fix: address review feedback

- Add PUBLIC_MODE auth guard on bulk-status endpoint - Convert DB models to view models via model_validate() - Early return when no accessible rooms (skip DB queries) - BulkMeetingStatusMap: Partial<Record> for type honesty - Sort roomNames in query key for cache stability - Remove redundant empty-guard in queryFn - Add 7 backend tests: auth, redaction, whereby host_room_url, 401, empty - Add 2 frontend tests: error handling, unauthenticated case
fix: batch room meeting status queries via prop-drilling
2026-02-06 10:46:46 +00:00 · 2026-02-05 20:30:26 -05:00 · 2026-02-05 20:04:31 -05:00
18 changed files with 1512 additions and 675 deletions
--- a/.github/workflows/test_next_server.yml
+++ b/.github/workflows/test_next_server.yml
@@ -13,6 +13,9 @@ on:
 jobs:
  test-next-server:
    runs-on: ubuntu-latest
+    concurrency:
+      group: test-next-server-${{ github.ref }}
+      cancel-in-progress: true

    defaults:
      run:
@@ -21,17 +24,12 @@ 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:
-        version: 8
+        package_json_file: './www/package.json'

-    - name: Setup Node.js cache
+    - name: Setup Node.js
      uses: actions/setup-node@v4
      with:
        node-version: '20'
@@ -42,4 +40,4 @@ jobs:
      run: pnpm install

    - name: Run tests
-      run: pnpm test
+      run: pnpm test
--- a/server/reflector/db/calendar_events.py
+++ b/server/reflector/db/calendar_events.py
@@ -104,6 +104,26 @@ 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)
--- a/server/reflector/db/meetings.py
+++ b/server/reflector/db/meetings.py
@@ -301,6 +301,23 @@ 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:
--- a/server/reflector/db/rooms.py
+++ b/server/reflector/db/rooms.py
@@ -245,6 +245,11 @@ 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
--- a/server/reflector/video_platforms/daily.py
+++ b/server/reflector/video_platforms/daily.py
@@ -129,10 +129,6 @@ class DailyClient(VideoPlatformClient):
        """Get room presence/session data for a Daily.co room."""
        return await self._api_client.get_room_presence(room_name)

-    async def delete_room(self, room_name: str) -> None:
-        """Delete a Daily.co room (idempotent - succeeds even if room doesn't exist)."""
-        return await self._api_client.delete_room(room_name)
-
    async def get_meeting_participants(
        self, meeting_id: str
    ) -> MeetingParticipantsResponse:
--- a/server/reflector/views/rooms.py
+++ b/server/reflector/views/rooms.py
@@ -1,4 +1,6 @@
+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
@@ -6,13 +8,14 @@ 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
+from pydantic import BaseModel, Field
 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.schemas.platform import Platform
@@ -20,7 +23,6 @@ from reflector.services.ics_sync import ics_sync_service
 from reflector.settings import settings
 from reflector.utils.url import add_query_param
 from reflector.video_platforms.factory import create_platform_client
-from reflector.worker.process import poll_daily_room_presence_task
 from reflector.worker.webhook import test_webhook

 logger = logging.getLogger(__name__)
