fix: prevent presence race condition during WebRTC handshake

Add /joining and /joined endpoints to track user join intent before
WebRTC handshake completes. This prevents meetings from being
deactivated while users are still connecting.

- Add pending_joins Redis module with 30s TTL
- Add /joining endpoint (called before WebRTC handshake)
- Add /joined endpoint (called after connection established)
- Check for pending joins before deactivating meetings in worker
- Frontend integration with connectionId per browser tab

.github/workflows/test_next_server.yml

@@ -13,9 +13,6 @@ on:
 jobs:
   test-next-server:
     runs-on: ubuntu-latest
-    concurrency:
-      group: test-next-server-${{ github.ref }}
-      cancel-in-progress: true
 
     defaults:
       run:
@@ -24,12 +21,17 @@ jobs:
     steps:
     - uses: actions/checkout@v4
 
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20'
+
     - name: Install pnpm
       uses: pnpm/action-setup@v4
       with:
-        package_json_file: './www/package.json'
+        version: 8
 
-    - name: Setup Node.js
+    - name: Setup Node.js cache
       uses: actions/setup-node@v4
       with:
         node-version: '20'

server/reflector/db/calendar_events.py

@@ -104,26 +104,6 @@ class CalendarEventController:
         results = await get_database().fetch_all(query)
         return [CalendarEvent(**result) for result in results]
 
-    async def get_upcoming_for_rooms(
-        self, room_ids: list[str], minutes_ahead: int = 120
-    ) -> list[CalendarEvent]:
-        now = datetime.now(timezone.utc)
-        future_time = now + timedelta(minutes=minutes_ahead)
-        query = (
-            calendar_events.select()
-            .where(
-                sa.and_(
-                    calendar_events.c.room_id.in_(room_ids),
-                    calendar_events.c.is_deleted == False,
-                    calendar_events.c.start_time <= future_time,
-                    calendar_events.c.end_time >= now,
-                )
-            )
-            .order_by(calendar_events.c.start_time.asc())
-        )
-        results = await get_database().fetch_all(query)
-        return [CalendarEvent(**result) for result in results]
-
     async def get_by_id(self, event_id: str) -> CalendarEvent | None:
         query = calendar_events.select().where(calendar_events.c.id == event_id)
         result = await get_database().fetch_one(query)

server/reflector/db/meetings.py

@@ -301,23 +301,6 @@ class MeetingController:
         results = await get_database().fetch_all(query)
         return [Meeting(**result) for result in results]
 
-    async def get_all_active_for_rooms(
-        self, room_ids: list[str], current_time: datetime
-    ) -> list[Meeting]:
-        query = (
-            meetings.select()
-            .where(
-                sa.and_(
-                    meetings.c.room_id.in_(room_ids),
-                    meetings.c.end_date > current_time,
-                    meetings.c.is_active,
-                )
-            )
-            .order_by(meetings.c.end_date.desc())
-        )
-        results = await get_database().fetch_all(query)
-        return [Meeting(**result) for result in results]
-
     async def get_active_by_calendar_event(
         self, room: Room, calendar_event_id: str, current_time: datetime
     ) -> Meeting | None:

server/reflector/db/rooms.py

@@ -245,11 +245,6 @@ class RoomController:
 
         return room
 
