✨(backend) let any authenticated user manage the lobby on trusted rooms

On rooms with the `trusted` access level, any authenticated user
connected to the meeting can now manage the lobby. Requested by
several organizations, and a step toward generalized lobby
management once hubs and groups land (same organization only).

Being authenticated is not enough to grant the capability: a
`trusted` room means "trusted to join", not "trusted to decide who
else joins from outside the call". The new `CanManageLobby`
permission therefore also requires the requester to be currently
connected to the meeting, verified against LiveKit and failing
closed, like `IsPresentInMeeting`. The access level itself is never
cached and always read fresh, so an owner switching the room back to
`restricted` revokes the capability on the very next request - the
one guarantee we did not want to trade for performance.

Performance is traded elsewhere: the waiting list is polled by every
lobby manager, and on a trusted room that audience grows from a few
admins to potentially the whole meeting. Hitting LiveKit once per
poll per participant would not survive that fan-out, so presence is
memoized in Redis (`PresenceCache`, `PRESENCE_CACHE_TIMEOUT`, 1h).
Entries are created lazily because only the minority of participants
who actually manage a lobby ever need one, and only positive answers
are cached because a sticky negative would lock out someone joining
right after a miss for the whole TTL. Eager invalidation on
`participant_left`, `room_finished` and admin kick keeps the cache
honest; the TTL is the safety net when an event is lost, and its
value bounds how long a departed participant could still act.

Trade-offs in this v0:

* `PRESENCE_CLEAR_ON_PARTICIPANT_LEFT` gates the eager invalidation
  on `participant_left`: its cost is one Redis DELETE per departure,
  for every departure, so we want to be able to measure it in
  production and turn it off independently of the feature. When
  disabled, invalidation relies on `room_finished` and the TTL only,
  widening the stale window above.
* This can put non-trivial pressure on the cache at scale; the
  rollout will need to be monitored closely.
* The `participant_left` webhook must be enabled in the LiveKit
  deployment, otherwise eager invalidation silently degrades to the
  TTL-only behavior.

src/backend/core/tests/rooms/test_api_rooms_lobby.py

@@ -389,7 +389,7 @@ def test_allow_participant_to_enter_anonymous():
 
 def test_allow_participant_to_enter_non_owner():
     """Non-privileged users should not be allowed to manage entry requests."""
-    room = RoomFactory()
+    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
     user = UserFactory()
     client = APIClient()
     client.force_login(user)
@@ -522,7 +522,7 @@ def test_list_waiting_participants_anonymous():
 
 def test_list_waiting_participants_non_owner():
     """Non-privileged users should not be allowed to list waiting participants."""
-    room = RoomFactory()
+    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
     user = UserFactory()
     client = APIClient()
     client.force_login(user)

src/backend/core/tests/rooms/test_api_rooms_lobby_trusted.py

@@ -0,0 +1,106 @@
+"""Trusted rooms: any authenticated participant present in the meeting can manage the lobby."""
+
+from unittest import mock
+
+import pytest
+from rest_framework.test import APIClient
+
+from core.factories import RoomFactory, UserFactory
+from core.models import RoomAccessLevel
+from core.services.presence import PresenceCache
+
+pytestmark = pytest.mark.django_db
+
+
+@mock.patch(
+    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
+)
+def test_trusted_room_present_user_can_list_waiting(mock_check):
+    """Authenticated + present in a trusted room -> 200, LiveKit asked once then cached."""
+    mock_check.return_value = True
+    user = UserFactory()
+    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
+    client = APIClient()
+    client.force_login(user)
+
+    url = f"/api/v1.0/rooms/{room.id}/waiting-participants/"
+    assert client.get(url).status_code == 200
+    assert client.get(url).status_code == 200
+    assert mock_check.call_count == 1
+
+
+@mock.patch(
+    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
+)
+def test_trusted_room_absent_user_forbidden(mock_check):
+    """Authenticated but not connected to the meeting -> 403."""
+    mock_check.return_value = False
+    user = UserFactory()
+    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
+    client = APIClient()
+    client.force_login(user)
+
+    response = client.get(f"/api/v1.0/rooms/{room.id}/waiting-participants/")
+    assert response.status_code == 403
+
+
+@mock.patch(
+    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
+)
+def test_restricted_room_present_user_forbidden(mock_check):
+    """Presence is not enough on a restricted room; LiveKit must not even be asked."""
+    user = UserFactory()
+    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
+    client = APIClient()
+    client.force_login(user)
+
+    response = client.get(f"/api/v1.0/rooms/{room.id}/waiting-participants/")
+    assert response.status_code == 403
+    mock_check.assert_not_called()
+
+
+@mock.patch(
+    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
+)
+def test_trusted_room_presence_cleared_after_leave(mock_check):
+    """Once the presence cache is cleared (participant_left), LiveKit is re-checked."""
+    mock_check.return_value = True
+    user = UserFactory()
+    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
+    client = APIClient()
+    client.force_login(user)
+    url = f"/api/v1.0/rooms/{room.id}/waiting-participants/"
+
+    assert client.get(url).status_code == 200
+    PresenceCache().clear(room.id, str(user.sub))
+
+    mock_check.return_value = False
+    assert client.get(url).status_code == 403
+    assert mock_check.call_count == 2
+
+
+def test_trusted_room_anonymous_forbidden():
+    """Anonymous users never manage the lobby."""
+    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
+    response = APIClient().get(f"/api/v1.0/rooms/{room.id}/waiting-participants/")
+    assert response.status_code == 401
+
+
+@mock.patch(
+    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
+)
+def test_trusted_room_present_user_can_accept_entry(mock_check):
+    """Authenticated + present in a trusted room can accept a waiting participant."""
+    mock_check.return_value = True
+    user = UserFactory()
+    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
+    client = APIClient()
+    client.force_login(user)
+
+    response = client.post(
+        f"/api/v1.0/rooms/{room.id}/enter/",
+        {"participant_id": "2f7f162f-e7d1-421b-90e7-02bfbfbf8def", "allow_entry": True},
+    )
+    # Permission passed; 404 because that participant isn't actually waiting.
+    assert response.status_code == 404
+    assert response.json() == {"message": "Participant not found."}