@@ -196,6 +198,82 @@ 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,
@@ -366,53 +444,6 @@ async def rooms_create_meeting(
    return meeting


-@router.post("/rooms/{room_name}/meetings/{meeting_id}/joined")
-async def rooms_joined_meeting(
-    room_name: str,
-    meeting_id: str,
-):
-    """Trigger presence poll (ideally when user actually joins meeting in Daily iframe)"""
-    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 meeting.platform == "daily":
-        poll_daily_room_presence_task.delay(meeting_id)
-
-    return {"status": "ok"}
-
-
-@router.post("/rooms/{room_name}/meetings/{meeting_id}/leave")
-async def rooms_leave_meeting(
-    room_name: str,
-    meeting_id: str,
-    delay_seconds: int = 2,
-):
-    """Trigger presence recheck when user leaves meeting (e.g., tab close/navigation).
-
-    Queues presence poll with optional delay to allow Daily.co to detect disconnect.
-    """
-    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 meeting.platform == "daily":
-        poll_daily_room_presence_task.apply_async(
-            args=[meeting_id],
-            countdown=delay_seconds,
-        )
-
-    return {"status": "ok"}
-
-
@router.post("/rooms/{room_id}/webhook/test", response_model=WebhookTestResult)
 async def rooms_test_webhook(
    room_id: str,
--- a/server/reflector/worker/process.py
+++ b/server/reflector/worker/process.py
@@ -845,47 +845,15 @@ async def process_meetings():
                    end_date = end_date.replace(tzinfo=timezone.utc)

                client = create_platform_client(meeting.platform)
-                has_active_sessions = False
-                has_had_sessions = False
+                room_sessions = await client.get_room_sessions(meeting.room_name)

-                if meeting.platform == "daily":
-                    try:
-                        presence = await client.get_room_presence(meeting.room_name)
-                        has_active_sessions = presence.total_count > 0
-
-                        room_sessions = await client.get_room_sessions(
-                            meeting.room_name
-                        )
-                        has_had_sessions = bool(room_sessions)
-
-                        logger_.info(
-                            "Daily.co presence check",
-                            has_active_sessions=has_active_sessions,
-                            has_had_sessions=has_had_sessions,
-                            presence_count=presence.total_count,
-                        )
-                    except Exception:
-                        logger_.warning(
-                            "Daily.co presence API failed, falling back to DB sessions",
-                            exc_info=True,
-                        )
-                        room_sessions = await client.get_room_sessions(
-                            meeting.room_name
-                        )
-                        has_active_sessions = bool(
-                            room_sessions
-                            and any(s.ended_at is None for s in room_sessions)
-                        )
-                        has_had_sessions = bool(room_sessions)
-                else:
-                    room_sessions = await client.get_room_sessions(meeting.room_name)
-                    has_active_sessions = bool(
-                        room_sessions and any(s.ended_at is None for s in room_sessions)
-                    )
-                    has_had_sessions = bool(room_sessions)
-                    logger_.info(
-                        f"has_active_sessions={has_active_sessions}, has_had_sessions={has_had_sessions}"
-                    )
+                has_active_sessions = bool(
+                    room_sessions and any(s.ended_at is None for s in room_sessions)
+                )
+                has_had_sessions = bool(room_sessions)
+                logger_.info(
+                    f"has_active_sessions={has_active_sessions}, has_had_sessions={has_had_sessions}"
+                )

                if has_active_sessions:
                    logger_.debug("Meeting still has active sessions, keep it")
@@ -904,20 +872,7 @@ async def process_meetings():
                    await meetings_controller.update_meeting(
                        meeting.id, is_active=False
                    )
-                    logger_.info("Meeting deactivated in database")
-
-                    if meeting.platform == "daily":
-                        try:
-                            await client.delete_room(meeting.room_name)
-                            logger_.info(
-                                "Daily.co room deleted", room_name=meeting.room_name
-                            )
-                        except Exception:
-                            logger_.warning(
-                                "Failed to delete Daily.co room",
-                                room_name=meeting.room_name,
-                                exc_info=True,
-                            )
+                    logger_.info("Meeting is deactivated")

                processed_count += 1

--- a/server/tests/test_daily_presence_deactivation.py
+++ b/server/tests/test_daily_presence_deactivation.py
@@ -1,286 +0,0 @@
-"""Unit tests for Daily.co presence-based meeting deactivation logic.
-
-Tests the fix for split room race condition by verifying:
-1. Real-time presence checking via Daily.co API
-2. Room deletion when meetings deactivate
-"""
-
-from datetime import datetime, timedelta, timezone
-from unittest.mock import AsyncMock, patch
-
-import pytest
-
-from reflector.dailyco_api.responses import (
-    RoomPresenceParticipant,
-    RoomPresenceResponse,
-)
-from reflector.db.daily_participant_sessions import (
-    DailyParticipantSession,
-    daily_participant_sessions_controller,
-)
-from reflector.db.meetings import meetings_controller
-from reflector.db.rooms import rooms_controller
-from reflector.video_platforms.daily import DailyClient
-
-
-@pytest.fixture
-async def daily_room_and_meeting():
-    """Create test room and meeting for Daily platform."""
-    room = await rooms_controller.add(
-        name="test-daily",
-        user_id="test-user",
-        platform="daily",
-        zulip_auto_post=False,
-        zulip_stream="",
-        zulip_topic="",
-        is_locked=False,
-        room_mode="normal",
-        recording_type="cloud",
-        recording_trigger="automatic-2nd-participant",
-        is_shared=False,
-    )
-
-    current_time = datetime.now(timezone.utc)
-    end_time = current_time + timedelta(hours=2)
-
-    meeting = await meetings_controller.create(
-        id="test-meeting-id",
-        room_name="test-daily-20260129120000",
-        room_url="https://daily.co/test",
-        host_room_url="https://daily.co/test",
-        start_date=current_time,
-        end_date=end_time,
-        room=room,
-    )
-
-    return room, meeting
-
-
-@pytest.mark.asyncio
-async def test_daily_client_has_delete_room_method():
-    """Verify DailyClient has delete_room method for cleanup."""
-    # Create a mock DailyClient
-    with patch("reflector.dailyco_api.client.DailyApiClient"):
-        from reflector.video_platforms.models import VideoPlatformConfig
-
-        config = VideoPlatformConfig(api_key="test-key", webhook_secret="test-secret")
-        client = DailyClient(config)
-
-        # Verify delete_room method exists
-        assert hasattr(client, "delete_room")
-        assert callable(getattr(client, "delete_room"))
-
-
-@pytest.mark.asyncio
-async def test_get_room_presence_returns_realtime_data(daily_room_and_meeting):
-    """Test that get_room_presence returns real-time participant data."""
-    room, meeting = daily_room_and_meeting
-
-    # Mock Daily.co API response
-    mock_presence = RoomPresenceResponse(
-        total_count=2,
-        data=[
-            RoomPresenceParticipant(
-                room=meeting.room_name,
-                id="session-1",
-                userId="user-1",
-                userName="User One",
-                joinTime="2026-01-29T12:00:00.000Z",
-                duration=120,
-            ),
-            RoomPresenceParticipant(
-                room=meeting.room_name,
-                id="session-2",
-                userId="user-2",
-                userName="User Two",
-                joinTime="2026-01-29T12:05:00.000Z",
-                duration=60,
-            ),
-        ],
-    )
-
-    with patch("reflector.dailyco_api.client.DailyApiClient") as mock_api:
-        from reflector.video_platforms.models import VideoPlatformConfig
-
-        config = VideoPlatformConfig(api_key="test-key", webhook_secret="test-secret")
-        client = DailyClient(config)
-
-        # Mock the API client method
-        client._api_client.get_room_presence = AsyncMock(return_value=mock_presence)
-
-        # Call get_room_presence
-        result = await client.get_room_presence(meeting.room_name)
-
-        # Verify it calls Daily.co API
-        client._api_client.get_room_presence.assert_called_once_with(meeting.room_name)
-
-        # Verify result contains real-time data
-        assert result.total_count == 2
-        assert len(result.data) == 2
-        assert result.data[0].id == "session-1"
-        assert result.data[1].id == "session-2"
-
-
-@pytest.mark.asyncio
-async def test_presence_shows_active_even_when_db_stale(daily_room_and_meeting):
-    """Test that Daily.co presence API is source of truth, not stale DB sessions."""
-    room, meeting = daily_room_and_meeting
-    current_time = datetime.now(timezone.utc)
-
-    # Create stale DB session (left_at=NULL but user actually left)
-    session_id = f"{meeting.id}:stale-user:{int((current_time - timedelta(minutes=5)).timestamp() * 1000)}"
-    await daily_participant_sessions_controller.upsert_joined(
-        DailyParticipantSession(
-            id=session_id,
-            meeting_id=meeting.id,
-            room_id=room.id,
-            session_id="stale-daily-session",
-            user_name="Stale User",
-            user_id="stale-user",
-            joined_at=current_time - timedelta(minutes=5),
-            left_at=None,  # Stale - shows active but user left
-        )
-    )
-
-    # Verify DB shows active session
-    db_sessions = await daily_participant_sessions_controller.get_active_by_meeting(
-        meeting.id
-    )
-    assert len(db_sessions) == 1
-
-    # But Daily.co API shows room is empty
-    mock_presence = RoomPresenceResponse(total_count=0, data=[])
-
-    with patch("reflector.dailyco_api.client.DailyApiClient"):
-        from reflector.video_platforms.models import VideoPlatformConfig
-
-        config = VideoPlatformConfig(api_key="test-key", webhook_secret="test-secret")
-        client = DailyClient(config)
-        client._api_client.get_room_presence = AsyncMock(return_value=mock_presence)
-
-        # Get real-time presence
-        presence = await client.get_room_presence(meeting.room_name)
-
-        # Real-time API shows no participants (truth)
-        assert presence.total_count == 0
-        assert len(presence.data) == 0
-
-        # DB shows 1 participant (stale)
-        assert len(db_sessions) == 1
-
-        # Implementation should trust presence API, not DB
-
-
-@pytest.mark.asyncio
-async def test_meeting_deactivation_logic_with_presence_empty():
-    """Test the core deactivation decision logic when presence shows room empty."""
-    # This tests the logic that will be in process_meetings
-
-    # Simulate: DB shows stale active session
-    has_active_db_sessions = True  # DB is stale
-
-    # Simulate: Daily.co presence API shows room empty
-    presence_count = 0  # Real-time truth
-
-    # Simulate: Meeting has been used before
-    has_had_sessions = True
-
-    # Decision logic (what process_meetings should do):
-    # - If presence API available: trust it
-    # - If presence shows empty AND has_had_sessions: deactivate
-
-    if presence_count == 0 and has_had_sessions:
-        should_deactivate = True
-    else:
-        should_deactivate = False
-
-    assert should_deactivate is True  # Should deactivate despite stale DB
-
-
-@pytest.mark.asyncio
-async def test_meeting_deactivation_logic_with_presence_active():
-    """Test that meetings stay active when presence shows participants."""
-    # Simulate: DB shows no sessions (not yet updated)
-    has_active_db_sessions = False  # DB hasn't caught up
-
-    # Simulate: Daily.co presence API shows active participant
-    presence_count = 1  # Real-time truth
-
-    # Decision logic: presence shows activity, keep meeting active
-    if presence_count > 0:
-        should_deactivate = False
-    else:
-        should_deactivate = True
-
-    assert should_deactivate is False  # Should stay active
-
-
-@pytest.mark.asyncio
-async def test_delete_room_called_on_deactivation(daily_room_and_meeting):
-    """Test that Daily.co room is deleted when meeting deactivates."""
-    room, meeting = daily_room_and_meeting
-
-    with patch("reflector.dailyco_api.client.DailyApiClient"):
-        from reflector.video_platforms.models import VideoPlatformConfig
-
-        config = VideoPlatformConfig(api_key="test-key", webhook_secret="test-secret")
-        client = DailyClient(config)
-
-        # Mock delete_room API call
-        client._api_client.delete_room = AsyncMock()
-
-        # Simulate deactivation - should delete room
-        await client._api_client.delete_room(meeting.room_name)
-
-        # Verify delete was called
-        client._api_client.delete_room.assert_called_once_with(meeting.room_name)
-
-
-@pytest.mark.asyncio
-async def test_delete_room_idempotent_on_404():
-    """Test that room deletion is idempotent (succeeds even if room doesn't exist)."""
-    from reflector.dailyco_api.client import DailyApiClient
-
-    # Create real client to test delete_room logic
-    client = DailyApiClient(api_key="test-key")
-
-    # Mock the HTTP client
-    mock_http_client = AsyncMock()
-    mock_response = AsyncMock()
-    mock_response.status_code = 404  # Room not found
-    mock_http_client.delete = AsyncMock(return_value=mock_response)
-
-    # Mock _get_client to return our mock
-    async def mock_get_client():
-        return mock_http_client
-
-    client._get_client = mock_get_client
-
-    # delete_room should succeed even on 404 (idempotent)
-    await client.delete_room("nonexistent-room")
-
-    # Verify delete was attempted
-    mock_http_client.delete.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_api_failure_fallback_to_db_sessions():
-    """Test that system falls back to DB sessions if Daily.co API fails."""
-    # Simulate: Daily.co API throws exception
-    api_exception = Exception("API unavailable")
-
-    # Simulate: DB shows active session
-    has_active_db_sessions = True
-
-    # Decision logic with fallback:
-    try:
-        presence_count = None
-        raise api_exception  # Simulating API failure
-    except Exception:
-        # Fallback: use DB sessions (conservative - don't deactivate if unsure)
-        if has_active_db_sessions:
-            should_deactivate = False
-        else:
-            should_deactivate = True
-
-    assert should_deactivate is False  # Conservative: keep active on API failure
--- a/server/tests/test_rooms_bulk_status.py
+++ b/server/tests/test_rooms_bulk_status.py
@@ -0,0 +1,184 @@
+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"] == []
--- a/www/app/(app)/rooms/_components/RoomList.tsx
+++ b/www/app/(app)/rooms/_components/RoomList.tsx
@@ -1,5 +1,10 @@
+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";
@@ -31,6 +36,10 @@ 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>
@@ -43,6 +52,8 @@ export function RoomList({
            onEdit={onEdit}
            onDelete={onDelete}
            loading={loading}
+            meetingStatusMap={meetingStatusMap}
+            meetingStatusLoading={bulkStatusQuery.isLoading}
          />
          <RoomCards
            rooms={rooms}
--- a/www/app/(app)/rooms/_components/RoomTable.tsx
+++ b/www/app/(app)/rooms/_components/RoomTable.tsx
@@ -14,11 +14,7 @@ import {
 import { LuLink, LuRefreshCw } from "react-icons/lu";
 import { FaCalendarAlt } from "react-icons/fa";
 import type { components } from "../../../reflector-api";
-import {
-  useRoomActiveMeetings,
-  useRoomUpcomingMeetings,
-  useRoomIcsSync,
-} from "../../../lib/apiHooks";
+import { useRoomIcsSync, BulkMeetingStatusMap } from "../../../lib/apiHooks";

 type Room = components["schemas"]["Room"];
 type Meeting = components["schemas"]["Meeting"];
@@ -62,6 +58,8 @@ interface RoomTableProps {
  onEdit: (roomId: string, roomData: any) => void;
  onDelete: (roomId: string) => void;
  loading?: boolean;
+  meetingStatusMap: BulkMeetingStatusMap;
+  meetingStatusLoading: boolean;
 }

 const getRoomModeDisplay = (mode: string): string => {
@@ -104,14 +102,16 @@ const getZulipDisplay = (
  return "Enabled";
 };

-function MeetingStatus({ roomName }: { roomName: string }) {
-  const activeMeetingsQuery = useRoomActiveMeetings(roomName);
-  const upcomingMeetingsQuery = useRoomUpcomingMeetings(roomName);
-
-  const activeMeetings = activeMeetingsQuery.data || [];
-  const upcomingMeetings = upcomingMeetingsQuery.data || [];
-
-  if (activeMeetingsQuery.isLoading || upcomingMeetingsQuery.isLoading) {
+function MeetingStatus({
+  activeMeetings,
+  upcomingMeetings,
+  isLoading,
+}: {
+  activeMeetings: Meeting[];
+  upcomingMeetings: CalendarEventResponse[];
+  isLoading: boolean;
+}) {
+  if (isLoading) {
    return <Spinner size="sm" />;
  }

@@ -176,6 +176,8 @@ export function RoomTable({
  onEdit,
  onDelete,
  loading,
+  meetingStatusMap,
+  meetingStatusLoading,
 }: RoomTableProps) {
  const [syncingRooms, setSyncingRooms] = useState<Set<NonEmptyString>>(
    new Set(),
@@ -252,7 +254,15 @@ export function RoomTable({
                  <Link href={`/${room.name}`}>{room.name}</Link>
                </Table.Cell>
                <Table.Cell>
-                  <MeetingStatus roomName={room.name} />
+                  <MeetingStatus
+                    activeMeetings={
+                      meetingStatusMap[room.name]?.active_meetings ?? []
+                    }
+                    upcomingMeetings={
+                      meetingStatusMap[room.name]?.upcoming_events ?? []
+                    }
+                    isLoading={meetingStatusLoading}
+                  />
                </Table.Cell>
                <Table.Cell>
                  {getZulipDisplay(
--- a/www/app/[roomName]/components/DailyRoom.tsx
+++ b/www/app/[roomName]/components/DailyRoom.tsx
@@ -24,24 +24,15 @@ import { useAuth } from "../../lib/AuthProvider";
 import { useConsentDialog } from "../../lib/consent";
 import {
  useRoomJoinMeeting,
-  useRoomJoinedMeeting,
-  useRoomLeaveMeeting,
  useMeetingStartRecording,
-  leaveRoomPostUrl,
-  LeaveRoomBody,
 } from "../../lib/apiHooks";
 import { omit } from "remeda";
 import {
  assertExists,
-  assertExistsAndNonEmptyString,
  NonEmptyString,
  parseNonEmptyString,
 } from "../../lib/utils";
-import {
-  assertMeetingId,
-  DailyRecordingType,
-  MeetingId,
-} from "../../lib/types";
+import { assertMeetingId, DailyRecordingType } from "../../lib/types";
 import { useUuidV5 } from "react-uuid-hook";

 const CONSENT_BUTTON_ID = "recording-consent";
@@ -188,58 +179,6 @@ const useFrame = (
  ] as const;
 };

-const leaveDaily = () => {
-  const frame = DailyIframe.getCallInstance();
-  frame?.leave();
-};
-
-const useDirtyDisconnects = (
-  meetingId: NonEmptyString,
-  roomName: NonEmptyString,
-) => {
-  useEffect(() => {
-    if (!meetingId || !roomName) return;
-
-    const handleBeforeUnload = () => {
-      leaveDaily();
-      navigator.sendBeacon(
-        leaveRoomPostUrl(
-          {
-            room_name: roomName,
-            meeting_id: meetingId,
-          },
-          {
-            delay_seconds: 5,
-          },
-        ),
-        undefined satisfies LeaveRoomBody,
-      );
-    };
-    window.addEventListener("beforeunload", handleBeforeUnload);
-    return () => window.removeEventListener("beforeunload", handleBeforeUnload);
-  }, [meetingId, roomName]);
-};
-
-const useDisconnects = (
-  meetingId: NonEmptyString,
-  roomName: NonEmptyString,
-  leaveMutation: ReturnType<typeof useRoomLeaveMeeting>,
-) => {
-  useDirtyDisconnects(meetingId, roomName);
-
-  useEffect(() => {
-    return () => {
-      leaveDaily();
-      leaveMutation.mutate({
-        params: {
-          path: { meeting_id: meetingId, room_name: roomName },
-          query: { delay_seconds: 5 },
-        },
-      });
-    };
-  }, [meetingId, roomName]);
-};
-
 export default function DailyRoom({ meeting, room }: DailyRoomProps) {
  const router = useRouter();
  const params = useParams();
@@ -247,8 +186,6 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
  const authLastUserId = auth.lastUserId;
  const [container, setContainer] = useState<HTMLDivElement | null>(null);
  const joinMutation = useRoomJoinMeeting();
-  const joinedMutation = useRoomJoinedMeeting();
-  const leaveMutation = useRoomLeaveMeeting();
  const startRecordingMutation = useMeetingStartRecording();
  const [joinedMeeting, setJoinedMeeting] = useState<Meeting | null>(null);

@@ -258,9 +195,7 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
    useUuidV5(meeting.id, RAW_TRACKS_NAMESPACE)[0],
  );

-  if (typeof params.roomName === "object")
-    throw new Error(`Invalid room name in params. array? ${params.roomName}`);
-  const roomName = assertExistsAndNonEmptyString(params.roomName);
+  const roomName = params?.roomName as string;

  const {
    showConsentModal,
@@ -302,8 +237,6 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
    router.push("/browse");
  }, [router]);

-  useDisconnects(meeting.id as MeetingId, roomName, leaveMutation);
-
  const handleCustomButtonClick = useCallback(
    (ev: DailyEventObjectCustomButtonClick) => {
      if (ev.button_id === CONSENT_BUTTON_ID) {
@@ -316,15 +249,6 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
  );

  const handleFrameJoinMeeting = useCallback(() => {
-    joinedMutation.mutate({
-      params: {
-        path: {
-          room_name: roomName,
-          meeting_id: meeting.id,
-        },
-      },
-    });
-
    if (meeting.recording_type === "cloud") {
      console.log("Starting dual recording via REST API", {
        cloudInstanceId,
@@ -384,10 +308,8 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
      startRecordingWithRetry("raw-tracks", rawTracksInstanceId);
    }
  }, [
-    joinedMutation,
-    roomName,
-    meeting.id,
    meeting.recording_type,
+    meeting.id,
    startRecordingMutation,
    cloudInstanceId,
    rawTracksInstanceId,
--- a/www/app/lib/tests/bulkMeetingStatus.test.tsx
+++ b/www/app/lib/tests/bulkMeetingStatus.test.tsx
@@ -0,0 +1,246 @@
+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;
+  });
+});
--- a/www/app/lib/apiHooks.ts
+++ b/www/app/lib/apiHooks.ts
@@ -1,13 +1,12 @@
 "use client";

-import { $api, API_URL } from "./apiClient";
+import { $api, client } from "./apiClient";
 import { useError } from "../(errors)/errorContext";
-import { QueryClient, useQueryClient } from "@tanstack/react-query";
-import type { components, operations } from "../reflector-api";
+import { QueryClient, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { components } from "../reflector-api";
 import { useAuth } from "./AuthProvider";
 import { MeetingId } from "./types";
 import { NonEmptyString } from "./utils";
-import { createFinalURL, createQuerySerializer } from "openapi-fetch";

 /*
 * XXX error types returned from the hooks are not always correct; declared types are ValidationError but real type could be string or any other
@@ -642,16 +641,21 @@ export function useMeetingDeactivate() {
      setError(error as Error, "Failed to end meeting");
    },
    onSuccess: () => {
-      return queryClient.invalidateQueries({
-        predicate: (query) => {
-          const key = query.queryKey;
-          return key.some(
-            (k) =>
-              typeof k === "string" &&
-              !!MEETING_LIST_PATH_PARTIALS.find((e) => k.includes(e)),
-          );
-        },
-      });
+      return Promise.all([
+        queryClient.invalidateQueries({
+          predicate: (query) => {
+            const key = query.queryKey;
+            return key.some(
+              (k) =>
+                typeof k === "string" &&
+                !!MEETING_LIST_PATH_PARTIALS.find((e) => k.includes(e)),
+            );
+          },
+        }),
+        queryClient.invalidateQueries({
+          queryKey: ["bulk-meeting-status"],
+        }),
+      ]);
    },
  });
 }
@@ -708,6 +712,9 @@ export function useRoomsCreateMeeting() {
            },
          ).queryKey,
        }),
+        queryClient.invalidateQueries({
+          queryKey: ["bulk-meeting-status"],
+        }),
      ]);
    },
    onError: (error) => {
@@ -773,6 +780,32 @@ 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,
@@ -808,44 +841,6 @@ export function useRoomJoinMeeting() {
  );
 }

-export const LEAVE_ROOM_POST_URL_TEMPLATE =
-  "/v1/rooms/{room_name}/meetings/{meeting_id}/leave" as const;
-
-export const leaveRoomPostUrl = (
-  path: operations["v1_rooms_leave_meeting"]["parameters"]["path"],
-  query?: operations["v1_rooms_leave_meeting"]["parameters"]["query"],
-): string =>
-  createFinalURL(LEAVE_ROOM_POST_URL_TEMPLATE, {
-    baseUrl: API_URL,
-    params: { path, query },
-    querySerializer: createQuerySerializer(),
-  });
-
-export type LeaveRoomBody = operations["v1_rooms_leave_meeting"]["requestBody"];
-
-export function useRoomLeaveMeeting() {
-  return $api.useMutation("post", LEAVE_ROOM_POST_URL_TEMPLATE);
-}
-
-export const JOINED_ROOM_POST_URL_TEMPLATE =
-  "/v1/rooms/{room_name}/meetings/{meeting_id}/joined" as const;
-
-export const joinedRoomPostUrl = (
-  params: operations["v1_rooms_joined_meeting"]["parameters"]["path"],
-): string =>
-  createFinalURL(JOINED_ROOM_POST_URL_TEMPLATE, {
-    baseUrl: API_URL,
-    params: { path: params },
-    querySerializer: () => "",
-  });
-
-export type JoinedRoomBody =
-  operations["v1_rooms_joined_meeting"]["requestBody"];
-
-export function useRoomJoinedMeeting() {
-  return $api.useMutation("post", JOINED_ROOM_POST_URL_TEMPLATE);
-}
-
 export function useRoomIcsSync() {
  const { setError } = useError();

--- a/www/app/reflector-api.d.ts
+++ b/www/app/reflector-api.d.ts
@@ -118,6 +118,23 @@ 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;
@@ -171,48 +188,6 @@ export interface paths {
    patch?: never;
    trace?: never;
  };
-  "/v1/rooms/{room_name}/meetings/{meeting_id}/joined": {
-    parameters: {
-      query?: never;
-      header?: never;
-      path?: never;
-      cookie?: never;
-    };
-    get?: never;
-    put?: never;
-    /**
-     * Rooms Joined Meeting
-     * @description Trigger presence poll (ideally when user actually joins meeting in Daily iframe)
-     */
-    post: operations["v1_rooms_joined_meeting"];
-    delete?: never;
-    options?: never;
-    head?: never;
-    patch?: never;
-    trace?: never;
-  };
-  "/v1/rooms/{room_name}/meetings/{meeting_id}/leave": {
-    parameters: {
-      query?: never;
-      header?: never;
-      path?: never;
-      cookie?: never;
-    };
-    get?: never;
-    put?: never;
-    /**
-     * Rooms Leave Meeting
-     * @description Trigger presence recheck when user leaves meeting (e.g., tab close/navigation).
-     *
-     *     Queues presence poll with optional delay to allow Daily.co to detect disconnect.
-     */
-    post: operations["v1_rooms_leave_meeting"];
-    delete?: never;
-    options?: never;
-    head?: never;
-    patch?: never;
-    trace?: never;
-  };
  "/v1/rooms/{room_id}/webhook/test": {
    parameters: {
      query?: never;
@@ -841,6 +816,11 @@ export interface components {
       */
      chunk: string;
    };
+    /** BulkStatusRequest */
+    BulkStatusRequest: {
+      /** Room Names */
+      room_names: string[];
+    };
    /** CalendarEventResponse */
    CalendarEventResponse: {
      /** Id */
@@ -1717,6 +1697,13 @@ 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 */
@@ -2314,6 +2301,41 @@ 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;
@@ -2477,72 +2499,6 @@ export interface operations {
      };
    };
  };
-  v1_rooms_joined_meeting: {
-    parameters: {
-      query?: never;
-      header?: never;
-      path: {
-        room_name: string;
-        meeting_id: string;
-      };
-      cookie?: never;
-    };
-    requestBody?: never;
-    responses: {
-      /** @description Successful Response */
-      200: {
-        headers: {
-          [name: string]: unknown;
-        };
-        content: {
-          "application/json": unknown;
-        };
-      };
-      /** @description Validation Error */
-      422: {
-        headers: {
-          [name: string]: unknown;
-        };
-        content: {
-          "application/json": components["schemas"]["HTTPValidationError"];
-        };
-      };
-    };
-  };
-  v1_rooms_leave_meeting: {
-    parameters: {
-      query?: {
-        delay_seconds?: number;
-      };
-      header?: never;
-      path: {
-        room_name: string;
-        meeting_id: string;
-      };
-      cookie?: never;
-    };
-    requestBody?: never;
-    responses: {
-      /** @description Successful Response */
-      200: {
-        headers: {
-          [name: string]: unknown;
-        };
-        content: {
-          "application/json": unknown;
-        };
-      };
-      /** @description Validation Error */
-      422: {
-        headers: {
-          [name: string]: unknown;
-        };
-        content: {
-          "application/json": components["schemas"]["HTTPValidationError"];
-        };
-      };
-    };
-  };
  v1_rooms_test_webhook: {
    parameters: {
      query?: never;
--- a/www/jest.config.js
+++ b/www/jest.config.js
@@ -1,8 +1,22 @@
 module.exports = {
-  preset: "ts-jest",
-  testEnvironment: "node",
+  testEnvironment: "jest-environment-jsdom",
  roots: ["<rootDir>/app"],
-  testMatch: ["**/__tests__/**/*.test.ts"],
-  collectCoverage: true,
-  collectCoverageFrom: ["app/**/*.ts", "!app/**/*.d.ts"],
+  testMatch: ["**/__tests__/**/*.test.ts", "**/__tests__/**/*.test.tsx"],
+  collectCoverage: false,
+  transform: {
+    "^.+\\.[jt]sx?$": [
+      "ts-jest",
+      {
+        tsconfig: {
+          jsx: "react-jsx",
+          module: "esnext",
+          moduleResolution: "bundler",
+          esModuleInterop: true,
+          strict: true,
+          downlevelIteration: true,
+          lib: ["dom", "dom.iterable", "esnext"],
+        },
+      },
+    ],
+  },
 };
--- a/www/package.json
+++ b/www/package.json
@@ -61,9 +61,13 @@
  "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"
--- a/www/pnpm-lock.yaml
+++ b/www/pnpm-lock.yaml