-    async def get_by_names(self, names: list[str]) -> list[Room]:
-        query = rooms.select().where(rooms.c.name.in_(names))
-        results = await get_database().fetch_all(query)
-        return [Room(**r) for r in results]
-
     async def get_ics_enabled(self) -> list[Room]:
         query = rooms.select().where(
             rooms.c.ics_enabled == True, rooms.c.ics_url != None

server/reflector/presence/__init__.py

@@ -0,0 +1,17 @@
+"""Presence tracking for meetings."""
+
+from reflector.presence.pending_joins import (
+    PENDING_JOIN_PREFIX,
+    PENDING_JOIN_TTL,
+    create_pending_join,
+    delete_pending_join,
+    has_pending_joins,
+)
+
+__all__ = [
+    "PENDING_JOIN_PREFIX",
+    "PENDING_JOIN_TTL",
+    "create_pending_join",
+    "delete_pending_join",
+    "has_pending_joins",
+]

server/reflector/presence/pending_joins.py

@@ -0,0 +1,59 @@
+"""Track pending join intents in Redis.
+
+When a user signals intent to join a meeting (before WebRTC handshake completes),
+we store a pending join record. This prevents the meeting from being deactivated
+while users are still connecting.
+"""
+
+import time
+
+from redis.asyncio import Redis
+
+from reflector.logger import logger
+
+PENDING_JOIN_TTL = 30  # seconds
+PENDING_JOIN_PREFIX = "pending_join"
+# Max keys to scan per Redis SCAN iteration
+SCAN_BATCH_SIZE = 100
+
+
+async def create_pending_join(redis: Redis, meeting_id: str, user_id: str) -> None:
+    """Create a pending join record. Called before WebRTC handshake."""
+    key = f"{PENDING_JOIN_PREFIX}:{meeting_id}:{user_id}"
+    log = logger.bind(meeting_id=meeting_id, user_id=user_id, key=key)
+    await redis.setex(key, PENDING_JOIN_TTL, str(time.time()))
+    log.debug("Created pending join")
+
+
+async def delete_pending_join(redis: Redis, meeting_id: str, user_id: str) -> None:
+    """Delete pending join. Called after WebRTC connection established."""
+    key = f"{PENDING_JOIN_PREFIX}:{meeting_id}:{user_id}"
+    log = logger.bind(meeting_id=meeting_id, user_id=user_id, key=key)
+    await redis.delete(key)
+    log.debug("Deleted pending join")
+
+
+async def has_pending_joins(redis: Redis, meeting_id: str) -> bool:
+    """Check if meeting has any pending joins.
+
+    Uses Redis SCAN to iterate through all keys matching the pattern.
+    Properly iterates until cursor returns 0 to ensure all keys are checked.
+    """
+    pattern = f"{PENDING_JOIN_PREFIX}:{meeting_id}:*"
+    log = logger.bind(meeting_id=meeting_id, pattern=pattern)
+
+    cursor = 0
+    iterations = 0
+    while True:
+        cursor, keys = await redis.scan(
+            cursor=cursor, match=pattern, count=SCAN_BATCH_SIZE
+        )
+        iterations += 1
+        if keys:
+            log.debug("Found pending joins", count=len(keys), iterations=iterations)
+            return True
+        if cursor == 0:
+            break
+
+    log.debug("No pending joins found", iterations=iterations)
+    return False

server/reflector/views/rooms.py

@@ -1,6 +1,3 @@
-import asyncio
-import logging
-from collections import defaultdict
 from datetime import datetime, timedelta, timezone
 from enum import Enum
 from typing import Annotated, Any, Literal, Optional
@@ -8,25 +5,25 @@ from typing import Annotated, Any, Literal, Optional
 from fastapi import APIRouter, Depends, HTTPException
 from fastapi_pagination import Page
 from fastapi_pagination.ext.databases import apaginate
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 from redis.exceptions import LockError
 
 import reflector.auth as auth
 from reflector.db import get_database
 from reflector.db.calendar_events import calendar_events_controller
 from reflector.db.meetings import meetings_controller
-from reflector.db.rooms import Room as DbRoom
 from reflector.db.rooms import rooms_controller
-from reflector.redis_cache import RedisAsyncLock
+from reflector.logger import logger
+from reflector.presence.pending_joins import create_pending_join, delete_pending_join
+from reflector.redis_cache import RedisAsyncLock, get_async_redis_client
 from reflector.schemas.platform import Platform
 from reflector.services.ics_sync import ics_sync_service
 from reflector.settings import settings
+from reflector.utils.string import NonEmptyString
 from reflector.utils.url import add_query_param
 from reflector.video_platforms.factory import create_platform_client
 from reflector.worker.webhook import test_webhook
 
-logger = logging.getLogger(__name__)
-
 
 class Room(BaseModel):
     id: str
@@ -198,82 +195,6 @@ async def rooms_list(
     return paginated
 
 
-class BulkStatusRequest(BaseModel):
-    room_names: list[str] = Field(max_length=100)
-
-
-class RoomMeetingStatus(BaseModel):
-    active_meetings: list[Meeting]
-    upcoming_events: list[CalendarEventResponse]
-
-
-@router.post("/rooms/meetings/bulk-status", response_model=dict[str, RoomMeetingStatus])
-async def rooms_bulk_meeting_status(
-    request: BulkStatusRequest,
-    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
-):
-    if not user and not settings.PUBLIC_MODE:
-        raise HTTPException(status_code=401, detail="Not authenticated")
-
-    user_id = user["sub"] if user else None
-
-    all_rooms = await rooms_controller.get_by_names(request.room_names)
-    # Filter to rooms the user can see (owned or shared), matching rooms_list behavior
-    rooms = [
-        r
-        for r in all_rooms
-        if r.is_shared or (user_id is not None and r.user_id == user_id)
-    ]
-    room_by_id: dict[str, DbRoom] = {r.id: r for r in rooms}
-    room_ids = list(room_by_id.keys())
-
-    if not room_ids:
-        return {
-            name: RoomMeetingStatus(active_meetings=[], upcoming_events=[])
-            for name in request.room_names
-        }
-
-    current_time = datetime.now(timezone.utc)
-    active_meetings, upcoming_events = await asyncio.gather(
-        meetings_controller.get_all_active_for_rooms(room_ids, current_time),
-        calendar_events_controller.get_upcoming_for_rooms(room_ids),
-    )
-
-    # Group by room name, converting DB models to view models
-    active_by_room: dict[str, list[Meeting]] = defaultdict(list)
-    for m in active_meetings:
-        room = room_by_id.get(m.room_id)
-        if not room:
-            continue
-        m.platform = room.platform
-        if user_id != room.user_id and m.platform == "whereby":
-            m.host_room_url = ""
-        active_by_room[room.name].append(
-            Meeting.model_validate(m, from_attributes=True)
-        )
-
-    upcoming_by_room: dict[str, list[CalendarEventResponse]] = defaultdict(list)
-    for e in upcoming_events:
-        room = room_by_id.get(e.room_id)
-        if not room:
-            continue
-        if user_id != room.user_id:
-            e.description = None
-            e.attendees = None
-        upcoming_by_room[room.name].append(
-            CalendarEventResponse.model_validate(e, from_attributes=True)
-        )
-
-    result: dict[str, RoomMeetingStatus] = {}
-    for name in request.room_names:
-        result[name] = RoomMeetingStatus(
-            active_meetings=active_by_room.get(name, []),
-            upcoming_events=upcoming_by_room.get(name, []),
-        )
-
-    return result
-
-
 @router.get("/rooms/{room_id}", response_model=RoomDetails)
 async def rooms_get(
     room_id: str,
@@ -676,3 +597,112 @@ async def rooms_join_meeting(
         meeting.room_url = add_query_param(meeting.room_url, "t", token)
 
     return meeting
+
+
+class JoiningRequest(BaseModel):
+    """Request body for /joining and /joined endpoints."""
+
+    connection_id: NonEmptyString
+    """Unique identifier for this connection. Should be a UUID generated by the client.
+    Must be the same value for both /joining and /joined calls from the same tab."""
+
+
+class JoiningResponse(BaseModel):
+    status: Literal["ok"]
+
+
+def _get_pending_join_key(
+    user: Optional[auth.UserInfo], connection_id: NonEmptyString
+) -> str:
+    """Get a unique key for pending join tracking.
+
+    Uses user ID for authenticated users, connection_id for anonymous users.
+    This ensures each browser tab has its own unique pending join record.
+    """
+    if user:
+        return f"{user['sub']}:{connection_id}"
+    return f"anon:{connection_id}"
+
+
+@router.post(
+    "/rooms/{room_name}/meetings/{meeting_id}/joining", response_model=JoiningResponse
+)
+async def meeting_joining(
+    room_name: str,
+    meeting_id: str,
+    body: JoiningRequest,
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
+) -> JoiningResponse:
+    """Signal intent to join meeting. Called before WebRTC handshake starts.
+
+    This creates a pending join record that prevents the meeting from being
+    deactivated while the WebRTC handshake is in progress. The record expires
+    automatically after 30 seconds if the connection is not established.
+    """
+    log = logger.bind(
+        room_name=room_name, meeting_id=meeting_id, connection_id=body.connection_id
+    )
+
+    room = await rooms_controller.get_by_name(room_name)
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    meeting = await meetings_controller.get_by_id(meeting_id, room=room)
+    if not meeting:
+        raise HTTPException(status_code=404, detail="Meeting not found")
+
+    if not meeting.is_active:
+        raise HTTPException(status_code=400, detail="Meeting is not active")
+
+    join_key = _get_pending_join_key(user, body.connection_id)
+
+    redis = await get_async_redis_client()
+    try:
+        await create_pending_join(redis, meeting_id, join_key)
+        log.debug("Created pending join intent", join_key=join_key)
+    finally:
+        await redis.aclose()
+
+    return JoiningResponse(status="ok")
+
+
+@router.post(
+    "/rooms/{room_name}/meetings/{meeting_id}/joined", response_model=JoiningResponse
+)
+async def meeting_joined(
+    room_name: str,
+    meeting_id: str,
+    body: JoiningRequest,
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
+) -> JoiningResponse:
+    """Signal that WebRTC connection is established.
+
+    This clears the pending join record, confirming the user has successfully
+    connected to the meeting. Safe to call even if meeting was deactivated
+    during the handshake (idempotent cleanup).
+    """
+    log = logger.bind(
+        room_name=room_name, meeting_id=meeting_id, connection_id=body.connection_id
+    )
+
+    room = await rooms_controller.get_by_name(room_name)
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    meeting = await meetings_controller.get_by_id(meeting_id, room=room)
+    if not meeting:
+        raise HTTPException(status_code=404, detail="Meeting not found")
+
+    # Note: We don't check is_active here - the /joined call is a cleanup operation
+    # and should succeed even if the meeting was deactivated during the handshake
+
+    join_key = _get_pending_join_key(user, body.connection_id)
+
+    redis = await get_async_redis_client()
+    try:
+        await delete_pending_join(redis, meeting_id, join_key)
+        log.debug("Cleared pending join intent", join_key=join_key)
+    finally:
+        await redis.aclose()
+
+    return JoiningResponse(status="ok")

server/reflector/worker/process.py

@@ -31,9 +31,10 @@ from reflector.pipelines.main_multitrack_pipeline import (
     task_pipeline_multitrack_process,
 )
 from reflector.pipelines.topic_processing import EmptyPipeline
+from reflector.presence.pending_joins import has_pending_joins
 from reflector.processors import AudioFileWriterProcessor
 from reflector.processors.audio_waveform_processor import AudioWaveformProcessor
-from reflector.redis_cache import RedisAsyncLock
+from reflector.redis_cache import RedisAsyncLock, get_async_redis_client
 from reflector.settings import settings
 from reflector.storage import get_transcripts_storage
 from reflector.utils.daily import (
@@ -869,6 +870,18 @@ async def process_meetings():
                     logger_.debug("Meeting not yet started, keep it")
 
                 if should_deactivate:
+                    # Check for pending joins before deactivating
+                    # Users might be in the process of connecting via WebRTC
+                    redis = await get_async_redis_client()
+                    try:
+                        if await has_pending_joins(redis, meeting.id):
+                            logger_.info(
+                                "Meeting has pending joins, skipping deactivation"
+                            )
+                            continue
+                    finally:
+                        await redis.aclose()
+
                     await meetings_controller.update_meeting(
                         meeting.id, is_active=False
                     )

server/tests/test_joining_endpoint.py

@@ -0,0 +1,362 @@
+"""Integration tests for /joining and /joined endpoints.
+
+Tests for the join intent tracking to prevent race conditions during
+WebRTC handshake when users join meetings.
+"""
+
+from datetime import datetime, timedelta, timezone
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from reflector.db.meetings import Meeting
+from reflector.presence.pending_joins import PENDING_JOIN_PREFIX
+
+TEST_CONNECTION_ID = "test-connection-uuid-12345"
+
+
+@pytest.fixture
+def mock_room():
+    """Mock room object."""
+    from reflector.db.rooms import Room
+
+    return Room(
+        id="room-123",
+        name="test-room",
+        user_id="owner-user",
+        created_at=datetime.now(timezone.utc),
+        zulip_auto_post=False,
+        zulip_stream="",
+        zulip_topic="",
+        is_locked=False,
+        room_mode="normal",
+        recording_type="cloud",
+        recording_trigger="automatic",
+        is_shared=True,
+        platform="daily",
+        skip_consent=False,
+    )
+
+
+@pytest.fixture
+def mock_meeting():
+    """Mock meeting object."""
+    now = datetime.now(timezone.utc)
+    return Meeting(
+        id="meeting-456",
+        room_id="room-123",
+        room_name="test-room-20251118120000",
+        room_url="https://daily.co/test-room-20251118120000",
+        host_room_url="https://daily.co/test-room-20251118120000?t=host",
+        platform="daily",
+        num_clients=0,
+        is_active=True,
+        start_date=now,
+        end_date=now + timedelta(hours=1),
+    )
+
+
+@pytest.mark.asyncio
+@patch("reflector.views.rooms.rooms_controller.get_by_name")
+@patch("reflector.views.rooms.meetings_controller.get_by_id")
+@patch("reflector.views.rooms.get_async_redis_client")
+async def test_joining_endpoint_creates_pending_join(
+    mock_get_redis,
+    mock_get_meeting,
+    mock_get_room,
+    mock_room,
+    mock_meeting,
+    client,
+    authenticated_client,
+):
+    """Test that /joining endpoint creates pending join in Redis."""
+    mock_get_room.return_value = mock_room
+    mock_get_meeting.return_value = mock_meeting
+
+    mock_redis = AsyncMock()
+    mock_redis.setex = AsyncMock()
+    mock_redis.aclose = AsyncMock()
+    mock_get_redis.return_value = mock_redis
+
+    response = await client.post(
+        f"/rooms/{mock_room.name}/meetings/{mock_meeting.id}/joining",
+        json={"connection_id": TEST_CONNECTION_ID},
+    )
+
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+
+    # Verify Redis setex was called with correct key pattern
+    mock_redis.setex.assert_called_once()
+    call_args = mock_redis.setex.call_args[0]
+    assert call_args[0].startswith(f"{PENDING_JOIN_PREFIX}:{mock_meeting.id}:")
+    assert TEST_CONNECTION_ID in call_args[0]
+
+
+@pytest.mark.asyncio
+@patch("reflector.views.rooms.rooms_controller.get_by_name")
+@patch("reflector.views.rooms.meetings_controller.get_by_id")
+@patch("reflector.views.rooms.get_async_redis_client")
+async def test_joined_endpoint_deletes_pending_join(
+    mock_get_redis,
+    mock_get_meeting,
+    mock_get_room,
+    mock_room,
+    mock_meeting,
+    client,
+    authenticated_client,
+):
+    """Test that /joined endpoint deletes pending join from Redis."""
+    mock_get_room.return_value = mock_room
+    mock_get_meeting.return_value = mock_meeting
+
+    mock_redis = AsyncMock()
+    mock_redis.delete = AsyncMock()
+    mock_redis.aclose = AsyncMock()
+    mock_get_redis.return_value = mock_redis
+
+    response = await client.post(
+        f"/rooms/{mock_room.name}/meetings/{mock_meeting.id}/joined",
+        json={"connection_id": TEST_CONNECTION_ID},
+    )
+
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+
+    # Verify Redis delete was called with correct key pattern
+    mock_redis.delete.assert_called_once()
+    call_args = mock_redis.delete.call_args[0]
+    assert call_args[0].startswith(f"{PENDING_JOIN_PREFIX}:{mock_meeting.id}:")
+    assert TEST_CONNECTION_ID in call_args[0]
+
+
+@pytest.mark.asyncio
+@patch("reflector.views.rooms.rooms_controller.get_by_name")
+async def test_joining_endpoint_room_not_found(
+    mock_get_room,
+    client,
+    authenticated_client,
+):
+    """Test that /joining returns 404 when room not found."""
+    mock_get_room.return_value = None
+
+    response = await client.post(
+        "/rooms/nonexistent-room/meetings/meeting-123/joining",
+        json={"connection_id": TEST_CONNECTION_ID},
+    )
+
+    assert response.status_code == 404
+    assert response.json()["detail"] == "Room not found"
+
+
+@pytest.mark.asyncio
+@patch("reflector.views.rooms.rooms_controller.get_by_name")
+@patch("reflector.views.rooms.meetings_controller.get_by_id")
+async def test_joining_endpoint_meeting_not_found(
+    mock_get_meeting,
+    mock_get_room,
+    mock_room,
+    client,
+    authenticated_client,
+):
+    """Test that /joining returns 404 when meeting not found."""
+    mock_get_room.return_value = mock_room
+    mock_get_meeting.return_value = None
+
+    response = await client.post(
+        f"/rooms/{mock_room.name}/meetings/nonexistent-meeting/joining",
+        json={"connection_id": TEST_CONNECTION_ID},
+    )
+
+    assert response.status_code == 404
+    assert response.json()["detail"] == "Meeting not found"
+
+
+@pytest.mark.asyncio
+@patch("reflector.views.rooms.rooms_controller.get_by_name")
+@patch("reflector.views.rooms.meetings_controller.get_by_id")
+async def test_joining_endpoint_meeting_not_active(
+    mock_get_meeting,
+    mock_get_room,
+    mock_room,
+    mock_meeting,
+    client,
+    authenticated_client,
+):
+    """Test that /joining returns 400 when meeting is not active."""
+    mock_get_room.return_value = mock_room
+    inactive_meeting = mock_meeting.model_copy(update={"is_active": False})
+    mock_get_meeting.return_value = inactive_meeting
+
+    response = await client.post(
+        f"/rooms/{mock_room.name}/meetings/{mock_meeting.id}/joining",
+        json={"connection_id": TEST_CONNECTION_ID},
+    )
+
+    assert response.status_code == 400
+    assert response.json()["detail"] == "Meeting is not active"
+
+
+@pytest.mark.asyncio
+@patch("reflector.views.rooms.rooms_controller.get_by_name")
+@patch("reflector.views.rooms.meetings_controller.get_by_id")
+@patch("reflector.views.rooms.get_async_redis_client")
+async def test_joining_endpoint_anonymous_user(
+    mock_get_redis,
+    mock_get_meeting,
+    mock_get_room,
+    mock_room,
+    mock_meeting,
+    client,
+):
+    """Test that /joining works for anonymous users with unique connection_id."""
+    mock_get_room.return_value = mock_room
+    mock_get_meeting.return_value = mock_meeting
+
+    mock_redis = AsyncMock()
+    mock_redis.setex = AsyncMock()
+    mock_redis.aclose = AsyncMock()
+    mock_get_redis.return_value = mock_redis
+
+    response = await client.post(
+        f"/rooms/{mock_room.name}/meetings/{mock_meeting.id}/joining",
+        json={"connection_id": TEST_CONNECTION_ID},
+    )
+
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+
+    # Verify Redis setex was called with "anon:" prefix and connection_id
+    call_args = mock_redis.setex.call_args[0]
+    assert ":anon:" in call_args[0]
+    assert TEST_CONNECTION_ID in call_args[0]
+
+
+@pytest.mark.asyncio
+@patch("reflector.views.rooms.rooms_controller.get_by_name")
+@patch("reflector.views.rooms.meetings_controller.get_by_id")
+@patch("reflector.views.rooms.get_async_redis_client")
+async def test_joining_endpoint_redis_closed_on_success(
+    mock_get_redis,
+    mock_get_meeting,
+    mock_get_room,
+    mock_room,
+    mock_meeting,
+    client,
+    authenticated_client,
+):
+    """Test that Redis connection is closed after successful operation."""
+    mock_get_room.return_value = mock_room
+    mock_get_meeting.return_value = mock_meeting
+
+    mock_redis = AsyncMock()
+    mock_redis.setex = AsyncMock()
+    mock_redis.aclose = AsyncMock()
+    mock_get_redis.return_value = mock_redis
+
+    await client.post(
+        f"/rooms/{mock_room.name}/meetings/{mock_meeting.id}/joining",
+        json={"connection_id": TEST_CONNECTION_ID},
+    )
+
+    mock_redis.aclose.assert_called_once()
+
+
+@pytest.mark.asyncio
+@patch("reflector.views.rooms.rooms_controller.get_by_name")
+@patch("reflector.views.rooms.meetings_controller.get_by_id")
+@patch("reflector.views.rooms.get_async_redis_client")
+async def test_joining_endpoint_redis_closed_on_error(
+    mock_get_redis,
+    mock_get_meeting,
+    mock_get_room,
+    mock_room,
+    mock_meeting,
+    client,
+    authenticated_client,
+):
+    """Test that Redis connection is closed even when operation fails."""
+    mock_get_room.return_value = mock_room
+    mock_get_meeting.return_value = mock_meeting
+
+    mock_redis = AsyncMock()
+    mock_redis.setex = AsyncMock(side_effect=Exception("Redis error"))
+    mock_redis.aclose = AsyncMock()
+    mock_get_redis.return_value = mock_redis
+
+    with pytest.raises(Exception):
+        await client.post(
+            f"/rooms/{mock_room.name}/meetings/{mock_meeting.id}/joining",
+            json={"connection_id": TEST_CONNECTION_ID},
+        )
+
+    mock_redis.aclose.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_joining_endpoint_requires_connection_id(
+    client,
+):
+    """Test that /joining returns 422 when connection_id is missing."""
+    response = await client.post(
+        "/rooms/test-room/meetings/meeting-123/joining",
+        json={},
+    )
+
+    assert response.status_code == 422  # Validation error
+
+
+@pytest.mark.asyncio
+async def test_joining_endpoint_rejects_empty_connection_id(
+    client,
+):
+    """Test that /joining returns 422 when connection_id is empty string."""
+    response = await client.post(
+        "/rooms/test-room/meetings/meeting-123/joining",
+        json={"connection_id": ""},
+    )
+
+    assert response.status_code == 422  # Validation error (NonEmptyString)
+
+
+@pytest.mark.asyncio
+@patch("reflector.views.rooms.rooms_controller.get_by_name")
+@patch("reflector.views.rooms.meetings_controller.get_by_id")
+@patch("reflector.views.rooms.get_async_redis_client")
+async def test_different_connection_ids_create_different_keys(
+    mock_get_redis,
+    mock_get_meeting,
+    mock_get_room,
+    mock_room,
+    mock_meeting,
+    client,
+):
+    """Test that different connection_ids create different Redis keys."""
+    mock_get_room.return_value = mock_room
+    mock_get_meeting.return_value = mock_meeting
+
+    mock_redis = AsyncMock()
+    mock_redis.setex = AsyncMock()
+    mock_redis.aclose = AsyncMock()
+    mock_get_redis.return_value = mock_redis
+
+    # First connection
+    await client.post(
+        f"/rooms/{mock_room.name}/meetings/{mock_meeting.id}/joining",
+        json={"connection_id": "connection-1"},
+    )
+    key1 = mock_redis.setex.call_args[0][0]
+
+    mock_redis.setex.reset_mock()
+
+    # Second connection (different tab)
+    await client.post(
+        f"/rooms/{mock_room.name}/meetings/{mock_meeting.id}/joining",
+        json={"connection_id": "connection-2"},
+    )
+    key2 = mock_redis.setex.call_args[0][0]
+
+    # Keys should be different
+    assert key1 != key2
+    assert "connection-1" in key1
+    assert "connection-2" in key2

server/tests/test_pending_joins.py

@@ -0,0 +1,153 @@
+"""Tests for pending joins Redis helper functions.
+
+TDD tests for tracking join intent to prevent race conditions during
+WebRTC handshake when users join meetings.
+"""
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from reflector.presence.pending_joins import (
+    PENDING_JOIN_PREFIX,
+    PENDING_JOIN_TTL,
+    create_pending_join,
+    delete_pending_join,
+    has_pending_joins,
+)
+
+
+@pytest.fixture
+def mock_redis():
+    """Mock async Redis client."""
+    redis = AsyncMock()
+    redis.setex = AsyncMock()
+    redis.delete = AsyncMock()
+    redis.scan = AsyncMock(return_value=(0, []))
+    return redis
+
+
+@pytest.mark.asyncio
+async def test_create_pending_join_sets_key_with_ttl(mock_redis):
+    """Test that create_pending_join stores key with correct TTL."""
+    meeting_id = "meeting-123"
+    user_id = "user-456"
+
+    await create_pending_join(mock_redis, meeting_id, user_id)
+
+    expected_key = f"{PENDING_JOIN_PREFIX}:{meeting_id}:{user_id}"
+    mock_redis.setex.assert_called_once()
+    call_args = mock_redis.setex.call_args
+    assert call_args[0][0] == expected_key
+    assert call_args[0][1] == PENDING_JOIN_TTL
+    # Value should be a timestamp string
+    assert call_args[0][2] is not None
+
+
+@pytest.mark.asyncio
+async def test_delete_pending_join_removes_key(mock_redis):
+    """Test that delete_pending_join removes the key."""
+    meeting_id = "meeting-123"
+    user_id = "user-456"
+
+    await delete_pending_join(mock_redis, meeting_id, user_id)
+
+    expected_key = f"{PENDING_JOIN_PREFIX}:{meeting_id}:{user_id}"
+    mock_redis.delete.assert_called_once_with(expected_key)
+
+
+@pytest.mark.asyncio
+async def test_has_pending_joins_returns_false_when_no_keys(mock_redis):
+    """Test has_pending_joins returns False when no matching keys."""
+    mock_redis.scan.return_value = (0, [])
+
+    result = await has_pending_joins(mock_redis, "meeting-123")
+
+    assert result is False
+    mock_redis.scan.assert_called_once()
+    call_kwargs = mock_redis.scan.call_args.kwargs
+    assert call_kwargs["match"] == f"{PENDING_JOIN_PREFIX}:meeting-123:*"
+
+
+@pytest.mark.asyncio
+async def test_has_pending_joins_returns_true_when_keys_exist(mock_redis):
+    """Test has_pending_joins returns True when matching keys found."""
+    mock_redis.scan.return_value = (0, [b"pending_join:meeting-123:user-1"])
+
+    result = await has_pending_joins(mock_redis, "meeting-123")
+
+    assert result is True
+
+
+@pytest.mark.asyncio
+async def test_has_pending_joins_scans_with_correct_pattern(mock_redis):
+    """Test has_pending_joins uses correct scan pattern."""
+    meeting_id = "meeting-abc-def"
+    mock_redis.scan.return_value = (0, [])
+
+    await has_pending_joins(mock_redis, meeting_id)
+
+    expected_pattern = f"{PENDING_JOIN_PREFIX}:{meeting_id}:*"
+    mock_redis.scan.assert_called_once()
+    call_kwargs = mock_redis.scan.call_args.kwargs
+    assert call_kwargs["match"] == expected_pattern
+    assert call_kwargs["count"] == 100
+
+
+@pytest.mark.asyncio
+async def test_multiple_users_pending_joins(mock_redis):
+    """Test that multiple users can have pending joins for same meeting."""
+    meeting_id = "meeting-123"
+    # Simulate two pending joins
+    mock_redis.scan.return_value = (
+        0,
+        [b"pending_join:meeting-123:user-1", b"pending_join:meeting-123:user-2"],
+    )
+
+    result = await has_pending_joins(mock_redis, meeting_id)
+
+    assert result is True
+
+
+@pytest.mark.asyncio
+async def test_pending_join_ttl_value():
+    """Test that PENDING_JOIN_TTL has expected value."""
+    # 30 seconds should be enough for WebRTC handshake but not too long
+    assert PENDING_JOIN_TTL == 30
+
+
+@pytest.mark.asyncio
+async def test_pending_join_prefix_value():
+    """Test that PENDING_JOIN_PREFIX has expected value."""
+    assert PENDING_JOIN_PREFIX == "pending_join"
+
+
+@pytest.mark.asyncio
+async def test_has_pending_joins_multi_iteration_scan_no_keys(mock_redis):
+    """Test has_pending_joins iterates until cursor returns 0."""
+    # Simulate multi-iteration scan: cursor 100 -> cursor 50 -> cursor 0
+    mock_redis.scan.side_effect = [
+        (100, []),  # First iteration, no keys, continue
+        (50, []),  # Second iteration, no keys, continue
+        (0, []),  # Third iteration, cursor 0, done
+    ]
+
+    result = await has_pending_joins(mock_redis, "meeting-123")
+
+    assert result is False
+    assert mock_redis.scan.call_count == 3
+
+
+@pytest.mark.asyncio
+async def test_has_pending_joins_multi_iteration_finds_key_later(mock_redis):
+    """Test has_pending_joins finds key on second iteration."""
+    # Simulate finding key on second scan iteration
+    mock_redis.scan.side_effect = [
+        (100, []),  # First iteration, no keys
+        (0, [b"pending_join:meeting-123:user-1"]),  # Second iteration, found key
+    ]
+
+    result = await has_pending_joins(mock_redis, "meeting-123")
+
+    assert result is True
+    assert mock_redis.scan.call_count == 2

server/tests/test_process_meetings_pending_joins.py

@@ -0,0 +1,241 @@
+"""Tests for process_meetings pending joins check.
+
+Tests that process_meetings correctly skips deactivation when
+pending joins exist for a meeting.
+"""
+
+from datetime import datetime, timedelta, timezone
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from reflector.db.meetings import Meeting
+
+
+def _get_process_meetings_fn():
+    """Get the underlying async function without Celery/asynctask decorators."""
+    from reflector.worker import process
+
+    fn = process.process_meetings
+    # Get through both decorator layers (@shared_task and @asynctask)
+    if hasattr(fn, "__wrapped__"):
+        fn = fn.__wrapped__
+    if hasattr(fn, "__wrapped__"):
+        fn = fn.__wrapped__
+    return fn
+
+
+@pytest.fixture
+def mock_active_meeting():
+    """Mock an active meeting that should be considered for deactivation."""
+    now = datetime.now(timezone.utc)
+    return Meeting(
+        id="meeting-123",
+        room_id="room-456",
+        room_name="test-room-20251118120000",
+        room_url="https://daily.co/test-room-20251118120000",
+        host_room_url="https://daily.co/test-room-20251118120000?t=host",
+        platform="daily",
+        num_clients=0,
+        is_active=True,
+        start_date=now - timedelta(hours=1),
+        end_date=now - timedelta(minutes=30),  # Already ended
+    )
+
+
+@pytest.mark.asyncio
+@patch("reflector.worker.process.meetings_controller.get_all_active")
+@patch("reflector.worker.process.RedisAsyncLock")
+@patch("reflector.worker.process.create_platform_client")
+@patch("reflector.worker.process.get_async_redis_client")
+@patch("reflector.worker.process.has_pending_joins")
+@patch("reflector.worker.process.meetings_controller.update_meeting")
+async def test_process_meetings_skips_deactivation_with_pending_joins(
+    mock_update_meeting,
+    mock_has_pending_joins,
+    mock_get_redis,
+    mock_create_client,
+    mock_redis_lock_class,
+    mock_get_all_active,
+    mock_active_meeting,
+):
+    """Test that process_meetings skips deactivation when pending joins exist."""
+    process_meetings = _get_process_meetings_fn()
+
+    mock_get_all_active.return_value = [mock_active_meeting]
+
+    # Mock lock acquired
+    mock_lock_instance = AsyncMock()
+    mock_lock_instance.acquired = True
+    mock_lock_instance.__aenter__ = AsyncMock(return_value=mock_lock_instance)
+    mock_lock_instance.__aexit__ = AsyncMock()
+    mock_redis_lock_class.return_value = mock_lock_instance
+
+    # Mock platform client - no active sessions, but had sessions (triggers deactivation)
+    mock_daily_client = AsyncMock()
+    mock_session = AsyncMock()
+    mock_session.ended_at = datetime.now(timezone.utc)  # Session ended
+    mock_daily_client.get_room_sessions = AsyncMock(return_value=[mock_session])
+    mock_create_client.return_value = mock_daily_client
+
+    # Mock Redis client
+    mock_redis = AsyncMock()
+    mock_redis.aclose = AsyncMock()
+    mock_get_redis.return_value = mock_redis
+
+    # Mock pending joins exist
+    mock_has_pending_joins.return_value = True
+
+    await process_meetings()
+
+    # Verify has_pending_joins was called
+    mock_has_pending_joins.assert_called_once_with(mock_redis, mock_active_meeting.id)
+
+    # Verify meeting was NOT deactivated
+    mock_update_meeting.assert_not_called()
+
+    # Verify Redis was closed
+    mock_redis.aclose.assert_called_once()
+
+
+@pytest.mark.asyncio
+@patch("reflector.worker.process.meetings_controller.get_all_active")
+@patch("reflector.worker.process.RedisAsyncLock")
+@patch("reflector.worker.process.create_platform_client")
+@patch("reflector.worker.process.get_async_redis_client")
+@patch("reflector.worker.process.has_pending_joins")
+@patch("reflector.worker.process.meetings_controller.update_meeting")
+async def test_process_meetings_deactivates_without_pending_joins(
+    mock_update_meeting,
+    mock_has_pending_joins,
+    mock_get_redis,
+    mock_create_client,
+    mock_redis_lock_class,
+    mock_get_all_active,
+    mock_active_meeting,
+):
+    """Test that process_meetings deactivates when no pending joins."""
+    process_meetings = _get_process_meetings_fn()
+
+    mock_get_all_active.return_value = [mock_active_meeting]
+
+    # Mock lock acquired
+    mock_lock_instance = AsyncMock()
+    mock_lock_instance.acquired = True
+    mock_lock_instance.__aenter__ = AsyncMock(return_value=mock_lock_instance)
+    mock_lock_instance.__aexit__ = AsyncMock()
+    mock_redis_lock_class.return_value = mock_lock_instance
+
+    # Mock platform client - no active sessions, but had sessions
+    mock_daily_client = AsyncMock()
+    mock_session = AsyncMock()
+    mock_session.ended_at = datetime.now(timezone.utc)
+    mock_daily_client.get_room_sessions = AsyncMock(return_value=[mock_session])
+    mock_create_client.return_value = mock_daily_client
+
+    # Mock Redis client
+    mock_redis = AsyncMock()
+    mock_redis.aclose = AsyncMock()
+    mock_get_redis.return_value = mock_redis
+
+    # Mock no pending joins
+    mock_has_pending_joins.return_value = False
+
+    await process_meetings()
+
+    # Verify meeting was deactivated
+    mock_update_meeting.assert_called_once_with(mock_active_meeting.id, is_active=False)
+
+
+@pytest.mark.asyncio
+@patch("reflector.worker.process.meetings_controller.get_all_active")
+@patch("reflector.worker.process.RedisAsyncLock")
+@patch("reflector.worker.process.create_platform_client")
+async def test_process_meetings_no_check_when_active_sessions(
+    mock_create_client,
+    mock_redis_lock_class,
+    mock_get_all_active,
+    mock_active_meeting,
+):
+    """Test that pending joins check is skipped when there are active sessions."""
+    process_meetings = _get_process_meetings_fn()
+
+    mock_get_all_active.return_value = [mock_active_meeting]
+
+    # Mock lock acquired
+    mock_lock_instance = AsyncMock()
+    mock_lock_instance.acquired = True
+    mock_lock_instance.__aenter__ = AsyncMock(return_value=mock_lock_instance)
+    mock_lock_instance.__aexit__ = AsyncMock()
+    mock_redis_lock_class.return_value = mock_lock_instance
+
+    # Mock platform client - has active session
+    mock_daily_client = AsyncMock()
+    mock_session = AsyncMock()
+    mock_session.ended_at = None  # Still active
+    mock_daily_client.get_room_sessions = AsyncMock(return_value=[mock_session])
+    mock_create_client.return_value = mock_daily_client
+
+    with (
+        patch("reflector.worker.process.get_async_redis_client") as mock_get_redis,
+        patch("reflector.worker.process.has_pending_joins") as mock_has_pending_joins,
+        patch(
+            "reflector.worker.process.meetings_controller.update_meeting"
+        ) as mock_update_meeting,
+    ):
+        await process_meetings()
+
+        # Verify pending joins check was NOT called (no need - active sessions exist)
+        mock_has_pending_joins.assert_not_called()
+
+        # Verify meeting was NOT deactivated
+        mock_update_meeting.assert_not_called()
+
+
+@pytest.mark.asyncio
+@patch("reflector.worker.process.meetings_controller.get_all_active")
+@patch("reflector.worker.process.RedisAsyncLock")
+@patch("reflector.worker.process.create_platform_client")
+@patch("reflector.worker.process.get_async_redis_client")
+@patch("reflector.worker.process.has_pending_joins")
+@patch("reflector.worker.process.meetings_controller.update_meeting")
+async def test_process_meetings_closes_redis_even_on_continue(
+    mock_update_meeting,
+    mock_has_pending_joins,
+    mock_get_redis,
+    mock_create_client,
+    mock_redis_lock_class,
+    mock_get_all_active,
+    mock_active_meeting,
+):
+    """Test that Redis connection is always closed, even when skipping deactivation."""
+    process_meetings = _get_process_meetings_fn()
+
+    mock_get_all_active.return_value = [mock_active_meeting]
+
+    # Mock lock acquired
+    mock_lock_instance = AsyncMock()
+    mock_lock_instance.acquired = True
+    mock_lock_instance.__aenter__ = AsyncMock(return_value=mock_lock_instance)
+    mock_lock_instance.__aexit__ = AsyncMock()
+    mock_redis_lock_class.return_value = mock_lock_instance
+
+    # Mock platform client - no active sessions
+    mock_daily_client = AsyncMock()
+    mock_session = AsyncMock()
+    mock_session.ended_at = datetime.now(timezone.utc)
+    mock_daily_client.get_room_sessions = AsyncMock(return_value=[mock_session])
+    mock_create_client.return_value = mock_daily_client
+
+    # Mock Redis client
+    mock_redis = AsyncMock()
+    mock_redis.aclose = AsyncMock()
+    mock_get_redis.return_value = mock_redis
+
+    # Mock pending joins exist (will trigger continue)
+    mock_has_pending_joins.return_value = True
+
+    await process_meetings()
+
+    # Verify Redis was closed
+    mock_redis.aclose.assert_called_once()

server/tests/test_rooms_bulk_status.py

@@ -1,184 +0,0 @@
-from datetime import datetime, timedelta, timezone
-
-import pytest
-from conftest import authenticated_client_ctx
-
-from reflector.db.calendar_events import CalendarEvent, calendar_events_controller
-from reflector.db.meetings import meetings_controller
-from reflector.db.rooms import Room, rooms_controller
-from reflector.settings import settings
-
-
-async def _create_room(name: str, user_id: str, is_shared: bool = False) -> Room:
-    return await rooms_controller.add(
-        name=name,
-        user_id=user_id,
-        zulip_auto_post=False,
-        zulip_stream="",
-        zulip_topic="",
-        is_locked=False,
-        room_mode="normal",
-        recording_type="cloud",
-        recording_trigger="automatic-2nd-participant",
-        is_shared=is_shared,
-        webhook_url="",
-        webhook_secret="",
-    )
-
-
-async def _create_meeting(room: Room, active: bool = True):
-    now = datetime.now(timezone.utc)
-    return await meetings_controller.create(
-        id=f"meeting-{room.name}-{now.timestamp()}",
-        room_name=room.name,
-        room_url="room-url",
-        host_room_url="host-url",
-        start_date=now - timedelta(minutes=10),
-        end_date=now + timedelta(minutes=50) if active else now - timedelta(minutes=1),
-        room=room,
-    )
-
-
-async def _create_calendar_event(room: Room):
-    now = datetime.now(timezone.utc)
-    return await calendar_events_controller.upsert(
-        CalendarEvent(
-            room_id=room.id,
-            ics_uid=f"event-{room.name}",
-            title=f"Upcoming in {room.name}",
-            description="secret description",
-            start_time=now + timedelta(minutes=30),
-            end_time=now + timedelta(minutes=90),
-            attendees=[{"name": "Alice", "email": "alice@example.com"}],
-        )
-    )
-
-
-@pytest.mark.asyncio
-async def test_bulk_status_returns_empty_for_no_rooms(client):
-    """Empty room_names returns empty dict."""
-    async with authenticated_client_ctx():
-        resp = await client.post("/rooms/meetings/bulk-status", json={"room_names": []})
-    assert resp.status_code == 200
-    assert resp.json() == {}
-
-
-@pytest.mark.asyncio
-async def test_bulk_status_returns_active_meetings_and_upcoming_events(client):
-    """Owner sees active meetings and upcoming events for their rooms."""
-    room = await _create_room("bulk-test-room", "randomuserid")
-    await _create_meeting(room, active=True)
-    await _create_calendar_event(room)
-
-    async with authenticated_client_ctx():
-        resp = await client.post(
-            "/rooms/meetings/bulk-status",
-            json={"room_names": ["bulk-test-room"]},
-        )
-
-    assert resp.status_code == 200
-    data = resp.json()
-    assert "bulk-test-room" in data
-    status = data["bulk-test-room"]
-    assert len(status["active_meetings"]) == 1
-    assert len(status["upcoming_events"]) == 1
-    # Owner sees description
-    assert status["upcoming_events"][0]["description"] == "secret description"
-
-
-@pytest.mark.asyncio
-async def test_bulk_status_redacts_data_for_non_owner(client):
-    """Non-owner of a shared room gets redacted calendar events and no whereby host_room_url."""
-    room = await _create_room("shared-bulk", "other-user-id", is_shared=True)
-    await _create_meeting(room, active=True)
-    await _create_calendar_event(room)
-
-    # authenticated as "randomuserid" but room owned by "other-user-id"
-    async with authenticated_client_ctx():
-        resp = await client.post(
-            "/rooms/meetings/bulk-status",
-            json={"room_names": ["shared-bulk"]},
-        )
-
-    assert resp.status_code == 200
-    status = resp.json()["shared-bulk"]
-    assert len(status["active_meetings"]) == 1
-    assert len(status["upcoming_events"]) == 1
-    # Non-owner: description and attendees redacted
-    assert status["upcoming_events"][0]["description"] is None
-    assert status["upcoming_events"][0]["attendees"] is None
-
-
-@pytest.mark.asyncio
-async def test_bulk_status_filters_private_rooms_of_other_users(client):
-    """User cannot see private rooms owned by others."""
-    await _create_room("private-other", "other-user-id", is_shared=False)
-
-    async with authenticated_client_ctx():
-        resp = await client.post(
-            "/rooms/meetings/bulk-status",
-            json={"room_names": ["private-other"]},
-        )
-
-    assert resp.status_code == 200
-    status = resp.json()["private-other"]
-    assert status["active_meetings"] == []
-    assert status["upcoming_events"] == []
-
-
-@pytest.mark.asyncio
-async def test_bulk_status_redacts_whereby_host_room_url_for_non_owner(client):
-    """Non-owner of a shared whereby room gets empty host_room_url."""
-    room = await _create_room("shared-whereby", "other-user-id", is_shared=True)
-    # Force platform to whereby
-    from reflector.db import get_database
-    from reflector.db.rooms import rooms as rooms_table
-
-    await get_database().execute(
-        rooms_table.update()
-        .where(rooms_table.c.id == room.id)
-        .values(platform="whereby")
-    )
-
-    await _create_meeting(room, active=True)
-
-    async with authenticated_client_ctx():
-        resp = await client.post(
-            "/rooms/meetings/bulk-status",
-            json={"room_names": ["shared-whereby"]},
-        )
-
-    assert resp.status_code == 200
-    status = resp.json()["shared-whereby"]
-    assert len(status["active_meetings"]) == 1
-    assert status["active_meetings"][0]["host_room_url"] == ""
-
-
-@pytest.mark.asyncio
-async def test_bulk_status_unauthenticated_rejected_non_public(client):
-    """Unauthenticated request on non-PUBLIC_MODE instance returns 401."""
-    original = settings.PUBLIC_MODE
-    try:
-        settings.PUBLIC_MODE = False
-        resp = await client.post(
-            "/rooms/meetings/bulk-status",
-            json={"room_names": ["any-room"]},
-        )
-        assert resp.status_code == 401
-    finally:
-        settings.PUBLIC_MODE = original
-
-
-@pytest.mark.asyncio
-async def test_bulk_status_nonexistent_room_returns_empty(client):
-    """Requesting a room that doesn't exist returns empty lists."""
-    async with authenticated_client_ctx():
-        resp = await client.post(
-            "/rooms/meetings/bulk-status",
-            json={"room_names": ["does-not-exist"]},
-        )
-
-    assert resp.status_code == 200
-    status = resp.json()["does-not-exist"]
-    assert status["active_meetings"] == []
-    assert status["upcoming_events"] == []

www/app/(app)/rooms/_components/RoomList.tsx

@@ -1,10 +1,5 @@
-import { useMemo } from "react";
 import { Box, Heading, Text, VStack } from "@chakra-ui/react";
 import type { components } from "../../../reflector-api";
-import {
-  useRoomsBulkMeetingStatus,
-  BulkMeetingStatusMap,
-} from "../../../lib/apiHooks";
 
 type Room = components["schemas"]["Room"];
 import { RoomTable } from "./RoomTable";
@@ -36,10 +31,6 @@ export function RoomList({
   pt,
   loading,
 }: RoomListProps) {
-  const roomNames = useMemo(() => rooms.map((r) => r.name), [rooms]);
-  const bulkStatusQuery = useRoomsBulkMeetingStatus(roomNames);
-  const meetingStatusMap: BulkMeetingStatusMap = bulkStatusQuery.data ?? {};
-
   return (
     <VStack alignItems="start" gap={4} mb={mb} pt={pt}>
       <Heading size="md">{title}</Heading>
@@ -52,8 +43,6 @@ export function RoomList({
             onEdit={onEdit}
             onDelete={onDelete}
             loading={loading}
-            meetingStatusMap={meetingStatusMap}
-            meetingStatusLoading={bulkStatusQuery.isLoading}
           />
           <RoomCards
             rooms={rooms}

www/app/(app)/rooms/_components/RoomTable.tsx

@@ -14,7 +14,11 @@ import {
 import { LuLink, LuRefreshCw } from "react-icons/lu";
 import { FaCalendarAlt } from "react-icons/fa";
 import type { components } from "../../../reflector-api";
-import { useRoomIcsSync, BulkMeetingStatusMap } from "../../../lib/apiHooks";
+import {
+  useRoomActiveMeetings,
+  useRoomUpcomingMeetings,
+  useRoomIcsSync,
+} from "../../../lib/apiHooks";
 
 type Room = components["schemas"]["Room"];
 type Meeting = components["schemas"]["Meeting"];
@@ -58,8 +62,6 @@ interface RoomTableProps {
   onEdit: (roomId: string, roomData: any) => void;
   onDelete: (roomId: string) => void;
   loading?: boolean;
-  meetingStatusMap: BulkMeetingStatusMap;
-  meetingStatusLoading: boolean;
 }
 
 const getRoomModeDisplay = (mode: string): string => {
@@ -102,16 +104,14 @@ const getZulipDisplay = (
   return "Enabled";
 };
 
-function MeetingStatus({
+function MeetingStatus({ roomName }: { roomName: string }) {
-  activeMeetings,
+  const activeMeetingsQuery = useRoomActiveMeetings(roomName);
-  upcomingMeetings,
+  const upcomingMeetingsQuery = useRoomUpcomingMeetings(roomName);
-  isLoading,
+
-}: {
+  const activeMeetings = activeMeetingsQuery.data || [];
-  activeMeetings: Meeting[];
+  const upcomingMeetings = upcomingMeetingsQuery.data || [];
-  upcomingMeetings: CalendarEventResponse[];
+
-  isLoading: boolean;
+  if (activeMeetingsQuery.isLoading || upcomingMeetingsQuery.isLoading) {
-}) {
-  if (isLoading) {
     return <Spinner size="sm" />;
   }
 
@@ -176,8 +176,6 @@ export function RoomTable({
   onEdit,
   onDelete,
   loading,
-  meetingStatusMap,
-  meetingStatusLoading,
 }: RoomTableProps) {
   const [syncingRooms, setSyncingRooms] = useState<Set<NonEmptyString>>(
     new Set(),
@@ -254,15 +252,7 @@ export function RoomTable({
                   <Link href={`/${room.name}`}>{room.name}</Link>
                 </Table.Cell>
                 <Table.Cell>
-                  <MeetingStatus
+                  <MeetingStatus roomName={room.name} />
-                    activeMeetings={
-                      meetingStatusMap[room.name]?.active_meetings ?? []
-                    }
-                    upcomingMeetings={
-                      meetingStatusMap[room.name]?.upcoming_events ?? []
-                    }
-                    isLoading={meetingStatusLoading}
-                  />
                 </Table.Cell>
                 <Table.Cell>
                   {getZulipDisplay(

www/app/[roomName]/components/DailyRoom.tsx

@@ -25,6 +25,8 @@ import { useConsentDialog } from "../../lib/consent";
 import {
   useRoomJoinMeeting,
   useMeetingStartRecording,
+  useMeetingJoining,
+  useMeetingJoined,
 } from "../../lib/apiHooks";
 import { omit } from "remeda";
 import {
@@ -187,8 +189,14 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
   const [container, setContainer] = useState<HTMLDivElement | null>(null);
   const joinMutation = useRoomJoinMeeting();
   const startRecordingMutation = useMeetingStartRecording();
+  const joiningMutation = useMeetingJoining();
+  const joinedMutation = useMeetingJoined();
   const [joinedMeeting, setJoinedMeeting] = useState<Meeting | null>(null);
 
+  // Generate a stable connection ID for this component instance
+  // Used to track pending joins per browser tab (prevents key collision for anonymous users)
+  const connectionId = useMemo(() => crypto.randomUUID(), []);
+
   // Generate deterministic instanceIds so all participants use SAME IDs
   const cloudInstanceId = parseNonEmptyString(meeting.id);
   const rawTracksInstanceId = parseNonEmptyString(
@@ -249,6 +257,28 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
   );
 
   const handleFrameJoinMeeting = useCallback(() => {
+    // Signal that WebRTC connection is established
+    // This clears the pending join intent, confirming successful connection
+    joinedMutation.mutate(
+      {
+        params: {
+          path: {
+            room_name: roomName,
+            meeting_id: meeting.id,
+          },
+        },
+        body: {
+          connection_id: connectionId,
+        },
+      },
+      {
+        onError: (error: unknown) => {
+          // Non-blocking: log but don't fail - this is cleanup, not critical
+          console.warn("Failed to signal joined:", error);
+        },
+      },
+    );
+
     if (meeting.recording_type === "cloud") {
       console.log("Starting dual recording via REST API", {
         cloudInstanceId,
@@ -310,6 +340,9 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
   }, [
     meeting.recording_type,
     meeting.id,
+    roomName,
+    connectionId,
+    joinedMutation,
     startRecordingMutation,
     cloudInstanceId,
     rawTracksInstanceId,
@@ -328,8 +361,28 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
 
   useEffect(() => {
     if (!frame || !roomUrl) return;
-    frame
+
-      .join({
+    const joinRoom = async () => {
+      // Signal intent to join before WebRTC handshake starts
+      // This prevents race condition where meeting is deactivated during handshake
+      try {
+        await joiningMutation.mutateAsync({
+          params: {
+            path: {
+              room_name: roomName,
+              meeting_id: meeting.id,
+            },
+          },
+          body: {
+            connection_id: connectionId,
+          },
+        });
+      } catch (error) {
+        // Non-blocking: log but continue with join
+        console.warn("Failed to signal joining intent:", error);
+      }
+
+      await frame.join({
         url: roomUrl,
         sendSettings: {
           video: {
@@ -341,9 +394,13 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
           },
           // Note: screenVideo intentionally not configured to preserve full quality for screen shares
         },
-      })
+      });
-      .catch(console.error.bind(console, "Failed to join daily room:"));
+    };
-  }, [frame, roomUrl]);
+
+    joinRoom().catch(console.error.bind(console, "Failed to join daily room:"));
+    // joiningMutation excluded from deps - it's a stable hook reference
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [frame, roomUrl, roomName, meeting.id, connectionId]);
 
   useEffect(() => {
     setCustomTrayButton(

www/app/lib/__tests__/bulkMeetingStatus.test.tsx

@@ -1,246 +0,0 @@
-import "@testing-library/jest-dom";
-
-// --- Module mocks (hoisted before imports) ---
-
-jest.mock("../apiClient", () => ({
-  client: {
-    GET: jest.fn(),
-    POST: jest.fn(),
-    PUT: jest.fn(),
-    PATCH: jest.fn(),
-    DELETE: jest.fn(),
-    use: jest.fn(),
-  },
-  $api: {
-    useQuery: jest.fn(),
-    useMutation: jest.fn(),
-    queryOptions: (method: string, path: string, init?: unknown) =>
-      init === undefined
-        ? { queryKey: [method, path] }
-        : { queryKey: [method, path, init] },
-  },
-  API_URL: "http://test",
-  WEBSOCKET_URL: "ws://test",
-  configureApiAuth: jest.fn(),
-}));
-
-jest.mock("../AuthProvider", () => ({
-  useAuth: () => ({
-    status: "authenticated" as const,
-    accessToken: "test-token",
-    accessTokenExpires: Date.now() + 3600000,
-    user: { id: "user1", name: "Test User" },
-    update: jest.fn(),
-    signIn: jest.fn(),
-    signOut: jest.fn(),
-    lastUserId: "user1",
-  }),
-}));
-
-// --- Imports (after mocks) ---
-
-import React from "react";
-import { render, waitFor, screen } from "@testing-library/react";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { useRoomsBulkMeetingStatus, BulkMeetingStatusMap } from "../apiHooks";
-import { client } from "../apiClient";
-import { ErrorProvider } from "../../(errors)/errorContext";
-
-const mockClient = client as { POST: jest.Mock };
-
-// --- Helpers ---
-
-function mockBulkStatusEndpoint(
-  roomData?: Record<
-    string,
-    { active_meetings: unknown[]; upcoming_events: unknown[] }
-  >,
-) {
-  mockClient.POST.mockImplementation(
-    async (_path: string, options: { body: { room_names: string[] } }) => {
-      const roomNames: string[] = options.body.room_names;
-      const src = roomData ?? {};
-      const data = Object.fromEntries(
-        roomNames.map((name) => [
-          name,
-          src[name] ?? { active_meetings: [], upcoming_events: [] },
-        ]),
-      );
-      return { data, error: undefined, response: {} };
-    },
-  );
-}
-
-// --- Test component: uses the bulk hook and displays results ---
-
-function BulkStatusDisplay({ roomNames }: { roomNames: string[] }) {
-  const { data, isLoading } = useRoomsBulkMeetingStatus(roomNames);
-
-  if (isLoading) {
-    return <div data-testid="status">loading</div>;
-  }
-
-  if (!data) {
-    return <div data-testid="status">no data</div>;
-  }
-
-  return (
-    <div data-testid="status">
-      {roomNames.map((name) => {
-        const status = data[name];
-        return (
-          <div key={name} data-testid={`room-${name}`}>
-            {status?.active_meetings?.length ?? 0} active,{" "}
-            {status?.upcoming_events?.length ?? 0} upcoming
-          </div>
-        );
-      })}
-    </div>
-  );
-}
-
-function createWrapper() {
-  const queryClient = new QueryClient({
-    defaultOptions: {
-      queries: { retry: false },
-    },
-  });
-  return function Wrapper({ children }: { children: React.ReactNode }) {
-    return (
-      <QueryClientProvider client={queryClient}>
-        <ErrorProvider>{children}</ErrorProvider>
-      </QueryClientProvider>
-    );
-  };
-}
-
-// --- Tests ---
-
-describe("bulk meeting status (prop-drilling)", () => {
-  afterEach(() => jest.clearAllMocks());
-
-  it("fetches all room statuses in a single POST request", async () => {
-    const rooms = Array.from({ length: 10 }, (_, i) => `room-${i}`);
-
-    mockBulkStatusEndpoint();
-
-    render(<BulkStatusDisplay roomNames={rooms} />, {
-      wrapper: createWrapper(),
-    });
-
-    await waitFor(() => {
-      for (const name of rooms) {
-        expect(screen.getByTestId(`room-${name}`)).toHaveTextContent(
-          "0 active, 0 upcoming",
-        );
-      }
-    });
-
-    const postCalls = mockClient.POST.mock.calls.filter(
-      ([path]: [string]) => path === "/v1/rooms/meetings/bulk-status",
-    );
-
-    // Prop-drilling: exactly 1 POST for all rooms (no batcher needed)
-    expect(postCalls).toHaveLength(1);
-
-    // The single call contains all room names
-    const requestedRooms: string[] = postCalls[0][1].body.room_names;
-    expect(requestedRooms).toHaveLength(10);
-    for (const name of rooms) {
-      expect(requestedRooms).toContain(name);
-    }
-  });
-
-  it("returns room-specific data correctly", async () => {
-    mockBulkStatusEndpoint({
-      "room-a": {
-        active_meetings: [{ id: "m1", room_name: "room-a" }],
-        upcoming_events: [],
-      },
-      "room-b": {
-        active_meetings: [],
-        upcoming_events: [{ id: "e1", title: "Standup" }],
-      },
-    });
-
-    render(<BulkStatusDisplay roomNames={["room-a", "room-b"]} />, {
-      wrapper: createWrapper(),
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId("room-room-a")).toHaveTextContent(
-        "1 active, 0 upcoming",
-      );
-      expect(screen.getByTestId("room-room-b")).toHaveTextContent(
-        "0 active, 1 upcoming",
-      );
-    });
-
-    // Still just 1 POST
-    expect(mockClient.POST).toHaveBeenCalledTimes(1);
-  });
-
-  it("does not fetch when roomNames is empty", async () => {
-    mockBulkStatusEndpoint();
-
-    render(<BulkStatusDisplay roomNames={[]} />, {
-      wrapper: createWrapper(),
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId("status")).toHaveTextContent("no data");
-    });
-
-    // No POST calls when no rooms
-    expect(mockClient.POST).not.toHaveBeenCalled();
-  });
-
-  it("surfaces error when POST fails", async () => {
-    mockClient.POST.mockResolvedValue({
-      data: undefined,
-      error: { detail: "server error" },
-      response: {},
-    });
-
-    function ErrorDisplay({ roomNames }: { roomNames: string[] }) {
-      const { error } = useRoomsBulkMeetingStatus(roomNames);
-      if (error) return <div data-testid="error">{error.message}</div>;
-      return <div data-testid="error">no error</div>;
-    }
-
-    render(<ErrorDisplay roomNames={["room-x"]} />, {
-      wrapper: createWrapper(),
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId("error")).toHaveTextContent(
-        "bulk-status fetch failed",
-      );
-    });
-  });
-
-  it("does not fetch when unauthenticated", async () => {
-    // Override useAuth to return unauthenticated
-    const authModule = jest.requireMock("../AuthProvider");
-    const originalUseAuth = authModule.useAuth;
-    authModule.useAuth = () => ({
-      ...originalUseAuth(),
-      status: "unauthenticated",
-    });
-
-    mockBulkStatusEndpoint();
-
-    render(<BulkStatusDisplay roomNames={["room-1"]} />, {
-      wrapper: createWrapper(),
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId("status")).toHaveTextContent("no data");
-    });
-
-    expect(mockClient.POST).not.toHaveBeenCalled();
-
-    // Restore
-    authModule.useAuth = originalUseAuth;
-  });
-});

www/app/lib/apiHooks.ts

@@ -1,8 +1,8 @@
 "use client";
 
-import { $api, client } from "./apiClient";
+import { $api } from "./apiClient";
 import { useError } from "../(errors)/errorContext";
-import { QueryClient, useQuery, useQueryClient } from "@tanstack/react-query";
+import { QueryClient, useQueryClient } from "@tanstack/react-query";
 import type { components } from "../reflector-api";
 import { useAuth } from "./AuthProvider";
 import { MeetingId } from "./types";
@@ -641,8 +641,7 @@ export function useMeetingDeactivate() {
       setError(error as Error, "Failed to end meeting");
     },
     onSuccess: () => {
-      return Promise.all([
+      return queryClient.invalidateQueries({
-        queryClient.invalidateQueries({
         predicate: (query) => {
           const key = query.queryKey;
           return key.some(
@@ -651,11 +650,7 @@ export function useMeetingDeactivate() {
               !!MEETING_LIST_PATH_PARTIALS.find((e) => k.includes(e)),
           );
         },
-        }),
+      });
-        queryClient.invalidateQueries({
-          queryKey: ["bulk-meeting-status"],
-        }),
-      ]);
     },
   });
 }
@@ -712,9 +707,6 @@ export function useRoomsCreateMeeting() {
             },
           ).queryKey,
         }),
-        queryClient.invalidateQueries({
-          queryKey: ["bulk-meeting-status"],
-        }),
       ]);
     },
     onError: (error) => {
@@ -780,32 +772,6 @@ export function useRoomActiveMeetings(roomName: string | null) {
   );
 }
 
-type RoomMeetingStatus = components["schemas"]["RoomMeetingStatus"];
-
-export type BulkMeetingStatusMap = Partial<Record<string, RoomMeetingStatus>>;
-
-export function useRoomsBulkMeetingStatus(roomNames: string[]) {
-  const { isAuthenticated } = useAuthReady();
-  const sortedNames = [...roomNames].sort();
-
-  return useQuery({
-    queryKey: ["bulk-meeting-status", sortedNames],
-    queryFn: async (): Promise<BulkMeetingStatusMap> => {
-      const { data, error } = await client.POST(
-        "/v1/rooms/meetings/bulk-status",
-        { body: { room_names: roomNames } },
-      );
-      if (error || !data) {
-        throw new Error(
-          `bulk-status fetch failed: ${JSON.stringify(error ?? "no data")}`,
-        );
-      }
-      return data;
-    },
-    enabled: sortedNames.length > 0 && isAuthenticated,
-  });
-}
-
 export function useRoomGetMeeting(
   roomName: string | null,
   meetingId: MeetingId | null,
@@ -841,6 +807,26 @@ export function useRoomJoinMeeting() {
   );
 }
 
+// Presence race fix endpoints (not yet in OpenAPI spec)
+// These signal join intent to prevent race conditions during WebRTC handshake
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function useMeetingJoining(): any {
+  return ($api as any).useMutation(
+    "post",
+    "/v1/rooms/{room_name}/meetings/{meeting_id}/joining",
+    {},
+  );
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function useMeetingJoined(): any {
+  return ($api as any).useMutation(
+    "post",
+    "/v1/rooms/{room_name}/meetings/{meeting_id}/joined",
+    {},
+  );
+}
+
 export function useRoomIcsSync() {
   const { setError } = useError();
 

www/app/reflector-api.d.ts

@@ -118,23 +118,6 @@ export interface paths {
     patch?: never;
     trace?: never;
   };
-  "/v1/rooms/meetings/bulk-status": {
-    parameters: {
-      query?: never;
-      header?: never;
-      path?: never;
-      cookie?: never;
-    };
-    get?: never;
-    put?: never;
-    /** Rooms Bulk Meeting Status */
-    post: operations["v1_rooms_bulk_meeting_status"];
-    delete?: never;
-    options?: never;
-    head?: never;
-    patch?: never;
-    trace?: never;
-  };
   "/v1/rooms/{room_id}": {
     parameters: {
       query?: never;
@@ -816,11 +799,6 @@ export interface components {
        */
       chunk: string;
     };
-    /** BulkStatusRequest */
-    BulkStatusRequest: {
-      /** Room Names */
-      room_names: string[];
-    };
     /** CalendarEventResponse */
     CalendarEventResponse: {
       /** Id */
@@ -1697,13 +1675,6 @@ export interface components {
        */
       skip_consent: boolean;
     };
-    /** RoomMeetingStatus */
-    RoomMeetingStatus: {
-      /** Active Meetings */
-      active_meetings: components["schemas"]["Meeting"][];
-      /** Upcoming Events */
-      upcoming_events: components["schemas"]["CalendarEventResponse"][];
-    };
     /** RoomDetails */
     RoomDetails: {
       /** Id */
@@ -2301,41 +2272,6 @@ export interface operations {
       };
     };
   };
-  v1_rooms_bulk_meeting_status: {
-    parameters: {
-      query?: never;
-      header?: never;
-      path?: never;
-      cookie?: never;
-    };
-    requestBody: {
-      content: {
-        "application/json": components["schemas"]["BulkStatusRequest"];
-      };
-    };
-    responses: {
-      /** @description Successful Response */
-      200: {
-        headers: {
-          [name: string]: unknown;
-        };
-        content: {
-          "application/json": {
-            [key: string]: components["schemas"]["RoomMeetingStatus"];
-          };
-        };
-      };
-      /** @description Validation Error */
-      422: {
-        headers: {
-          [name: string]: unknown;
-        };
-        content: {
-          "application/json": components["schemas"]["HTTPValidationError"];
-        };
-      };
-    };
-  };
   v1_rooms_get: {
     parameters: {
       query?: never;

www/jest.config.js

@@ -1,22 +1,8 @@
 module.exports = {
-  testEnvironment: "jest-environment-jsdom",
+  preset: "ts-jest",
+  testEnvironment: "node",
   roots: ["<rootDir>/app"],
-  testMatch: ["**/__tests__/**/*.test.ts", "**/__tests__/**/*.test.tsx"],
+  testMatch: ["**/__tests__/**/*.test.ts"],
-  collectCoverage: false,
+  collectCoverage: true,
-  transform: {
+  collectCoverageFrom: ["app/**/*.ts", "!app/**/*.d.ts"],
-    "^.+\\.[jt]sx?$": [
-      "ts-jest",
-      {
-        tsconfig: {
-          jsx: "react-jsx",
-          module: "esnext",
-          moduleResolution: "bundler",
-          esModuleInterop: true,
-          strict: true,
-          downlevelIteration: true,
-          lib: ["dom", "dom.iterable", "esnext"],
-        },
-      },
-    ],
-  },
 };

www/package.json

@@ -61,13 +61,9 @@
   "author": "Andreas <andreas@monadical.com>",
   "license": "All Rights Reserved",
   "devDependencies": {
-    "@testing-library/dom": "^10.4.1",
-    "@testing-library/jest-dom": "^6.9.1",
-    "@testing-library/react": "^16.3.2",
     "@types/jest": "^30.0.0",
     "@types/react": "18.2.20",
     "jest": "^30.1.3",
-    "jest-environment-jsdom": "^30.2.0",
     "openapi-typescript": "^7.9.1",
     "prettier": "^3.0.0",
     "ts-jest": "^29.4.1"