src/backend/core/tests/services/test_livekit_events.py

@@ -854,3 +854,31 @@ def test_receive_ignores_connection_test_room(
 
     mock_handle_room_started.assert_not_called()
     mock_handle_room_finished.assert_not_called()
+
+
+@mock.patch("core.services.presence.cache.delete")
+def test_participant_left_clearing_gated_by_setting(mock_delete, service, settings):
+    """PRESENCE_CLEAR_ON_PARTICIPANT_LEFT toggles eager presence invalidation."""
+    data = mock.Mock()
+    data.room.name = "room-name"
+    data.participant.identity = "user-sub"
+
+    settings.PRESENCE_CLEAR_ON_PARTICIPANT_LEFT = False
+    service._handle_participant_left(data)  # pylint: disable=protected-access
+    mock_delete.assert_not_called()
+
+    settings.PRESENCE_CLEAR_ON_PARTICIPANT_LEFT = True
+    service._handle_participant_left(data)  # pylint: disable=protected-access
+    mock_delete.assert_called_once()
+
+
+@mock.patch("core.services.presence.cache.delete")
+def test_participant_left_without_identity_is_ignored(mock_delete, service, settings):
+    """No cache operation when the webhook carries no identity."""
+    settings.PRESENCE_CLEAR_ON_PARTICIPANT_LEFT = True
+    data = mock.Mock()
+    data.room.name = "room-name"
+    data.participant.identity = ""
+
+    service._handle_participant_left(data)  # pylint: disable=protected-access
+    mock_delete.assert_not_called()

src/backend/core/tests/services/test_presence.py

@@ -0,0 +1,90 @@
+"""Tests for the presence cache and the cached presence check."""
+
+# pylint: disable=W0212
+
+from unittest import mock
+from uuid import uuid4
+
+from django.core.cache import cache
+
+import pytest
+
+from core.services.participants_management import (
+    ParticipantNotFoundException,
+    ParticipantsManagement,
+    ParticipantsManagementException,
+)
+from core.services.presence import PresenceCache
+
+
+@mock.patch(
+    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
+)
+def test_presence_cache_hit_skips_livekit(mock_check):
+    """A cached positive answer must not call LiveKit."""
+    room_id, identity = str(uuid4()), "user-sub"
+    PresenceCache().mark_present(room_id, identity)
+
+    assert (
+        ParticipantsManagement().check_if_in_meeting_cached(room_id, identity) is True
+    )
+    mock_check.assert_not_called()
+
+
+@mock.patch(
+    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
+)
+def test_presence_cache_miss_calls_livekit_and_caches_positive(mock_check):
+    """On a miss, LiveKit is asked once and a positive answer is memoized."""
+    mock_check.return_value = True
+    room_id, identity = str(uuid4()), "user-sub"
+    service = ParticipantsManagement()
+
+    assert service.check_if_in_meeting_cached(room_id, identity) is True
+    assert service.check_if_in_meeting_cached(room_id, identity) is True
+    assert mock_check.call_count == 1
+
+
+@mock.patch(
+    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
+)
+def test_presence_negative_not_cached(mock_check):
+    """Negative answers are never memoized."""
+    mock_check.return_value = False
+    room_id, identity = str(uuid4()), "user-sub"
+    service = ParticipantsManagement()
+
+    assert service.check_if_in_meeting_cached(room_id, identity) is False
+    assert service.check_if_in_meeting_cached(room_id, identity) is False
+    assert mock_check.call_count == 2
+
+
+@mock.patch(
+    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
+)
+def test_presence_errors_propagate_and_cache_nothing(mock_check):
+    """LiveKit errors propagate to the caller (which fails closed); nothing cached."""
+    room_id, identity = str(uuid4()), "user-sub"
+
+    for exc in (ParticipantNotFoundException(), ParticipantsManagementException()):
+        mock_check.side_effect = exc
+        with pytest.raises(type(exc)):
+            ParticipantsManagement().check_if_in_meeting_cached(room_id, identity)
+        assert cache.get(PresenceCache._get_cache_key(room_id, identity)) is None
+
+
+def test_presence_clear_and_clear_room():
+    """clear() removes one entry, clear_room() removes all entries of a room."""
+    room_id, other_room = str(uuid4()), str(uuid4())
+    presence = PresenceCache()
+    presence.mark_present(room_id, "a")
+    presence.mark_present(room_id, "b")
+    presence.mark_present(other_room, "a")
+
+    presence.clear(room_id, "a")
+    assert presence.is_marked_present(room_id, "a") is False
+    assert presence.is_marked_present(room_id, "b") is True
+
+    presence.clear_room(room_id)
+    assert presence.is_marked_present(room_id, "b") is False
+    assert presence.is_marked_present(other_room, "a") is True