feat: implement frontend for calendar integration (Phase 3 & 4)

## Frontend Implementation

### Meeting Selection & Management
- Created MeetingSelection component for choosing between multiple active meetings
- Shows both active meetings and upcoming calendar events (30 min ahead)
- Displays meeting metadata with privacy controls (owner-only details)
- Supports creation of unscheduled meetings alongside calendar meetings

### Waiting Room
- Added waiting page for users joining before scheduled start time
- Shows countdown timer until meeting begins
- Auto-transitions to meeting when calendar event becomes active
- Handles early joining with proper routing

### Meeting Info Panel
- Created collapsible info panel showing meeting details
- Displays calendar metadata (title, description, attendees)
- Shows participant count and duration
- Privacy-aware: sensitive info only visible to room owners

### ICS Configuration UI
- Integrated ICS settings into room configuration dialog
- Test connection functionality with immediate feedback
- Manual sync trigger with detailed results
- Shows last sync time and ETag for monitoring
- Configurable sync intervals (1 min to 1 hour)

### Routing & Navigation
- New /room/{roomName} route for meeting selection
- Waiting room at /room/{roomName}/wait?eventId={id}
- Classic room page at /{roomName} with meeting info
- Uses sessionStorage to pass selected meeting between pages

### API Integration
- Added new endpoints for active/upcoming meetings
- Regenerated TypeScript client with latest OpenAPI spec
- Proper error handling and loading states
- Auto-refresh every 30 seconds for live updates

### UI/UX Improvements
- Color-coded badges for meeting status
- Attendee status indicators (accepted/declined/tentative)
- Responsive design with Chakra UI components
- Clear visual hierarchy between active and upcoming meetings
- Smart truncation for long attendee lists

This completes the frontend implementation for calendar integration,
enabling users to seamlessly join scheduled meetings from their
calendar applications.

.github/workflows/db_migrations.yml

@@ -17,10 +17,40 @@ on:
 jobs:
   test-migrations:
     runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:17
+        env:
+          POSTGRES_USER: reflector
+          POSTGRES_PASSWORD: reflector
+          POSTGRES_DB: reflector
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready -h 127.0.0.1 -p 5432
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    env:
+      DATABASE_URL: postgresql://reflector:reflector@localhost:5432/reflector
 
     steps:
       - uses: actions/checkout@v4
 
+      - name: Install PostgreSQL client
+        run: sudo apt-get update && sudo apt-get install -y postgresql-client | cat
+
+      - name: Wait for Postgres
+        run: |
+          for i in {1..30}; do
+            if pg_isready -h localhost -p 5432; then
+              echo "Postgres is ready"
+              break
+            fi
+            echo "Waiting for Postgres... ($i)" && sleep 1
+          done
+
       - name: Install uv
         uses: astral-sh/setup-uv@v3
         with:

.github/workflows/pre-commit.yml

@@ -0,0 +1,24 @@
+name: pre-commit
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  pre-commit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v5
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 10
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: "pnpm"
+          cache-dependency-path: "www/pnpm-lock.yaml"
+      - name: Install dependencies
+        run: cd www && pnpm install --frozen-lockfile
+      - uses: pre-commit/action@v3.0.1

.gitignore

@@ -14,3 +14,4 @@ data/
 www/REFACTOR.md
 www/reload-frontend
 server/test.sqlite
+CLAUDE.local.md

.pre-commit-config.yaml

@@ -3,10 +3,10 @@
 repos:
   - repo: local
     hooks:
-      - id: yarn-format
-        name: run yarn format
+      - id: format
+        name: run format
         language: system
-        entry: bash -c 'cd www && yarn format'
+        entry: bash -c 'cd www && pnpm format'
         pass_filenames: false
         files: ^www/
 
@@ -23,8 +23,7 @@ repos:
       - id: ruff
         args:
           - --fix
-          - --select
-          - I,F401
+          # Uses select rules from server/pyproject.toml
         files: ^server/
       - id: ruff-format
         files: ^server/

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.6.1](https://github.com/Monadical-SAS/reflector/compare/v0.6.0...v0.6.1) (2025-08-06)
+
+
+### Bug Fixes
+
+* delayed waveform loading ([#538](https://github.com/Monadical-SAS/reflector/issues/538)) ([ef64146](https://github.com/Monadical-SAS/reflector/commit/ef64146325d03f64dd9a1fe40234fb3e7e957ae2))
+
 ## [0.6.0](https://github.com/Monadical-SAS/reflector/compare/v0.5.0...v0.6.0) (2025-08-05)
 
 

CLAUDE.md

@@ -62,7 +62,7 @@ uv run python -m reflector.tools.process path/to/audio.wav
 **Setup:**
 ```bash
 # Install dependencies
-yarn install
+pnpm install
 
 # Copy configuration templates
 cp .env_template .env
@@ -72,19 +72,19 @@ cp config-template.ts config.ts
 **Development:**
 ```bash
 # Start development server
-yarn dev
+pnpm dev
 
 # Generate TypeScript API client from OpenAPI spec
-yarn openapi
+pnpm openapi
 
 # Lint code
-yarn lint
+pnpm lint
 
 # Format code
-yarn format
+pnpm format
 
 # Build for production
-yarn build
+pnpm build
 ```
 
 ### Docker Compose (Full Stack)

ICS_IMPLEMENTATION.md

@@ -0,0 +1,497 @@
+# ICS Calendar Integration - Implementation Guide
+
+## Overview
+This document provides detailed implementation guidance for integrating ICS calendar feeds with Reflector rooms. Unlike CalDAV which requires complex authentication and protocol handling, ICS integration uses simple HTTP(S) fetching of calendar files.
+
+## Key Differences from CalDAV Approach
+
+| Aspect | CalDAV | ICS |
+|--------|--------|-----|
+| Protocol | WebDAV extension | HTTP/HTTPS GET |
+| Authentication | Username/password, OAuth | Tokens embedded in URL |
+| Data Access | Selective event queries | Full calendar download |
+| Implementation | Complex (caldav library) | Simple (requests + icalendar) |
+| Real-time Updates | Supported | Polling only |
+| Write Access | Yes | No (read-only) |
+
+## Technical Architecture
+
+### 1. ICS Fetching Service
+
+```python
+# reflector/services/ics_sync.py
+
+import requests
+from icalendar import Calendar
+from typing import List, Optional
+from datetime import datetime, timedelta
+
+class ICSFetchService:
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update({'User-Agent': 'Reflector/1.0'})
+
+    def fetch_ics(self, url: str) -> str:
+        """Fetch ICS file from URL (authentication via URL token if needed)."""
+        response = self.session.get(url, timeout=30)
+        response.raise_for_status()
+        return response.text
+
+    def parse_ics(self, ics_content: str) -> Calendar:
+        """Parse ICS content into calendar object."""
+        return Calendar.from_ical(ics_content)
+
+    def extract_room_events(self, calendar: Calendar, room_url: str) -> List[dict]:
+        """Extract events that match the room URL."""
+        events = []
+
+        for component in calendar.walk():
+            if component.name == "VEVENT":
+                # Check if event matches this room
+                if self._event_matches_room(component, room_url):
+                    events.append(self._parse_event(component))
+
+        return events
+
+    def _event_matches_room(self, event, room_url: str) -> bool:
+        """Check if event location or description contains room URL."""
+        location = str(event.get('LOCATION', ''))
+        description = str(event.get('DESCRIPTION', ''))
+
+        # Support various URL formats
+        patterns = [
+            room_url,
+            room_url.replace('https://', ''),
+            room_url.split('/')[-1],  # Just room name
+        ]
+
+        for pattern in patterns:
+            if pattern in location or pattern in description:
+                return True
+
+        return False
+```
+
+### 2. Database Schema
+
+```sql
+-- Modify room table
+ALTER TABLE room ADD COLUMN ics_url TEXT;  -- encrypted to protect embedded tokens
+ALTER TABLE room ADD COLUMN ics_fetch_interval INTEGER DEFAULT 300;  -- seconds
+ALTER TABLE room ADD COLUMN ics_enabled BOOLEAN DEFAULT FALSE;
+ALTER TABLE room ADD COLUMN ics_last_sync TIMESTAMP;
+ALTER TABLE room ADD COLUMN ics_last_etag TEXT;  -- for caching
+
+-- Calendar events table
+CREATE TABLE calendar_event (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    room_id UUID REFERENCES room(id) ON DELETE CASCADE,
+    external_id TEXT NOT NULL,  -- ICS UID
+    title TEXT,
+    description TEXT,
+    start_time TIMESTAMP NOT NULL,
+    end_time TIMESTAMP NOT NULL,
+    attendees JSONB,
+    location TEXT,
+    ics_raw_data TEXT,  -- Store raw VEVENT for reference
+    last_synced TIMESTAMP DEFAULT NOW(),
+    is_deleted BOOLEAN DEFAULT FALSE,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW(),
+    UNIQUE(room_id, external_id)
+);
+
+-- Index for efficient queries
+CREATE INDEX idx_calendar_event_room_start ON calendar_event(room_id, start_time);
+CREATE INDEX idx_calendar_event_deleted ON calendar_event(is_deleted) WHERE NOT is_deleted;
+```
+
+### 3. Background Tasks
+
+```python
+# reflector/worker/tasks/ics_sync.py
+
+from celery import shared_task
+from datetime import datetime, timedelta
+import hashlib
+
+@shared_task
+def sync_ics_calendars():
+    """Sync all enabled ICS calendars based on their fetch intervals."""
+    rooms = Room.query.filter_by(ics_enabled=True).all()
+
+    for room in rooms:
+        # Check if it's time to sync based on fetch interval
+        if should_sync(room):
+            sync_room_calendar.delay(room.id)
+
+@shared_task
+def sync_room_calendar(room_id: str):
+    """Sync calendar for a specific room."""
+    room = Room.query.get(room_id)
+    if not room or not room.ics_enabled:
+        return
+
+    try:
+        # Fetch ICS file (decrypt URL first)
+        service = ICSFetchService()
+        decrypted_url = decrypt_ics_url(room.ics_url)
+        ics_content = service.fetch_ics(decrypted_url)
+
+        # Check if content changed (using ETag or hash)
+        content_hash = hashlib.md5(ics_content.encode()).hexdigest()
+        if room.ics_last_etag == content_hash:
+            logger.info(f"No changes in ICS for room {room_id}")
+            return
+
+        # Parse and extract events
+        calendar = service.parse_ics(ics_content)
+        events = service.extract_room_events(calendar, room.url)
+
+        # Update database
+        sync_events_to_database(room_id, events)
+
+        # Update sync metadata
+        room.ics_last_sync = datetime.utcnow()
+        room.ics_last_etag = content_hash
+        db.session.commit()
+
+    except Exception as e:
+        logger.error(f"Failed to sync ICS for room {room_id}: {e}")
+
+def should_sync(room) -> bool:
+    """Check if room calendar should be synced."""
+    if not room.ics_last_sync:
+        return True
+
+    time_since_sync = datetime.utcnow() - room.ics_last_sync
+    return time_since_sync.total_seconds() >= room.ics_fetch_interval
+```
+
+### 4. Celery Beat Schedule
+
+```python
+# reflector/worker/celeryconfig.py
+
+from celery.schedules import crontab
+
+beat_schedule = {
+    'sync-ics-calendars': {
+        'task': 'reflector.worker.tasks.ics_sync.sync_ics_calendars',
+        'schedule': 60.0,  # Check every minute which calendars need syncing
+    },
+    'pre-create-meetings': {
+        'task': 'reflector.worker.tasks.ics_sync.pre_create_calendar_meetings',
+        'schedule': 60.0,  # Check every minute for upcoming meetings
+    },
+}
+```
+
+## API Endpoints
+
+### Room ICS Configuration
+
+```python
+# PATCH /v1/rooms/{room_id}
+{
+    "ics_url": "https://calendar.google.com/calendar/ical/.../private-token/basic.ics",
+    "ics_fetch_interval": 300,  # seconds
+    "ics_enabled": true
+    # URL will be encrypted in database to protect embedded tokens
+}
+```
+
+### Manual Sync Trigger
+
+```python
+# POST /v1/rooms/{room_name}/ics/sync
+# Response:
+{
+    "status": "syncing",
+    "last_sync": "2024-01-15T10:30:00Z",
+    "events_found": 5
+}
+```
+
+### ICS Status
+
+```python
+# GET /v1/rooms/{room_name}/ics/status
+# Response:
+{
+    "enabled": true,
+    "last_sync": "2024-01-15T10:30:00Z",
+    "next_sync": "2024-01-15T10:35:00Z",
+    "fetch_interval": 300,
+    "events_count": 12,
+    "upcoming_events": 3
+}
+```
+
+## ICS Parsing Details
+
+### Event Field Mapping
+
+| ICS Field | Database Field | Notes |
+|-----------|---------------|-------|
+| UID | external_id | Unique identifier |
+| SUMMARY | title | Event title |
+| DESCRIPTION | description | Full description |
+| DTSTART | start_time | Convert to UTC |
+| DTEND | end_time | Convert to UTC |
+| LOCATION | location | Check for room URL |
+| ATTENDEE | attendees | Parse into JSON |
+| ORGANIZER | attendees | Add as organizer |
+| STATUS | (internal) | Filter cancelled events |
+
+### Handling Recurring Events
+
+```python
+def expand_recurring_events(event, start_date, end_date):
+    """Expand recurring events into individual occurrences."""
+    from dateutil.rrule import rrulestr
+
+    if 'RRULE' not in event:
+        return [event]
+
+    # Parse recurrence rule
+    rrule_str = event['RRULE'].to_ical().decode()
+    dtstart = event['DTSTART'].dt
+
+    # Generate occurrences
+    rrule = rrulestr(rrule_str, dtstart=dtstart)
+    occurrences = []
+
+    for dt in rrule.between(start_date, end_date):
+        # Clone event with new date
+        occurrence = event.copy()
+        occurrence['DTSTART'].dt = dt
+        if 'DTEND' in event:
+            duration = event['DTEND'].dt - event['DTSTART'].dt
+            occurrence['DTEND'].dt = dt + duration
+
+        # Unique ID for each occurrence
+        occurrence['UID'] = f"{event['UID']}_{dt.isoformat()}"
+        occurrences.append(occurrence)
+
+    return occurrences
+```
+
+### Timezone Handling
+
+```python
+def normalize_datetime(dt):
+    """Convert various datetime formats to UTC."""
+    import pytz
+    from datetime import datetime
+
+    if hasattr(dt, 'dt'):  # icalendar property
+        dt = dt.dt
+
+    if isinstance(dt, datetime):
+        if dt.tzinfo is None:
+            # Assume local timezone if naive
+            dt = pytz.timezone('UTC').localize(dt)
+        else:
+            # Convert to UTC
+            dt = dt.astimezone(pytz.UTC)
+
+    return dt
+```
+
+## Security Considerations
+
+### 1. URL Validation
+
+```python
+def validate_ics_url(url: str) -> bool:
+    """Validate ICS URL for security."""
+    from urllib.parse import urlparse
+
+    parsed = urlparse(url)
+
+    # Must be HTTPS in production
+    if not settings.DEBUG and parsed.scheme != 'https':
+        return False
+
+    # Prevent local file access
+    if parsed.scheme in ('file', 'ftp'):
+        return False
+
+    # Prevent internal network access
+    if is_internal_ip(parsed.hostname):
+        return False
+
+    return True
+```
+
+### 2. Rate Limiting
+
+```python
+# Implement per-room rate limiting
+RATE_LIMITS = {
+    'min_fetch_interval': 60,  # Minimum 1 minute between fetches
+    'max_requests_per_hour': 60,  # Max 60 requests per hour per room
+    'max_file_size': 10 * 1024 * 1024,  # Max 10MB ICS file
+}
+```
+
+### 3. ICS URL Encryption
+
+```python
+from cryptography.fernet import Fernet
+
+class URLEncryption:
+    def __init__(self):
+        self.cipher = Fernet(settings.ENCRYPTION_KEY)
+
+    def encrypt_url(self, url: str) -> str:
+        """Encrypt ICS URL to protect embedded tokens."""
+        return self.cipher.encrypt(url.encode()).decode()
+
+    def decrypt_url(self, encrypted: str) -> str:
+        """Decrypt ICS URL for fetching."""
+        return self.cipher.decrypt(encrypted.encode()).decode()
+
+    def mask_url(self, url: str) -> str:
+        """Mask sensitive parts of URL for display."""
+        from urllib.parse import urlparse, urlunparse
+
+        parsed = urlparse(url)
+        # Keep scheme, host, and path structure but mask tokens
+        if '/private-' in parsed.path:
+            # Google Calendar format
+            parts = parsed.path.split('/private-')
+            masked_path = parts[0] + '/private-***' + parts[1].split('/')[-1]
+        elif 'token=' in url:
+            # Query parameter token
+            masked_path = parsed.path
+            parsed = parsed._replace(query='token=***')
+        else:
+            # Generic masking of path segments that look like tokens
+            import re
+            masked_path = re.sub(r'/[a-zA-Z0-9]{20,}/', '/***/', parsed.path)
+
+        return urlunparse(parsed._replace(path=masked_path))
+```
+
+## Testing Strategy
+
+### 1. Unit Tests
+
+```python
+# tests/test_ics_sync.py
+
+def test_ics_parsing():
+    """Test ICS file parsing."""
+    ics_content = """BEGIN:VCALENDAR
+VERSION:2.0
+BEGIN:VEVENT
+UID:test-123
+SUMMARY:Team Meeting
+LOCATION:https://reflector.monadical.com/engineering
+DTSTART:20240115T100000Z
+DTEND:20240115T110000Z
+END:VEVENT
+END:VCALENDAR"""
+
+    service = ICSFetchService()
+    calendar = service.parse_ics(ics_content)
+    events = service.extract_room_events(
+        calendar,
+        "https://reflector.monadical.com/engineering"
+    )
+
+    assert len(events) == 1
+    assert events[0]['title'] == 'Team Meeting'
+```
+
+### 2. Integration Tests
+
+```python
+def test_full_sync_flow():
+    """Test complete sync workflow."""
+    # Create room with ICS URL (encrypt URL to protect tokens)
+    encryption = URLEncryption()
+    room = Room(
+        name="test-room",
+        ics_url=encryption.encrypt_url("https://example.com/calendar.ics?token=secret"),
+        ics_enabled=True
+    )
+
+    # Mock ICS fetch
+    with patch('requests.get') as mock_get:
+        mock_get.return_value.text = sample_ics_content
+
+        # Run sync
+        sync_room_calendar(room.id)
+
+        # Verify events created
+        events = CalendarEvent.query.filter_by(room_id=room.id).all()
+        assert len(events) > 0
+```
+
+## Common ICS Provider Configurations
+
+### Google Calendar
+- URL Format: `https://calendar.google.com/calendar/ical/{calendar_id}/private-{token}/basic.ics`
+- Authentication via token embedded in URL
+- Updates every 3-8 hours by default
+
+### Outlook/Office 365
+- URL Format: `https://outlook.office365.com/owa/calendar/{id}/calendar.ics`
+- May include token in URL path or query parameters
+- Real-time updates
+
+### Apple iCloud
+- URL Format: `webcal://p{XX}-caldav.icloud.com/published/2/{token}`
+- Convert webcal:// to https://
+- Token embedded in URL path
+- Public calendars only
+
+### Nextcloud/ownCloud
+- URL Format: `https://cloud.example.com/remote.php/dav/public-calendars/{token}`
+- Token embedded in URL path
+- Configurable update frequency
+
+## Migration from CalDAV
+
+If migrating from an existing CalDAV implementation:
+
+1. **Database Migration**: Rename fields from `caldav_*` to `ics_*`
+2. **URL Conversion**: Most CalDAV servers provide ICS export endpoints
+3. **Authentication**: Convert from username/password to URL-embedded tokens
+4. **Remove Dependencies**: Uninstall caldav library, add icalendar
+5. **Update Background Tasks**: Replace CalDAV sync with ICS fetch
+
+## Performance Optimizations
+
+1. **Caching**: Use ETag/Last-Modified headers to avoid refetching unchanged calendars
+2. **Incremental Sync**: Store last sync timestamp, only process new/modified events
+3. **Batch Processing**: Process multiple room calendars in parallel
+4. **Connection Pooling**: Reuse HTTP connections for multiple requests
+5. **Compression**: Support gzip encoding for large ICS files
+
+## Monitoring and Debugging
+
+### Metrics to Track
+- Sync success/failure rate per room
+- Average sync duration
+- ICS file sizes
+- Number of events processed
+- Failed event matches
+
+### Debug Logging
+```python
+logger.debug(f"Fetching ICS from {room.ics_url}")
+logger.debug(f"ICS content size: {len(ics_content)} bytes")
+logger.debug(f"Found {len(events)} matching events")
+logger.debug(f"Event UIDs: {[e['external_id'] for e in events]}")
+```
+
+### Common Issues
+1. **SSL Certificate Errors**: Add certificate validation options
+2. **Timeout Issues**: Increase timeout for large calendars
+3. **Encoding Problems**: Handle various character encodings
+4. **Timezone Mismatches**: Always convert to UTC
+5. **Memory Issues**: Stream large ICS files instead of loading entirely

PLAN.md

@@ -0,0 +1,337 @@
+# ICS Calendar Integration Plan
+
+## Core Concept
+ICS calendar URLs are attached to rooms (not users) to enable automatic meeting tracking and management through periodic fetching of calendar data.
+
+## Database Schema Updates
+
+### 1. Add ICS configuration to rooms
+- Add `ics_url` field to room table (URL to .ics file, may include auth token)
+- Add `ics_fetch_interval` field to room table (default: 5 minutes, configurable)
+- Add `ics_enabled` boolean field to room table
+- Add `ics_last_sync` timestamp field to room table
+
+### 2. Create calendar_events table
+- `id` - UUID primary key
+- `room_id` - Foreign key to room
+- `external_id` - ICS event UID
+- `title` - Event title
+- `description` - Event description
+- `start_time` - Event start timestamp
+- `end_time` - Event end timestamp
+- `attendees` - JSON field with attendee list and status
+- `location` - Meeting location (should contain room name)
+- `last_synced` - Last sync timestamp
+- `is_deleted` - Boolean flag for soft delete (preserve past events)
+- `ics_raw_data` - TEXT field to store raw VEVENT data for reference
+
+### 3. Update meeting table
+- Add `calendar_event_id` - Foreign key to calendar_events
+- Add `calendar_metadata` - JSON field for additional calendar data
+- Remove unique constraint on room_id + active status (allow multiple active meetings per room)
+
+## Backend Implementation
+
+### 1. ICS Sync Service
+- Create background task that runs based on room's `ics_fetch_interval` (default: 5 minutes)
+- For each room with ICS enabled, fetch the .ics file via HTTP/HTTPS
+- Parse ICS file using icalendar library
+- Extract VEVENT components and filter events looking for room URL (e.g., "https://reflector.monadical.com/max")
+- Store matching events in calendar_events table
+- Mark events as "upcoming" if start_time is within next 30 minutes
+- Pre-create Whereby meetings 1 minute before start (ensures no delay when users join)
+- Soft-delete future events that were removed from calendar (set is_deleted=true)
+- Never delete past events (preserve for historical record)
+- Support authenticated ICS feeds via tokens embedded in URL
+
+### 2. Meeting Management Updates
+- Allow multiple active meetings per room
+- Pre-create meeting record 1 minute before calendar event starts (ensures meeting is ready)
+- Link meeting to calendar_event for metadata
+- Keep meeting active for 15 minutes after last participant leaves (grace period)
+- Don't auto-close if new participant joins within grace period
+
+### 3. API Endpoints
+- `GET /v1/rooms/{room_name}/meetings` - List all active and upcoming meetings for a room
+  - Returns filtered data based on user role (owner vs participant)
+- `GET /v1/rooms/{room_name}/meetings/upcoming` - List upcoming meetings (next 30 min)
+  - Returns filtered data based on user role
+- `POST /v1/rooms/{room_name}/meetings/{meeting_id}/join` - Join specific meeting
+- `PATCH /v1/rooms/{room_id}` - Update room settings (including ICS configuration)
+  - ICS fields only visible/editable by room owner
+- `POST /v1/rooms/{room_name}/ics/sync` - Trigger manual ICS sync
+  - Only accessible by room owner
+- `GET /v1/rooms/{room_name}/ics/status` - Get ICS sync status and last fetch time
+  - Only accessible by room owner
+
+## Frontend Implementation
+
+### 1. Room Settings Page
+- Add ICS configuration section
+- Field for ICS URL (e.g., Google Calendar private URL, Outlook ICS export)
+- Field for fetch interval (dropdown: 1 min, 5 min, 10 min, 30 min, 1 hour)
+- Test connection button (validates ICS file can be fetched and parsed)
+- Manual sync button
+- Show last sync time and next scheduled sync
+
+### 2. Meeting Selection Page (New)
+- Show when accessing `/room/{room_name}`
+- **Host view** (room owner):
+  - Full calendar event details
+  - Meeting title and description
+  - Complete attendee list with RSVP status
+  - Number of current participants
+  - Duration (how long it's been running)
+- **Participant view** (non-owners):
+  - Meeting title only
+  - Date and time
+  - Number of current participants
+  - Duration (how long it's been running)
+  - No attendee list or description (privacy)
+- Display upcoming meetings (visible 30min before):
+  - Show countdown to start
+  - Can click to join early → redirected to waiting page
+  - Waiting page shows countdown until meeting starts
+  - Meeting pre-created by background task (ready when users arrive)
+- Option to create unscheduled meeting (uses existing flow)
+
+### 3. Meeting Room Updates
+- Show calendar metadata in meeting info
+- Display invited attendees vs actual participants
+- Show meeting title from calendar event
+
+## Meeting Lifecycle
+
+### 1. Meeting Creation
+- Automatic: Pre-created 1 minute before calendar event starts (ensures Whereby room is ready)
+- Manual: User creates unscheduled meeting (existing `/rooms/{room_name}/meeting` endpoint)
+- Background task handles pre-creation to avoid delays when users join
+
+### 2. Meeting Join Rules
+- Can join active meetings immediately
+- Can see upcoming meetings 30 minutes before start
+- Can click to join upcoming meetings early → sent to waiting page
+- Waiting page automatically transitions to meeting at scheduled time
+- Unscheduled meetings always joinable (current behavior)
+
+### 3. Meeting Closure Rules
+- All meetings: 15-minute grace period after last participant leaves
+- If participant rejoins within grace period, keep meeting active
+- Calendar meetings: Force close 30 minutes after scheduled end time
+- Unscheduled meetings: Keep active for 8 hours (current behavior)
+
+## ICS Parsing Logic
+
+### 1. Event Matching
+- Parse ICS file using Python icalendar library
+- Iterate through VEVENT components
+- Check LOCATION field for full FQDN URL (e.g., "https://reflector.monadical.com/max")
+- Check DESCRIPTION for room URL or mention
+- Support multiple formats:
+  - Full URL: "https://reflector.monadical.com/max"
+  - With /room path: "https://reflector.monadical.com/room/max"
+  - Partial paths: "room/max", "/max room"
+
+### 2. Attendee Extraction
+- Parse ATTENDEE properties from VEVENT
+- Extract email (MAILTO), name (CN parameter), and RSVP status (PARTSTAT)
+- Store as JSON in calendar_events.attendees
+
+### 3. Sync Strategy
+- Fetch complete ICS file (contains all events)
+- Filter events from (now - 1 hour) to (now + 24 hours) for processing
+- Update existing events if LAST-MODIFIED or SEQUENCE changed
+- Delete future events that no longer exist in ICS (start_time > now)
+- Keep past events for historical record (never delete if start_time < now)
+- Handle recurring events (RRULE) - expand to individual instances
+- Track deleted calendar events to clean up future meetings
+- Cache ICS file hash to detect changes and skip unnecessary processing
+
+## Security Considerations
+
+### 1. ICS URL Security
+- ICS URLs may contain authentication tokens (e.g., Google Calendar private URLs)
+- Store full ICS URLs encrypted using Fernet to protect embedded tokens
+- Validate ICS URLs (must be HTTPS for production)
+- Never expose full ICS URLs in API responses (return masked version)
+- Rate limit ICS fetching to prevent abuse
+
+### 2. Room Access
+- Only room owner can configure ICS URL
+- ICS URL shown as masked version to room owner (hides embedded tokens)
+- ICS settings not visible to other users
+- Meeting list visible to all room participants
+- ICS fetch logs only visible to room owner
+
+### 3. Meeting Privacy
+- Full calendar details visible only to room owner
+- Participants see limited info: title, date/time only
+- Attendee list and description hidden from non-owners
+- Meeting titles visible in room listing to all
+
+## Implementation Phases
+
+### Phase 1: Database and ICS Setup (Week 1) ✅ COMPLETED (2025-08-18)
+1. ✅ Created database migrations for ICS fields and calendar_events table
+   - Added ics_url, ics_fetch_interval, ics_enabled, ics_last_sync, ics_last_etag to room table
+   - Created calendar_event table with ics_uid (instead of external_id) and proper typing
+   - Added calendar_event_id and calendar_metadata (JSONB) to meeting table
+   - Removed server_default from datetime fields for consistency
+2. ✅ Installed icalendar Python library for ICS parsing
+   - Added icalendar>=6.0.0 to dependencies
+   - No encryption needed - ICS URLs are read-only
+3. ✅ Built ICS fetch and sync service
+   - Simple HTTP fetching without unnecessary validation
+   - Proper TypedDict typing for event data structures
+   - Supports any standard ICS format
+   - Event matching on full room URL only
+4. ✅ API endpoints for ICS configuration
+   - Room model updated to support ICS fields via existing PATCH endpoint
+   - POST /v1/rooms/{room_name}/ics/sync - Trigger manual sync (owner only)
+   - GET /v1/rooms/{room_name}/ics/status - Get sync status (owner only)
+   - GET /v1/rooms/{room_name}/meetings - List meetings with privacy controls
+   - GET /v1/rooms/{room_name}/meetings/upcoming - List upcoming meetings
+5. ✅ Celery background tasks for periodic sync
+   - sync_room_ics - Sync individual room calendar
+   - sync_all_ics_calendars - Check all rooms and queue sync based on fetch intervals
+   - pre_create_upcoming_meetings - Pre-create Whereby meetings 1 minute before start
+   - Tasks scheduled in beat schedule (every minute for checking, respects individual intervals)
+6. ✅ Tests written and passing
+   - 6 tests for Room ICS fields
+   - 7 tests for CalendarEvent model
+   - 7 tests for ICS sync service
+   - 11 tests for API endpoints
+   - 6 tests for background tasks
+   - All 31 ICS-related tests passing
+
+### Phase 2: Meeting Management (Week 2) ✅ COMPLETED (2025-08-19)
+1. ✅ Updated meeting lifecycle logic with grace period support
+   - 15-minute grace period after last participant leaves
+   - Automatic reactivation when participants rejoin
+   - Force close calendar meetings 30 minutes after scheduled end
+2. ✅ Support multiple active meetings per room
+   - Removed unique constraint on active meetings
+   - Added get_all_active_for_room() method
+   - Added get_active_by_calendar_event() method
+3. ✅ Implemented grace period logic
+   - Added last_participant_left_at and grace_period_minutes fields
+   - Process meetings task handles grace period checking
+   - Whereby webhooks clear grace period on participant join
+4. ✅ Link meetings to calendar events
+   - Pre-created meetings properly linked via calendar_event_id
+   - Calendar metadata stored with meeting
+   - API endpoints for listing and joining specific meetings
+
+### Phase 3: Frontend Meeting Selection (Week 3)
+1. Build meeting selection page
+2. Show active and upcoming meetings
+3. Implement waiting page for early joiners
+4. Add automatic transition from waiting to meeting
+5. Support unscheduled meeting creation
+
+### Phase 4: Calendar Integration UI (Week 4)
+1. Add ICS settings to room configuration
+2. Display calendar metadata in meetings
+3. Show attendee information
+4. Add sync status indicators
+5. Show fetch interval and next sync time
+
+## Success Metrics
+- Zero merged meetings from consecutive calendar events
+- Successful ICS sync from major providers (Google Calendar, Outlook, Apple Calendar, Nextcloud)
+- Meeting join accuracy: correct meeting 100% of the time
+- Grace period prevents 90% of accidental meeting closures
+- Configurable fetch intervals reduce unnecessary API calls
+
+## Design Decisions
+1. **ICS attached to room, not user** - Prevents duplicate meetings from multiple calendars
+2. **Multiple active meetings per room** - Supported with meeting selection page
+3. **Grace period for rejoining** - 15 minutes after last participant leaves
+4. **Upcoming meeting visibility** - Show 30 minutes before, join only on time
+5. **Calendar data storage** - Attached to meeting record for full context
+6. **No "ad-hoc" meetings** - Use existing meeting creation flow (unscheduled meetings)
+7. **ICS configuration via room PATCH** - Reuse existing room configuration endpoint
+8. **Event deletion handling** - Soft-delete future events, preserve past meetings
+9. **Configurable fetch interval** - Balance between freshness and server load
+10. **ICS over CalDAV** - Simpler implementation, wider compatibility, no complex auth
+
+## Phase 2 Implementation Files
+
+### Database Migrations
+- `/server/migrations/versions/6025e9b2bef2_remove_one_active_meeting_per_room_.py` - Remove unique constraint
+- `/server/migrations/versions/d4a1c446458c_add_grace_period_fields_to_meeting.py` - Add grace period fields
+
+### Updated Models
+- `/server/reflector/db/meetings.py` - Added grace period fields and new query methods
+
+### Updated Services
+- `/server/reflector/worker/process.py` - Enhanced with grace period logic and multiple meeting support
+
+### Updated API
+- `/server/reflector/views/rooms.py` - Added endpoints for listing active meetings and joining specific meetings
+- `/server/reflector/views/whereby.py` - Clear grace period on participant join
+
+### Tests
+- `/server/tests/test_multiple_active_meetings.py` - Comprehensive tests for Phase 2 features (5 tests)
+
+## Phase 1 Implementation Files Created
+
+### Database Models
+- `/server/reflector/db/rooms.py` - Updated with ICS fields (url, fetch_interval, enabled, last_sync, etag)
+- `/server/reflector/db/calendar_events.py` - New CalendarEvent model with ics_uid and proper typing
+- `/server/reflector/db/meetings.py` - Updated with calendar_event_id and calendar_metadata (JSONB)
+
+### Services
+- `/server/reflector/services/ics_sync.py` - ICS fetching and parsing with TypedDict for proper typing
+
+### API Endpoints
+- `/server/reflector/views/rooms.py` - Added ICS management endpoints with privacy controls
+
+### Background Tasks
+- `/server/reflector/worker/ics_sync.py` - Celery tasks for automatic periodic sync
+- `/server/reflector/worker/app.py` - Updated beat schedule for ICS tasks
+
+### Tests
+- `/server/tests/test_room_ics.py` - Room model ICS fields tests (6 tests)
+- `/server/tests/test_calendar_event.py` - CalendarEvent model tests (7 tests)
+- `/server/tests/test_ics_sync.py` - ICS sync service tests (7 tests)
+- `/server/tests/test_room_ics_api.py` - API endpoint tests (11 tests)
+- `/server/tests/test_ics_background_tasks.py` - Background task tests (6 tests)
+
+### Key Design Decisions
+- No encryption needed - ICS URLs are read-only access
+- Using ics_uid instead of external_id for clarity
+- Proper TypedDict typing for event data structures
+- Removed unnecessary URL validation and webcal handling
+- calendar_metadata in meetings stores flexible calendar data (organizer, recurrence, etc)
+- Background tasks query all rooms directly to avoid filtering issues
+- Sync intervals respected per-room configuration
+
+## Implementation Approach
+
+### ICS Fetching vs CalDAV
+- **ICS Benefits**:
+  - Simpler implementation (HTTP GET vs CalDAV protocol)
+  - Wider compatibility (all calendar apps can export ICS)
+  - No authentication complexity (simple URL with optional token)
+  - Easier debugging (ICS is plain text)
+  - Lower server requirements (no CalDAV library dependencies)
+
+### Supported Calendar Providers
+1. **Google Calendar**: Private ICS URL from calendar settings
+2. **Outlook/Office 365**: ICS export URL from calendar sharing
+3. **Apple Calendar**: Published calendar ICS URL
+4. **Nextcloud**: Public/private calendar ICS export
+5. **Any CalDAV server**: Via ICS export endpoint
+
+### ICS URL Examples
+- Google: `https://calendar.google.com/calendar/ical/{calendar_id}/private-{token}/basic.ics`
+- Outlook: `https://outlook.live.com/owa/calendar/{id}/calendar.ics`
+- Custom: `https://example.com/calendars/room-schedule.ics`
+
+### Fetch Interval Configuration
+- 1 minute: For critical/high-activity rooms
+- 5 minutes (default): Balance of freshness and efficiency
+- 10 minutes: Standard meeting rooms
+- 30 minutes: Low-activity rooms
+- 1 hour: Rarely-used rooms or stable schedules

README.md

@@ -79,7 +79,7 @@ Start with `cd www`.
 **Installation**
 
 ```bash
-yarn install
+pnpm install
 cp .env_template .env
 cp config-template.ts config.ts
 ```
@@ -89,7 +89,7 @@ Then, fill in the environment variables in `.env` and the configuration in `conf
 **Run in development mode**
 
 ```bash
-yarn dev
+pnpm dev
 ```
 
 Then (after completing server setup and starting it) open [http://localhost:3000](http://localhost:3000) to view it in the browser.
@@ -99,7 +99,7 @@ Then (after completing server setup and starting it) open [http://localhost:3000
 To generate the TypeScript files from the openapi.json file, make sure the python server is running, then run:
 
 ```bash
-yarn openapi
+pnpm openapi
 ```
 
 ### Backend

compose.yml

@@ -39,11 +39,12 @@ services:
     image: node:18
     ports:
       - "3000:3000"
-    command: sh -c "yarn install && yarn dev"
+    command: sh -c "corepack enable && pnpm install && pnpm dev"
     restart: unless-stopped
     working_dir: /app
     volumes:
       - ./www:/app/
+      - /app/node_modules
     env_file:
       - ./www/.env.local
 

server/migrations/README

@@ -1 +1,3 @@
-Generic single-database configuration.
+Generic single-database configuration.
+
+Both data migrations and schema migrations must be in migrations.

server/migrations/versions/0bc0f3ff0111_add_webvtt_field_to_transcript.py

@@ -0,0 +1,25 @@
+"""add_webvtt_field_to_transcript
+
+Revision ID: 0bc0f3ff0111
+Revises: b7df9609542c
+Create Date: 2025-08-05 19:36:41.740957
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0bc0f3ff0111"
+down_revision: Union[str, None] = "b7df9609542c"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column("transcript", sa.Column("webvtt", sa.Text(), nullable=True))
+
+
+def downgrade() -> None:
+    op.drop_column("transcript", "webvtt")

server/migrations/versions/116b2f287eab_add_full_text_search.py

@@ -0,0 +1,46 @@
+"""add_full_text_search
+
+Revision ID: 116b2f287eab
+Revises: 0bc0f3ff0111
+Create Date: 2025-08-07 11:27:38.473517
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+
+revision: str = "116b2f287eab"
+down_revision: Union[str, None] = "0bc0f3ff0111"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    if conn.dialect.name != "postgresql":
+        return
+
+    op.execute("""
+        ALTER TABLE transcript ADD COLUMN search_vector_en tsvector
+        GENERATED ALWAYS AS (
+            setweight(to_tsvector('english', coalesce(title, '')), 'A') ||
+            setweight(to_tsvector('english', coalesce(webvtt, '')), 'B')
+        ) STORED
+    """)
+
+    op.create_index(
+        "idx_transcript_search_vector_en",
+        "transcript",
+        ["search_vector_en"],
+        postgresql_using="gin",
+    )
+
+
+def downgrade() -> None:
+    conn = op.get_bind()
+    if conn.dialect.name != "postgresql":
+        return
+
+    op.drop_index("idx_transcript_search_vector_en", table_name="transcript")
+    op.drop_column("transcript", "search_vector_en")

server/migrations/versions/6025e9b2bef2_remove_one_active_meeting_per_room_.py

@@ -0,0 +1,53 @@
+"""remove_one_active_meeting_per_room_constraint
+
+Revision ID: 6025e9b2bef2
+Revises: 9f5c78d352d6
+Create Date: 2025-08-18 18:45:44.418392
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "6025e9b2bef2"
+down_revision: Union[str, None] = "9f5c78d352d6"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Remove the unique constraint that prevents multiple active meetings per room
+    # This is needed to support calendar integration with overlapping meetings
+    # Check if index exists before trying to drop it
+    from alembic import context
+
+    if context.get_context().dialect.name == "postgresql":
+        conn = op.get_bind()
+        result = conn.execute(
+            sa.text(
+                "SELECT 1 FROM pg_indexes WHERE indexname = 'idx_one_active_meeting_per_room'"
+            )
+        )
+        if result.fetchone():
+            op.drop_index("idx_one_active_meeting_per_room", table_name="meeting")
+    else:
+        # For SQLite, just try to drop it
+        try:
+            op.drop_index("idx_one_active_meeting_per_room", table_name="meeting")
+        except:
+            pass
+
+
+def downgrade() -> None:
+    # Restore the unique constraint
+    op.create_index(
+        "idx_one_active_meeting_per_room",
+        "meeting",
+        ["room_id"],
+        unique=True,
+        postgresql_where=sa.text("is_active = true"),
+        sqlite_where=sa.text("is_active = 1"),
+    )

server/migrations/versions/62dea3db63a5_add_room_options.py

@@ -32,7 +32,7 @@ def upgrade() -> None:
         sa.Column("user_id", sa.String(), nullable=True),
         sa.Column("room_id", sa.String(), nullable=True),
         sa.Column(
-            "is_locked", sa.Boolean(), server_default=sa.text("0"), nullable=False
+            "is_locked", sa.Boolean(), server_default=sa.text("false"), nullable=False
         ),
         sa.Column("room_mode", sa.String(), server_default="normal", nullable=False),
         sa.Column(
@@ -53,12 +53,15 @@ def upgrade() -> None:
         sa.Column("user_id", sa.String(), nullable=False),
         sa.Column("created_at", sa.DateTime(), nullable=False),
         sa.Column(
-            "zulip_auto_post", sa.Boolean(), server_default=sa.text("0"), nullable=False
+            "zulip_auto_post",
+            sa.Boolean(),
+            server_default=sa.text("false"),
+            nullable=False,
         ),
         sa.Column("zulip_stream", sa.String(), nullable=True),
         sa.Column("zulip_topic", sa.String(), nullable=True),
         sa.Column(
-            "is_locked", sa.Boolean(), server_default=sa.text("0"), nullable=False
+            "is_locked", sa.Boolean(), server_default=sa.text("false"), nullable=False
         ),
         sa.Column("room_mode", sa.String(), server_default="normal", nullable=False),
         sa.Column(

server/migrations/versions/74b2b0236931_add_transcript_source_kind.py

@@ -20,11 +20,14 @@ depends_on: Union[str, Sequence[str], None] = None
 
 def upgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
+    sourcekind_enum = sa.Enum("room", "live", "file", name="sourcekind")
+    sourcekind_enum.create(op.get_bind())
+
     op.add_column(
         "transcript",
         sa.Column(
             "source_kind",
-            sa.Enum("ROOM", "LIVE", "FILE", name="sourcekind"),
+            sourcekind_enum,
             nullable=True,
         ),
     )
@@ -43,6 +46,8 @@ def upgrade() -> None:
 def downgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
     op.drop_column("transcript", "source_kind")
+    sourcekind_enum = sa.Enum(name="sourcekind")
+    sourcekind_enum.drop(op.get_bind())
 
 
 # ### end Alembic commands ###

server/migrations/versions/8120ebc75366_populate_webvtt_from_topics.py

@@ -0,0 +1,106 @@
+"""populate_webvtt_from_topics
+
+Revision ID: 8120ebc75366
+Revises: 116b2f287eab
+Create Date: 2025-08-11 19:11:01.316947
+
+"""
+
+import json
+from typing import Sequence, Union
+
+from alembic import op
+from sqlalchemy import text
+
+# revision identifiers, used by Alembic.
+revision: str = "8120ebc75366"
+down_revision: Union[str, None] = "116b2f287eab"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def topics_to_webvtt(topics):
+    """Convert topics list to WebVTT format string."""
+    if not topics:
+        return None
+
+    lines = ["WEBVTT", ""]
+
+    for topic in topics:
+        start_time = format_timestamp(topic.get("start"))
+        end_time = format_timestamp(topic.get("end"))
+        text = topic.get("text", "").strip()
+
+        if start_time and end_time and text:
+            lines.append(f"{start_time} --> {end_time}")
+            lines.append(text)
+            lines.append("")
+
+    return "\n".join(lines).strip()
+
+
+def format_timestamp(seconds):
+    """Format seconds to WebVTT timestamp format (HH:MM:SS.mmm)."""
+    if seconds is None:
+        return None
+
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = seconds % 60
+
+    return f"{hours:02d}:{minutes:02d}:{secs:06.3f}"
+
+
+def upgrade() -> None:
+    """Populate WebVTT field for all transcripts with topics."""
+
+    # Get connection
+    connection = op.get_bind()
+
+    # Query all transcripts with topics
+    result = connection.execute(
+        text("SELECT id, topics FROM transcript WHERE topics IS NOT NULL")
+    )
+
+    rows = result.fetchall()
+    print(f"Found {len(rows)} transcripts with topics")
+
+    updated_count = 0
+    error_count = 0
+
+    for row in rows:
+        transcript_id = row[0]
+        topics_data = row[1]
+
+        if not topics_data:
+            continue
+
+        try:
+            # Parse JSON if it's a string
+            if isinstance(topics_data, str):
+                topics_data = json.loads(topics_data)
+
+            # Convert topics to WebVTT format
+            webvtt_content = topics_to_webvtt(topics_data)
+
+            if webvtt_content:
+                # Update the webvtt field
+                connection.execute(
+                    text("UPDATE transcript SET webvtt = :webvtt WHERE id = :id"),
+                    {"webvtt": webvtt_content, "id": transcript_id},
+                )
+                updated_count += 1
+                print(f"✓ Updated transcript {transcript_id}")
+
+        except Exception as e:
+            error_count += 1
+            print(f"✗ Error updating transcript {transcript_id}: {e}")
+
+    print(f"\nMigration complete!")
+    print(f"  Updated: {updated_count}")
+    print(f"  Errors: {error_count}")
+
+
+def downgrade() -> None:
+    """Clear WebVTT field for all transcripts."""
+    op.execute(text("UPDATE transcript SET webvtt = NULL"))

server/migrations/versions/99365b0cd87b_add_title_short_and_long_summary_and_.py

@@ -22,7 +22,7 @@ def upgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
     op.execute(
         "UPDATE transcript SET events = "
-        'REPLACE(events, \'"event": "SUMMARY"\', \'"event": "LONG_SUMMARY"\');'
+        'REPLACE(events::text, \'"event": "SUMMARY"\', \'"event": "LONG_SUMMARY"\')::json;'
     )
     op.alter_column("transcript", "summary", new_column_name="long_summary")
     op.add_column("transcript", sa.Column("title", sa.String(), nullable=True))
@@ -34,7 +34,7 @@ def downgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
     op.execute(
         "UPDATE transcript SET events = "
-        'REPLACE(events, \'"event": "LONG_SUMMARY"\', \'"event": "SUMMARY"\');'
+        'REPLACE(events::text, \'"event": "LONG_SUMMARY"\', \'"event": "SUMMARY"\')::json;'
     )
     with op.batch_alter_table("transcript", schema=None) as batch_op:
         batch_op.alter_column("long_summary", nullable=True, new_column_name="summary")

server/migrations/versions/9f5c78d352d6_datetime_timezone.py

@@ -0,0 +1,121 @@
+"""datetime timezone
+
+Revision ID: 9f5c78d352d6
+Revises: 8120ebc75366
+Create Date: 2025-08-13 19:18:27.113593
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = "9f5c78d352d6"
+down_revision: Union[str, None] = "8120ebc75366"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("meeting", schema=None) as batch_op:
+        batch_op.alter_column(
+            "start_date",
+            existing_type=postgresql.TIMESTAMP(),
+            type_=sa.DateTime(timezone=True),
+            existing_nullable=True,
+        )
+        batch_op.alter_column(
+            "end_date",
+            existing_type=postgresql.TIMESTAMP(),
+            type_=sa.DateTime(timezone=True),
+            existing_nullable=True,
+        )
+
+    with op.batch_alter_table("meeting_consent", schema=None) as batch_op:
+        batch_op.alter_column(
+            "consent_timestamp",
+            existing_type=postgresql.TIMESTAMP(),
+            type_=sa.DateTime(timezone=True),
+            existing_nullable=False,
+        )
+
+    with op.batch_alter_table("recording", schema=None) as batch_op:
+        batch_op.alter_column(
+            "recorded_at",
+            existing_type=postgresql.TIMESTAMP(),
+            type_=sa.DateTime(timezone=True),
+            existing_nullable=False,
+        )
+
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.alter_column(
+            "created_at",
+            existing_type=postgresql.TIMESTAMP(),
+            type_=sa.DateTime(timezone=True),
+            existing_nullable=False,
+        )
+
+    with op.batch_alter_table("transcript", schema=None) as batch_op:
+        batch_op.alter_column(
+            "created_at",
+            existing_type=postgresql.TIMESTAMP(),
+            type_=sa.DateTime(timezone=True),
+            existing_nullable=True,
+        )
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("transcript", schema=None) as batch_op:
+        batch_op.alter_column(
+            "created_at",
+            existing_type=sa.DateTime(timezone=True),
+            type_=postgresql.TIMESTAMP(),
+            existing_nullable=True,
+        )
+
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.alter_column(
+            "created_at",
+            existing_type=sa.DateTime(timezone=True),
+            type_=postgresql.TIMESTAMP(),
+            existing_nullable=False,
+        )
+
+    with op.batch_alter_table("recording", schema=None) as batch_op:
+        batch_op.alter_column(
+            "recorded_at",
+            existing_type=sa.DateTime(timezone=True),
+            type_=postgresql.TIMESTAMP(),
+            existing_nullable=False,
+        )
+
+    with op.batch_alter_table("meeting_consent", schema=None) as batch_op:
+        batch_op.alter_column(
+            "consent_timestamp",
+            existing_type=sa.DateTime(timezone=True),
+            type_=postgresql.TIMESTAMP(),
+            existing_nullable=False,
+        )
+
+    with op.batch_alter_table("meeting", schema=None) as batch_op:
+        batch_op.alter_column(
+            "end_date",
+            existing_type=sa.DateTime(timezone=True),
+            type_=postgresql.TIMESTAMP(),
+            existing_nullable=True,
+        )
+        batch_op.alter_column(
+            "start_date",
+            existing_type=sa.DateTime(timezone=True),
+            type_=postgresql.TIMESTAMP(),
+            existing_nullable=True,
+        )
+
+    # ### end Alembic commands ###

server/migrations/versions/a7122bc0b2ca_add_shared_rooms.py

@@ -25,7 +25,7 @@ def upgrade() -> None:
         sa.Column(
             "is_shared",
             sa.Boolean(),
-            server_default=sa.text("0"),
+            server_default=sa.text("false"),
             nullable=False,
         ),
     )

server/migrations/versions/b0e5f7876032_add_meeting_is_active.py

@@ -23,7 +23,10 @@ def upgrade() -> None:
     with op.batch_alter_table("meeting", schema=None) as batch_op:
         batch_op.add_column(
             sa.Column(
-                "is_active", sa.Boolean(), server_default=sa.text("1"), nullable=False
+                "is_active",
+                sa.Boolean(),
+                server_default=sa.text("true"),
+                nullable=False,
             )
         )
 

server/migrations/versions/b9348748bbbc_reviewed.py

@@ -23,7 +23,7 @@ def upgrade() -> None:
     op.add_column(
         "transcript",
         sa.Column(
-            "reviewed", sa.Boolean(), server_default=sa.text("0"), nullable=False
+            "reviewed", sa.Boolean(), server_default=sa.text("false"), nullable=False
         ),
     )
     # ### end Alembic commands ###

server/migrations/versions/d4a1c446458c_add_grace_period_fields_to_meeting.py

@@ -0,0 +1,34 @@
+"""add_grace_period_fields_to_meeting
+
+Revision ID: d4a1c446458c
+Revises: 6025e9b2bef2
+Create Date: 2025-08-18 18:50:37.768052
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "d4a1c446458c"
+down_revision: Union[str, None] = "6025e9b2bef2"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Add fields to track when participants left for grace period logic
+    op.add_column(
+        "meeting", sa.Column("last_participant_left_at", sa.DateTime(timezone=True))
+    )
+    op.add_column(
+        "meeting",
+        sa.Column("grace_period_minutes", sa.Integer, server_default=sa.text("15")),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("meeting", "grace_period_minutes")
+    op.drop_column("meeting", "last_participant_left_at")

server/pyproject.toml

@@ -34,13 +34,14 @@ dependencies = [
     "python-multipart>=0.0.6",
     "faster-whisper>=0.10.0",
     "transformers>=4.36.2",
-    "black==24.1.1",
     "jsonschema>=4.23.0",
     "openai>=1.59.7",
     "psycopg2-binary>=2.9.10",
     "llama-index>=0.12.52",
     "llama-index-llms-openai-like>=0.4.0",
     "pytest-env>=1.1.5",
+    "webvtt-py>=0.5.0",
+    "icalendar>=6.0.0",
 ]
 
 [dependency-groups]
@@ -57,6 +58,8 @@ tests = [
     "httpx-ws>=0.4.1",
     "pytest-httpx>=0.23.1",
     "pytest-celery>=0.0.0",
+    "pytest-docker>=3.2.3",
+    "asgi-lifespan>=2.1.0",
 ]
 aws = ["aioboto3>=11.2.0"]
 evaluation = [
@@ -86,12 +89,23 @@ source = ["reflector"]
 
 [tool.pytest_env]
 ENVIRONMENT = "pytest"
-DATABASE_URL = "sqlite:///test.sqlite"
+DATABASE_URL = "postgresql://test_user:test_password@localhost:15432/reflector_test"
 
 [tool.pytest.ini_options]
 addopts = "-ra -q --disable-pytest-warnings --cov --cov-report html -v"
 testpaths = ["tests"]
 asyncio_mode = "auto"
 
+[tool.ruff.lint]
+select = [
+    "I",       # isort - import sorting
+    "F401",    # unused imports
+    "PLC0415", # import-outside-top-level - detect inline imports
+]
+
 [tool.ruff.lint.per-file-ignores]
 "reflector/processors/summary/summary_builder.py" = ["E501"]
+"gpu/**.py" = ["PLC0415"]
+"reflector/tools/**.py" = ["PLC0415"]
+"migrations/versions/**.py" = ["PLC0415"]
+"tests/**.py" = ["PLC0415"]

server/reflector/db/__init__.py

@@ -1,29 +1,48 @@
+import contextvars
+from typing import Optional
+
 import databases
 import sqlalchemy
 
 from reflector.events import subscribers_shutdown, subscribers_startup
 from reflector.settings import settings
 
-database = databases.Database(settings.DATABASE_URL)
 metadata = sqlalchemy.MetaData()
 
+_database_context: contextvars.ContextVar[Optional[databases.Database]] = (
+    contextvars.ContextVar("database", default=None)
+)
+
+
+def get_database() -> databases.Database:
+    """Get database instance for current asyncio context"""
+    db = _database_context.get()
+    if db is None:
+        db = databases.Database(settings.DATABASE_URL)
+        _database_context.set(db)
+    return db
+
+
 # import models
+import reflector.db.calendar_events  # noqa
 import reflector.db.meetings  # noqa
 import reflector.db.recordings  # noqa
 import reflector.db.rooms  # noqa
 import reflector.db.transcripts  # noqa
 
 kwargs = {}
-if "sqlite" in settings.DATABASE_URL:
-    kwargs["connect_args"] = {"check_same_thread": False}
+if "postgres" not in settings.DATABASE_URL:
+    raise Exception("Only postgres database is supported in reflector")
 engine = sqlalchemy.create_engine(settings.DATABASE_URL, **kwargs)
 
 
 @subscribers_startup.append
 async def database_connect(_):
+    database = get_database()
     await database.connect()
 
 
 @subscribers_shutdown.append
 async def database_disconnect(_):
+    database = get_database()
     await database.disconnect()

server/reflector/db/calendar_events.py

@@ -0,0 +1,193 @@
+from datetime import datetime, timezone
+from typing import Any
+
+import sqlalchemy as sa
+from pydantic import BaseModel, Field
+from sqlalchemy.dialects.postgresql import JSONB
+
+from reflector.db import get_database, metadata
+from reflector.utils import generate_uuid4
+
+calendar_events = sa.Table(
+    "calendar_event",
+    metadata,
+    sa.Column("id", sa.String, primary_key=True),
+    sa.Column(
+        "room_id",
+        sa.String,
+        sa.ForeignKey("room.id", ondelete="CASCADE"),
+        nullable=False,
+    ),
+    sa.Column("ics_uid", sa.Text, nullable=False),
+    sa.Column("title", sa.Text),
+    sa.Column("description", sa.Text),
+    sa.Column("start_time", sa.DateTime(timezone=True), nullable=False),
+    sa.Column("end_time", sa.DateTime(timezone=True), nullable=False),
+    sa.Column("attendees", JSONB),
+    sa.Column("location", sa.Text),
+    sa.Column("ics_raw_data", sa.Text),
+    sa.Column("last_synced", sa.DateTime(timezone=True), nullable=False),
+    sa.Column("is_deleted", sa.Boolean, nullable=False, server_default=sa.false()),
+    sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+    sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+    sa.UniqueConstraint("room_id", "ics_uid", name="uq_room_calendar_event"),
+    sa.Index("idx_calendar_event_room_start", "room_id", "start_time"),
+    sa.Index(
+        "idx_calendar_event_deleted",
+        "is_deleted",
+        postgresql_where=sa.text("NOT is_deleted"),
+    ),
+)
+
+
+class CalendarEvent(BaseModel):
+    id: str = Field(default_factory=generate_uuid4)
+    room_id: str
+    ics_uid: str
+    title: str | None = None
+    description: str | None = None
+    start_time: datetime
+    end_time: datetime
+    attendees: list[dict[str, Any]] | None = None
+    location: str | None = None
+    ics_raw_data: str | None = None
+    last_synced: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    is_deleted: bool = False
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+class CalendarEventController:
+    async def get_by_room(
+        self,
+        room_id: str,
+        include_deleted: bool = False,
+        start_after: datetime | None = None,
+        end_before: datetime | None = None,
+    ) -> list[CalendarEvent]:
+        """Get calendar events for a room."""
+        query = calendar_events.select().where(calendar_events.c.room_id == room_id)
+
+        if not include_deleted:
+            query = query.where(calendar_events.c.is_deleted == False)
+
+        if start_after:
+            query = query.where(calendar_events.c.start_time >= start_after)
+
+        if end_before:
+            query = query.where(calendar_events.c.end_time <= end_before)
+
+        query = query.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_upcoming(
+        self, room_id: str, minutes_ahead: int = 30
+    ) -> list[CalendarEvent]:
+        """Get upcoming events for a room within the specified minutes."""
+        now = datetime.now(timezone.utc)
+        future_time = now + timedelta(minutes=minutes_ahead)
+
+        query = (
+            calendar_events.select()
+            .where(
+                sa.and_(
+                    calendar_events.c.room_id == room_id,
+                    calendar_events.c.is_deleted == False,
+                    calendar_events.c.start_time >= now,
+                    calendar_events.c.start_time <= future_time,
+                )
+            )
+            .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_ics_uid(self, room_id: str, ics_uid: str) -> CalendarEvent | None:
+        """Get a calendar event by its ICS UID."""
+        query = calendar_events.select().where(
+            sa.and_(
+                calendar_events.c.room_id == room_id,
+                calendar_events.c.ics_uid == ics_uid,
+            )
+        )
+        result = await get_database().fetch_one(query)
+        return CalendarEvent(**result) if result else None
+
+    async def upsert(self, event: CalendarEvent) -> CalendarEvent:
+        """Create or update a calendar event."""
+        existing = await self.get_by_ics_uid(event.room_id, event.ics_uid)
+
+        if existing:
+            # Update existing event
+            event.id = existing.id
+            event.created_at = existing.created_at
+            event.updated_at = datetime.now(timezone.utc)
+
+            query = (
+                calendar_events.update()
+                .where(calendar_events.c.id == existing.id)
+                .values(**event.model_dump())
+            )
+        else:
+            # Insert new event
+            query = calendar_events.insert().values(**event.model_dump())
+
+        await get_database().execute(query)
+        return event
+
+    async def soft_delete_missing(
+        self, room_id: str, current_ics_uids: list[str]
+    ) -> int:
+        """Soft delete future events that are no longer in the calendar."""
+        now = datetime.now(timezone.utc)
+
+        # First, get the IDs of events to delete
+        select_query = calendar_events.select().where(
+            sa.and_(
+                calendar_events.c.room_id == room_id,
+                calendar_events.c.start_time > now,
+                calendar_events.c.is_deleted == False,
+                calendar_events.c.ics_uid.notin_(current_ics_uids)
+                if current_ics_uids
+                else True,
+            )
+        )
+
+        to_delete = await get_database().fetch_all(select_query)
+        delete_count = len(to_delete)
+
+        if delete_count > 0:
+            # Now update them
+            update_query = (
+                calendar_events.update()
+                .where(
+                    sa.and_(
+                        calendar_events.c.room_id == room_id,
+                        calendar_events.c.start_time > now,
+                        calendar_events.c.is_deleted == False,
+                        calendar_events.c.ics_uid.notin_(current_ics_uids)
+                        if current_ics_uids
+                        else True,
+                    )
+                )
+                .values(is_deleted=True, updated_at=now)
+            )
+
+            await get_database().execute(update_query)
+
+        return delete_count
+
+    async def delete_by_room(self, room_id: str) -> int:
+        """Hard delete all events for a room (used when room is deleted)."""
+        query = calendar_events.delete().where(calendar_events.c.room_id == room_id)
+        result = await get_database().execute(query)
+        return result.rowcount
+
+
+# Add missing import
+from datetime import timedelta
+
+calendar_events_controller = CalendarEventController()

server/reflector/db/meetings.py

@@ -1,11 +1,12 @@
 from datetime import datetime
-from typing import Literal
+from typing import Any, Literal
 
 import sqlalchemy as sa
 from fastapi import HTTPException
 from pydantic import BaseModel, Field
+from sqlalchemy.dialects.postgresql import JSONB
 
-from reflector.db import database, metadata
+from reflector.db import get_database, metadata
 from reflector.db.rooms import Room
 from reflector.utils import generate_uuid4
 
@@ -16,8 +17,8 @@ meetings = sa.Table(
     sa.Column("room_name", sa.String),
     sa.Column("room_url", sa.String),
     sa.Column("host_room_url", sa.String),
-    sa.Column("start_date", sa.DateTime),
-    sa.Column("end_date", sa.DateTime),
+    sa.Column("start_date", sa.DateTime(timezone=True)),
+    sa.Column("end_date", sa.DateTime(timezone=True)),
     sa.Column("user_id", sa.String),
     sa.Column("room_id", sa.String),
     sa.Column("is_locked", sa.Boolean, nullable=False, server_default=sa.false()),
@@ -41,7 +42,16 @@ meetings = sa.Table(
         nullable=False,
         server_default=sa.true(),
     ),
+    sa.Column(
+        "calendar_event_id",
+        sa.String,
+        sa.ForeignKey("calendar_event.id", ondelete="SET NULL"),
+    ),
+    sa.Column("calendar_metadata", JSONB),
+    sa.Column("last_participant_left_at", sa.DateTime(timezone=True)),
+    sa.Column("grace_period_minutes", sa.Integer, server_default=sa.text("15")),
     sa.Index("idx_meeting_room_id", "room_id"),
+    sa.Index("idx_meeting_calendar_event", "calendar_event_id"),
 )
 
 meeting_consent = sa.Table(
@@ -51,7 +61,7 @@ meeting_consent = sa.Table(
     sa.Column("meeting_id", sa.String, sa.ForeignKey("meeting.id"), nullable=False),
     sa.Column("user_id", sa.String),
     sa.Column("consent_given", sa.Boolean, nullable=False),
-    sa.Column("consent_timestamp", sa.DateTime, nullable=False),
+    sa.Column("consent_timestamp", sa.DateTime(timezone=True), nullable=False),
 )
 
 
@@ -79,6 +89,11 @@ class Meeting(BaseModel):
         "none", "prompt", "automatic", "automatic-2nd-participant"
     ] = "automatic-2nd-participant"
     num_clients: int = 0
+    is_active: bool = True
+    calendar_event_id: str | None = None
+    calendar_metadata: dict[str, Any] | None = None
+    last_participant_left_at: datetime | None = None
+    grace_period_minutes: int = 15
 
 
 class MeetingController:
@@ -92,6 +107,8 @@ class MeetingController:
         end_date: datetime,
         user_id: str,
         room: Room,
+        calendar_event_id: str | None = None,
+        calendar_metadata: dict[str, Any] | None = None,
     ):
         """
         Create a new meeting
@@ -109,9 +126,11 @@ class MeetingController:
             room_mode=room.room_mode,
             recording_type=room.recording_type,
             recording_trigger=room.recording_trigger,
+            calendar_event_id=calendar_event_id,
+            calendar_metadata=calendar_metadata,
         )
         query = meetings.insert().values(**meeting.model_dump())
-        await database.execute(query)
+        await get_database().execute(query)
         return meeting
 
     async def get_all_active(self) -> list[Meeting]:
@@ -119,7 +138,7 @@ class MeetingController:
         Get active meetings.
         """
         query = meetings.select().where(meetings.c.is_active)
-        return await database.fetch_all(query)
+        return await get_database().fetch_all(query)
 
     async def get_by_room_name(
         self,
@@ -129,7 +148,7 @@ class MeetingController:
         Get a meeting by room name.
         """
         query = meetings.select().where(meetings.c.room_name == room_name)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
 
@@ -138,6 +157,7 @@ class MeetingController:
     async def get_active(self, room: Room, current_time: datetime) -> Meeting:
         """
         Get latest active meeting for a room.
+        For backward compatibility, returns the most recent active meeting.
         """
         end_date = getattr(meetings.c, "end_date")
         query = (
@@ -151,18 +171,59 @@ class MeetingController:
             )
             .order_by(end_date.desc())
         )
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
 
         return Meeting(**result)
 
+    async def get_all_active_for_room(
+        self, room: Room, current_time: datetime
+    ) -> list[Meeting]:
+        """
+        Get all active meetings for a room.
+        This supports multiple concurrent meetings per room.
+        """
+        end_date = getattr(meetings.c, "end_date")
+        query = (
+            meetings.select()
+            .where(
+                sa.and_(
+                    meetings.c.room_id == room.id,
+                    meetings.c.end_date > current_time,
+                    meetings.c.is_active,
+                )
+            )
+            .order_by(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:
+        """
+        Get active meeting for a specific calendar event.
+        """
+        query = meetings.select().where(
+            sa.and_(
+                meetings.c.room_id == room.id,
+                meetings.c.calendar_event_id == calendar_event_id,
+                meetings.c.end_date > current_time,
+                meetings.c.is_active,
+            )
+        )
+        result = await get_database().fetch_one(query)
+        if not result:
+            return None
+        return Meeting(**result)
+
     async def get_by_id(self, meeting_id: str, **kwargs) -> Meeting | None:
         """
         Get a meeting by id
         """
         query = meetings.select().where(meetings.c.id == meeting_id)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
         return Meeting(**result)
@@ -174,7 +235,7 @@ class MeetingController:
         If not found, it will raise a 404 error.
         """
         query = meetings.select().where(meetings.c.id == meeting_id)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             raise HTTPException(status_code=404, detail="Meeting not found")
 
@@ -184,9 +245,18 @@ class MeetingController:
 
         return meeting
 
+    async def get_by_calendar_event(self, calendar_event_id: str) -> Meeting | None:
+        query = meetings.select().where(
+            meetings.c.calendar_event_id == calendar_event_id
+        )
+        result = await get_database().fetch_one(query)
+        if not result:
+            return None
+        return Meeting(**result)
+
     async def update_meeting(self, meeting_id: str, **kwargs):
         query = meetings.update().where(meetings.c.id == meeting_id).values(**kwargs)
-        await database.execute(query)
+        await get_database().execute(query)
 
 
 class MeetingConsentController:
@@ -194,7 +264,7 @@ class MeetingConsentController:
         query = meeting_consent.select().where(
             meeting_consent.c.meeting_id == meeting_id
         )
-        results = await database.fetch_all(query)
+        results = await get_database().fetch_all(query)
         return [MeetingConsent(**result) for result in results]
 
     async def get_by_meeting_and_user(
@@ -205,7 +275,7 @@ class MeetingConsentController:
             meeting_consent.c.meeting_id == meeting_id,
             meeting_consent.c.user_id == user_id,
         )
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if result is None:
             return None
         return MeetingConsent(**result) if result else None
@@ -227,14 +297,14 @@ class MeetingConsentController:
                         consent_timestamp=consent.consent_timestamp,
                     )
                 )
-                await database.execute(query)
+                await get_database().execute(query)
 
                 existing.consent_given = consent.consent_given
                 existing.consent_timestamp = consent.consent_timestamp
                 return existing
 
         query = meeting_consent.insert().values(**consent.model_dump())
-        await database.execute(query)
+        await get_database().execute(query)
         return consent
 
     async def has_any_denial(self, meeting_id: str) -> bool:
@@ -243,7 +313,7 @@ class MeetingConsentController:
             meeting_consent.c.meeting_id == meeting_id,
             meeting_consent.c.consent_given.is_(False),
         )
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         return result is not None
 
 

server/reflector/db/recordings.py

@@ -4,7 +4,7 @@ from typing import Literal
 import sqlalchemy as sa
 from pydantic import BaseModel, Field
 
-from reflector.db import database, metadata
+from reflector.db import get_database, metadata
 from reflector.utils import generate_uuid4
 
 recordings = sa.Table(
@@ -13,7 +13,7 @@ recordings = sa.Table(
     sa.Column("id", sa.String, primary_key=True),
     sa.Column("bucket_name", sa.String, nullable=False),
     sa.Column("object_key", sa.String, nullable=False),
-    sa.Column("recorded_at", sa.DateTime, nullable=False),
+    sa.Column("recorded_at", sa.DateTime(timezone=True), nullable=False),
     sa.Column(
         "status",
         sa.String,
@@ -37,12 +37,12 @@ class Recording(BaseModel):
 class RecordingController:
     async def create(self, recording: Recording):
         query = recordings.insert().values(**recording.model_dump())
-        await database.execute(query)
+        await get_database().execute(query)
         return recording
 
     async def get_by_id(self, id: str) -> Recording:
         query = recordings.select().where(recordings.c.id == id)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         return Recording(**result) if result else None
 
     async def get_by_object_key(self, bucket_name: str, object_key: str) -> Recording:
@@ -50,8 +50,12 @@ class RecordingController:
             recordings.c.bucket_name == bucket_name,
             recordings.c.object_key == object_key,
         )
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         return Recording(**result) if result else None
 
+    async def remove_by_id(self, id: str) -> None:
+        query = recordings.delete().where(recordings.c.id == id)
+        await get_database().execute(query)
+
 
 recordings_controller = RecordingController()

server/reflector/db/rooms.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from sqlite3 import IntegrityError
 from typing import Literal
 
@@ -7,7 +7,7 @@ from fastapi import HTTPException
 from pydantic import BaseModel, Field
 from sqlalchemy.sql import false, or_
 
-from reflector.db import database, metadata
+from reflector.db import get_database, metadata
 from reflector.utils import generate_uuid4
 
 rooms = sqlalchemy.Table(
@@ -16,7 +16,7 @@ rooms = sqlalchemy.Table(
     sqlalchemy.Column("id", sqlalchemy.String, primary_key=True),
     sqlalchemy.Column("name", sqlalchemy.String, nullable=False, unique=True),
     sqlalchemy.Column("user_id", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("created_at", sqlalchemy.DateTime, nullable=False),
+    sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True), nullable=False),
     sqlalchemy.Column(
         "zulip_auto_post", sqlalchemy.Boolean, nullable=False, server_default=false()
     ),
@@ -40,7 +40,15 @@ rooms = sqlalchemy.Table(
     sqlalchemy.Column(
         "is_shared", sqlalchemy.Boolean, nullable=False, server_default=false()
     ),
+    sqlalchemy.Column("ics_url", sqlalchemy.Text),
+    sqlalchemy.Column("ics_fetch_interval", sqlalchemy.Integer, server_default="300"),
+    sqlalchemy.Column(
+        "ics_enabled", sqlalchemy.Boolean, nullable=False, server_default=false()
+    ),
+    sqlalchemy.Column("ics_last_sync", sqlalchemy.DateTime(timezone=True)),
+    sqlalchemy.Column("ics_last_etag", sqlalchemy.Text),
     sqlalchemy.Index("idx_room_is_shared", "is_shared"),
+    sqlalchemy.Index("idx_room_ics_enabled", "ics_enabled"),
 )
 
 
@@ -48,7 +56,7 @@ class Room(BaseModel):
     id: str = Field(default_factory=generate_uuid4)
     name: str
     user_id: str
-    created_at: datetime = Field(default_factory=datetime.utcnow)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     zulip_auto_post: bool = False
     zulip_stream: str = ""
     zulip_topic: str = ""
@@ -59,6 +67,11 @@ class Room(BaseModel):
         "none", "prompt", "automatic", "automatic-2nd-participant"
     ] = "automatic-2nd-participant"
     is_shared: bool = False
+    ics_url: str | None = None
+    ics_fetch_interval: int = 300
+    ics_enabled: bool = False
+    ics_last_sync: datetime | None = None
+    ics_last_etag: str | None = None
 
 
 class RoomController:
@@ -92,7 +105,7 @@ class RoomController:
         if return_query:
             return query
 
-        results = await database.fetch_all(query)
+        results = await get_database().fetch_all(query)
         return results
 
     async def add(
@@ -107,6 +120,9 @@ class RoomController:
         recording_type: str,
         recording_trigger: str,
         is_shared: bool,
+        ics_url: str | None = None,
+        ics_fetch_interval: int = 300,
+        ics_enabled: bool = False,
     ):
         """
         Add a new room
@@ -122,10 +138,13 @@ class RoomController:
             recording_type=recording_type,
             recording_trigger=recording_trigger,
             is_shared=is_shared,
+            ics_url=ics_url,
+            ics_fetch_interval=ics_fetch_interval,
+            ics_enabled=ics_enabled,
         )
         query = rooms.insert().values(**room.model_dump())
         try:
-            await database.execute(query)
+            await get_database().execute(query)
         except IntegrityError:
             raise HTTPException(status_code=400, detail="Room name is not unique")
         return room
@@ -136,7 +155,7 @@ class RoomController:
         """
         query = rooms.update().where(rooms.c.id == room.id).values(**values)
         try:
-            await database.execute(query)
+            await get_database().execute(query)
         except IntegrityError:
             raise HTTPException(status_code=400, detail="Room name is not unique")
 
@@ -151,7 +170,7 @@ class RoomController:
         query = rooms.select().where(rooms.c.id == room_id)
         if "user_id" in kwargs:
             query = query.where(rooms.c.user_id == kwargs["user_id"])
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
         return Room(**result)
@@ -163,7 +182,7 @@ class RoomController:
         query = rooms.select().where(rooms.c.name == room_name)
         if "user_id" in kwargs:
             query = query.where(rooms.c.user_id == kwargs["user_id"])
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
         return Room(**result)
@@ -175,7 +194,7 @@ class RoomController:
         If not found, it will raise a 404 error.
         """
         query = rooms.select().where(rooms.c.id == meeting_id)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             raise HTTPException(status_code=404, detail="Room not found")
 
@@ -197,7 +216,7 @@ class RoomController:
         if user_id is not None and room.user_id != user_id:
             return
         query = rooms.delete().where(rooms.c.id == room_id)
-        await database.execute(query)
+        await get_database().execute(query)
 
 
 rooms_controller = RoomController()

server/reflector/db/search.py

@@ -0,0 +1,231 @@
+"""Search functionality for transcripts and other entities."""
+
+from datetime import datetime
+from io import StringIO
+from typing import Annotated, Any, Dict
+
+import sqlalchemy
+import webvtt
+from pydantic import BaseModel, Field, constr, field_serializer
+
+from reflector.db import get_database
+from reflector.db.transcripts import SourceKind, transcripts
+from reflector.db.utils import is_postgresql
+from reflector.logger import logger
+
+DEFAULT_SEARCH_LIMIT = 20
+SNIPPET_CONTEXT_LENGTH = 50  # Characters before/after match to include
+DEFAULT_SNIPPET_MAX_LENGTH = 150
+DEFAULT_MAX_SNIPPETS = 3
+
+SearchQueryBase = constr(min_length=1, strip_whitespace=True)
+SearchLimitBase = Annotated[int, Field(ge=1, le=100)]
+SearchOffsetBase = Annotated[int, Field(ge=0)]
+SearchTotalBase = Annotated[int, Field(ge=0)]
+
+SearchQuery = Annotated[SearchQueryBase, Field(description="Search query text")]
+SearchLimit = Annotated[SearchLimitBase, Field(description="Results per page")]
+SearchOffset = Annotated[
+    SearchOffsetBase, Field(description="Number of results to skip")
+]
+SearchTotal = Annotated[
+    SearchTotalBase, Field(description="Total number of search results")
+]
+
+
+class SearchParameters(BaseModel):
+    """Validated search parameters for full-text search."""
+
+    query_text: SearchQuery
+    limit: SearchLimit = DEFAULT_SEARCH_LIMIT
+    offset: SearchOffset = 0
+    user_id: str | None = None
+    room_id: str | None = None
+
+
+class SearchResultDB(BaseModel):
+    """Intermediate model for validating raw database results."""
+
+    id: str = Field(..., min_length=1)
+    created_at: datetime
+    status: str = Field(..., min_length=1)
+    duration: float | None = Field(None, ge=0)
+    user_id: str | None = None
+    title: str | None = None
+    source_kind: SourceKind
+    room_id: str | None = None
+    rank: float = Field(..., ge=0, le=1)
+
+
+class SearchResult(BaseModel):
+    """Public search result model with computed fields."""
+
+    id: str = Field(..., min_length=1)
+    title: str | None = None
+    user_id: str | None = None
+    room_id: str | None = None
+    created_at: datetime
+    status: str = Field(..., min_length=1)
+    rank: float = Field(..., ge=0, le=1)
+    duration: float | None = Field(..., ge=0, description="Duration in seconds")
+    search_snippets: list[str] = Field(
+        description="Text snippets around search matches"
+    )
+
+    @field_serializer("created_at", when_used="json")
+    def serialize_datetime(self, dt: datetime) -> str:
+        if dt.tzinfo is None:
+            return dt.isoformat() + "Z"
+        return dt.isoformat()
+
+
+class SearchController:
+    """Controller for search operations across different entities."""
+
+    @staticmethod
+    def _extract_webvtt_text(webvtt_content: str) -> str:
+        """Extract plain text from WebVTT content using webvtt library."""
+        if not webvtt_content:
+            return ""
+
+        try:
+            buffer = StringIO(webvtt_content)
+            vtt = webvtt.read_buffer(buffer)
+            return " ".join(caption.text for caption in vtt if caption.text)
+        except (webvtt.errors.MalformedFileError, UnicodeDecodeError, ValueError) as e:
+            logger.warning(f"Failed to parse WebVTT content: {e}", exc_info=e)
+            return ""
+        except AttributeError as e:
+            logger.warning(f"WebVTT parsing error - unexpected format: {e}", exc_info=e)
+            return ""
+
+    @staticmethod
+    def _generate_snippets(
+        text: str,
+        q: SearchQuery,
+        max_length: int = DEFAULT_SNIPPET_MAX_LENGTH,
+        max_snippets: int = DEFAULT_MAX_SNIPPETS,
+    ) -> list[str]:
+        """Generate multiple snippets around all occurrences of search term."""
+        if not text or not q:
+            return []
+
+        snippets = []
+        lower_text = text.lower()
+        search_lower = q.lower()
+
+        last_snippet_end = 0
+        start_pos = 0
+
+        while len(snippets) < max_snippets:
+            match_pos = lower_text.find(search_lower, start_pos)
+
+            if match_pos == -1:
+                if not snippets and search_lower.split():
+                    first_word = search_lower.split()[0]
+                    match_pos = lower_text.find(first_word, start_pos)
+                    if match_pos == -1:
+                        break
+                else:
+                    break
+
+            snippet_start = max(0, match_pos - SNIPPET_CONTEXT_LENGTH)
+            snippet_end = min(
+                len(text), match_pos + max_length - SNIPPET_CONTEXT_LENGTH
+            )
+
+            if snippet_start < last_snippet_end:
+                start_pos = match_pos + len(search_lower)
+                continue
+
+            snippet = text[snippet_start:snippet_end]
+
+            if snippet_start > 0:
+                snippet = "..." + snippet
+            if snippet_end < len(text):
+                snippet = snippet + "..."
+
+            snippet = snippet.strip()
+
+            if snippet:
+                snippets.append(snippet)
+                last_snippet_end = snippet_end
+
+            start_pos = match_pos + len(search_lower)
+            if start_pos >= len(text):
+                break
+
+        return snippets
+
+    @classmethod
+    async def search_transcripts(
+        cls, params: SearchParameters
+    ) -> tuple[list[SearchResult], int]:
+        """
+        Full-text search for transcripts using PostgreSQL tsvector.
+        Returns (results, total_count).
+        """
+
+        if not is_postgresql():
+            logger.warning(
+                "Full-text search requires PostgreSQL. Returning empty results."
+            )
+            return [], 0
+
+        search_query = sqlalchemy.func.websearch_to_tsquery(
+            "english", params.query_text
+        )
+
+        base_query = sqlalchemy.select(
+            [
+                transcripts.c.id,
+                transcripts.c.title,
+                transcripts.c.created_at,
+                transcripts.c.duration,
+                transcripts.c.status,
+                transcripts.c.user_id,
+                transcripts.c.room_id,
+                transcripts.c.source_kind,
+                transcripts.c.webvtt,
+                sqlalchemy.func.ts_rank(
+                    transcripts.c.search_vector_en,
+                    search_query,
+                    32,  # normalization flag: rank/(rank+1) for 0-1 range
+                ).label("rank"),
+            ]
+        ).where(transcripts.c.search_vector_en.op("@@")(search_query))
+
+        if params.user_id:
+            base_query = base_query.where(transcripts.c.user_id == params.user_id)
+        if params.room_id:
+            base_query = base_query.where(transcripts.c.room_id == params.room_id)
+
+        query = (
+            base_query.order_by(sqlalchemy.desc(sqlalchemy.text("rank")))
+            .limit(params.limit)
+            .offset(params.offset)
+        )
+        rs = await get_database().fetch_all(query)
+
+        count_query = sqlalchemy.select([sqlalchemy.func.count()]).select_from(
+            base_query.alias("search_results")
+        )
+        total = await get_database().fetch_val(count_query)
+
+        def _process_result(r) -> SearchResult:
+            r_dict: Dict[str, Any] = dict(r)
+            webvtt: str | None = r_dict.pop("webvtt", None)
+            db_result = SearchResultDB.model_validate(r_dict)
+
+            snippets = []
+            if webvtt:
+                plain_text = cls._extract_webvtt_text(webvtt)
+                snippets = cls._generate_snippets(plain_text, params.query_text)
+
+            return SearchResult(**db_result.model_dump(), search_snippets=snippets)
+
+        results = [_process_result(r) for r in rs]
+        return results, total
+
+
+search_controller = SearchController()

server/reflector/db/transcripts.py

@@ -3,7 +3,7 @@ import json
 import os
 import shutil
 from contextlib import asynccontextmanager
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Literal
 
@@ -11,13 +11,19 @@ import sqlalchemy
 from fastapi import HTTPException
 from pydantic import BaseModel, ConfigDict, Field, field_serializer
 from sqlalchemy import Enum
+from sqlalchemy.dialects.postgresql import TSVECTOR
 from sqlalchemy.sql import false, or_
 
-from reflector.db import database, metadata
+from reflector.db import get_database, metadata
+from reflector.db.recordings import recordings_controller
+from reflector.db.rooms import rooms
+from reflector.db.utils import is_postgresql
+from reflector.logger import logger
 from reflector.processors.types import Word as ProcessorWord
 from reflector.settings import settings
-from reflector.storage import get_transcripts_storage
+from reflector.storage import get_recordings_storage, get_transcripts_storage
 from reflector.utils import generate_uuid4
+from reflector.utils.webvtt import topics_to_webvtt
 
 
 class SourceKind(enum.StrEnum):
@@ -34,7 +40,7 @@ transcripts = sqlalchemy.Table(
     sqlalchemy.Column("status", sqlalchemy.String),
     sqlalchemy.Column("locked", sqlalchemy.Boolean),
     sqlalchemy.Column("duration", sqlalchemy.Float),
-    sqlalchemy.Column("created_at", sqlalchemy.DateTime),
+    sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True)),
     sqlalchemy.Column("title", sqlalchemy.String),
     sqlalchemy.Column("short_summary", sqlalchemy.String),
     sqlalchemy.Column("long_summary", sqlalchemy.String),
@@ -76,6 +82,7 @@ transcripts = sqlalchemy.Table(
     # same field could've been in recording/meeting, and it's maybe even ok to dupe it at need
     sqlalchemy.Column("audio_deleted", sqlalchemy.Boolean),
     sqlalchemy.Column("room_id", sqlalchemy.String),
+    sqlalchemy.Column("webvtt", sqlalchemy.Text),
     sqlalchemy.Index("idx_transcript_recording_id", "recording_id"),
     sqlalchemy.Index("idx_transcript_user_id", "user_id"),
     sqlalchemy.Index("idx_transcript_created_at", "created_at"),
@@ -83,6 +90,29 @@ transcripts = sqlalchemy.Table(
     sqlalchemy.Index("idx_transcript_room_id", "room_id"),
 )
 
+# Add PostgreSQL-specific full-text search column
+# This matches the migration in migrations/versions/116b2f287eab_add_full_text_search.py
+if is_postgresql():
+    transcripts.append_column(
+        sqlalchemy.Column(
+            "search_vector_en",
+            TSVECTOR,
+            sqlalchemy.Computed(
+                "setweight(to_tsvector('english', coalesce(title, '')), 'A') || "
+                "setweight(to_tsvector('english', coalesce(webvtt, '')), 'B')",
+                persisted=True,
+            ),
+        )
+    )
+    # Add GIN index for the search vector
+    transcripts.append_constraint(
+        sqlalchemy.Index(
+            "idx_transcript_search_vector_en",
+            "search_vector_en",
+            postgresql_using="gin",
+        )
+    )
+
 
 def generate_transcript_name() -> str:
     now = datetime.now(timezone.utc)
@@ -147,14 +177,18 @@ class TranscriptParticipant(BaseModel):
 
 
 class Transcript(BaseModel):
+    """Full transcript model with all fields."""
+
     id: str = Field(default_factory=generate_uuid4)
     user_id: str | None = None
     name: str = Field(default_factory=generate_transcript_name)
     status: str = "idle"
-    locked: bool = False
     duration: float = 0
     created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     title: str | None = None
+    source_kind: SourceKind
+    room_id: str | None = None
+    locked: bool = False
     short_summary: str | None = None
     long_summary: str | None = None
     topics: list[TranscriptTopic] = []
@@ -168,9 +202,8 @@ class Transcript(BaseModel):
     meeting_id: str | None = None
     recording_id: str | None = None
     zulip_message_id: int | None = None
-    source_kind: SourceKind
     audio_deleted: bool | None = None
-    room_id: str | None = None
+    webvtt: str | None = None
 
     @field_serializer("created_at", when_used="json")
     def serialize_datetime(self, dt: datetime) -> str:
@@ -271,10 +304,12 @@ class Transcript(BaseModel):
         # we need to create an url to be used for diarization
         # we can't use the audio_mp3_filename because it's not accessible
         # from the diarization processor
-        from datetime import timedelta
 
-        from reflector.app import app
-        from reflector.views.transcripts import create_access_token
+        # TODO don't import app in db
+        from reflector.app import app  # noqa: PLC0415
+
+        # TODO a util + don''t import views in db
+        from reflector.views.transcripts import create_access_token  # noqa: PLC0415
 
         path = app.url_path_for(
             "transcript_get_audio_mp3",
@@ -335,7 +370,6 @@ class TranscriptController:
         - `room_id`: filter transcripts by room ID
         - `search_term`: filter transcripts by search term
         """
-        from reflector.db.rooms import rooms
 
         query = transcripts.select().join(
             rooms, transcripts.c.room_id == rooms.c.id, isouter=True
@@ -386,7 +420,7 @@ class TranscriptController:
         if return_query:
             return query
 
-        results = await database.fetch_all(query)
+        results = await get_database().fetch_all(query)
         return results
 
     async def get_by_id(self, transcript_id: str, **kwargs) -> Transcript | None:
@@ -396,7 +430,7 @@ class TranscriptController:
         query = transcripts.select().where(transcripts.c.id == transcript_id)
         if "user_id" in kwargs:
             query = query.where(transcripts.c.user_id == kwargs["user_id"])
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
         return Transcript(**result)
@@ -410,7 +444,7 @@ class TranscriptController:
         query = transcripts.select().where(transcripts.c.recording_id == recording_id)
         if "user_id" in kwargs:
             query = query.where(transcripts.c.user_id == kwargs["user_id"])
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
         return Transcript(**result)
@@ -428,7 +462,7 @@ class TranscriptController:
             if order_by.startswith("-"):
                 field = field.desc()
             query = query.order_by(field)
-        results = await database.fetch_all(query)
+        results = await get_database().fetch_all(query)
         return [Transcript(**result) for result in results]
 
     async def get_by_id_for_http(
@@ -446,7 +480,7 @@ class TranscriptController:
         to determine if the user can access the transcript.
         """
         query = transcripts.select().where(transcripts.c.id == transcript_id)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             raise HTTPException(status_code=404, detail="Transcript not found")
 
@@ -499,23 +533,52 @@ class TranscriptController:
             room_id=room_id,
         )
         query = transcripts.insert().values(**transcript.model_dump())
-        await database.execute(query)
+        await get_database().execute(query)
         return transcript
 
-    async def update(self, transcript: Transcript, values: dict, mutate=True):
+    # TODO investigate why mutate= is used. it's used in one place currently, maybe because of ORM field updates.
+    # using mutate=True is discouraged
+    async def update(
+        self, transcript: Transcript, values: dict, mutate=False
+    ) -> Transcript:
         """
-        Update a transcript fields with key/values in values
+        Update a transcript fields with key/values in values.
+        Returns a copy of the transcript with updated values.
         """
+        values = TranscriptController._handle_topics_update(values)
+
         query = (
             transcripts.update()
             .where(transcripts.c.id == transcript.id)
             .values(**values)
         )
-        await database.execute(query)
+        await get_database().execute(query)
         if mutate:
             for key, value in values.items():
                 setattr(transcript, key, value)
 
+        updated_transcript = transcript.model_copy(update=values)
+        return updated_transcript
+
+    @staticmethod
+    def _handle_topics_update(values: dict) -> dict:
+        """Auto-update WebVTT when topics are updated."""
+
+        if values.get("webvtt") is not None:
+            logger.warn("trying to update read-only webvtt column")
+            pass
+
+        topics_data = values.get("topics")
+        if topics_data is None:
+            return values
+
+        return {
+            **values,
+            "webvtt": topics_to_webvtt(
+                [TranscriptTopic(**topic_dict) for topic_dict in topics_data]
+            ),
+        }
+
     async def remove_by_id(
         self,
         transcript_id: str,
@@ -529,23 +592,55 @@ class TranscriptController:
             return
         if user_id is not None and transcript.user_id != user_id:
             return
+        if transcript.audio_location == "storage" and not transcript.audio_deleted:
+            try:
+                await get_transcripts_storage().delete_file(
+                    transcript.storage_audio_path
+                )
+            except Exception as e:
+                logger.warning(
+                    "Failed to delete transcript audio from storage",
+                    exc_info=e,
+                    transcript_id=transcript.id,
+                )
         transcript.unlink()
+        if transcript.recording_id:
+            try:
+                recording = await recordings_controller.get_by_id(
+                    transcript.recording_id
+                )
+                if recording:
+                    try:
+                        await get_recordings_storage().delete_file(recording.object_key)
+                    except Exception as e:
+                        logger.warning(
+                            "Failed to delete recording object from S3",
+                            exc_info=e,
+                            recording_id=transcript.recording_id,
+                        )
+                    await recordings_controller.remove_by_id(transcript.recording_id)
+            except Exception as e:
+                logger.warning(
+                    "Failed to delete recording row",
+                    exc_info=e,
+                    recording_id=transcript.recording_id,
+                )
         query = transcripts.delete().where(transcripts.c.id == transcript_id)
-        await database.execute(query)
+        await get_database().execute(query)
 
     async def remove_by_recording_id(self, recording_id: str):
         """
         Remove a transcript by recording_id
         """
         query = transcripts.delete().where(transcripts.c.recording_id == recording_id)
-        await database.execute(query)
+        await get_database().execute(query)
 
     @asynccontextmanager
     async def transaction(self):
         """
         A context manager for database transaction
         """
-        async with database.transaction(isolation="serializable"):
+        async with get_database().transaction(isolation="serializable"):
             yield
 
     async def append_event(
@@ -558,11 +653,7 @@ class TranscriptController:
         Append an event to a transcript
         """
         resp = transcript.add_event(event=event, data=data)
-        await self.update(
-            transcript,
-            {"events": transcript.events_dump()},
-            mutate=False,
-        )
+        await self.update(transcript, {"events": transcript.events_dump()})
         return resp
 
     async def upsert_topic(
@@ -574,11 +665,7 @@ class TranscriptController:
         Upsert topics to a transcript
         """
         transcript.upsert_topic(topic)
-        await self.update(
-            transcript,
-            {"topics": transcript.topics_dump()},
-            mutate=False,
-        )
+        await self.update(transcript, {"topics": transcript.topics_dump()})
 
     async def move_mp3_to_storage(self, transcript: Transcript):
         """
@@ -603,7 +690,8 @@ class TranscriptController:
             )
 
             # indicate on the transcript that the audio is now on storage
-            await self.update(transcript, {"audio_location": "storage"})
+            # mutates transcript argument
+            await self.update(transcript, {"audio_location": "storage"}, mutate=True)
 
         # unlink the local file
         transcript.audio_mp3_filename.unlink(missing_ok=True)
@@ -627,11 +715,7 @@ class TranscriptController:
         Add/update a participant to a transcript
         """
         result = transcript.upsert_participant(participant)
-        await self.update(
-            transcript,
-            {"participants": transcript.participants_dump()},
-            mutate=False,
-        )
+        await self.update(transcript, {"participants": transcript.participants_dump()})
         return result
 
     async def delete_participant(
@@ -643,11 +727,7 @@ class TranscriptController:
         Delete a participant from a transcript
         """
         transcript.delete_participant(participant_id)
-        await self.update(
-            transcript,
-            {"participants": transcript.participants_dump()},
-            mutate=False,
-        )
+        await self.update(transcript, {"participants": transcript.participants_dump()})
 
 
 transcripts_controller = TranscriptController()

server/reflector/db/utils.py

@@ -0,0 +1,9 @@
+"""Database utility functions."""
+
+from reflector.db import get_database
+
+
+def is_postgresql() -> bool:
+    return get_database().url.scheme and get_database().url.scheme.startswith(
+        "postgresql"
+    )

server/reflector/pipelines/main_live_pipeline.py

@@ -14,12 +14,15 @@ It is directly linked to our data model.
 import asyncio
 import functools
 from contextlib import asynccontextmanager
+from typing import Generic
 
+import av
 import boto3
 from celery import chord, current_task, group, shared_task
 from pydantic import BaseModel
 from structlog import BoundLogger as Logger
 
+from reflector.db import get_database
 from reflector.db.meetings import meeting_consent_controller, meetings_controller
 from reflector.db.recordings import recordings_controller
 from reflector.db.rooms import rooms_controller
@@ -35,7 +38,7 @@ from reflector.db.transcripts import (
     transcripts_controller,
 )
 from reflector.logger import logger
-from reflector.pipelines.runner import PipelineRunner
+from reflector.pipelines.runner import PipelineMessage, PipelineRunner
 from reflector.processors import (
     AudioChunkerProcessor,
     AudioDiarizationAutoProcessor,
@@ -69,8 +72,7 @@ def asynctask(f):
     @functools.wraps(f)
     def wrapper(*args, **kwargs):
         async def run_with_db():
-            from reflector.db import database
-
+            database = get_database()
             await database.connect()
             try:
                 return await f(*args, **kwargs)
@@ -144,7 +146,7 @@ class StrValue(BaseModel):
     value: str
 
 
-class PipelineMainBase(PipelineRunner):
+class PipelineMainBase(PipelineRunner[PipelineMessage], Generic[PipelineMessage]):
     transcript_id: str
     ws_room_id: str | None = None
     ws_manager: WebsocketManager | None = None
@@ -164,7 +166,11 @@ class PipelineMainBase(PipelineRunner):
             raise Exception("Transcript not found")
         return result
 
-    def get_transcript_topics(self, transcript: Transcript) -> list[TranscriptTopic]:
+    @staticmethod
+    def wrap_transcript_topics(
+        topics: list[TranscriptTopic],
+    ) -> list[TitleSummaryWithIdProcessorType]:
+        # transformation to a pipe-supported format
         return [
             TitleSummaryWithIdProcessorType(
                 id=topic.id,
@@ -174,7 +180,7 @@ class PipelineMainBase(PipelineRunner):
                 duration=topic.duration,
                 transcript=TranscriptProcessorType(words=topic.words),
             )
-            for topic in transcript.topics
+            for topic in topics
         ]
 
     @asynccontextmanager
@@ -380,7 +386,7 @@ class PipelineMainLive(PipelineMainBase):
         pipeline_post(transcript_id=self.transcript_id)
 
 
-class PipelineMainDiarization(PipelineMainBase):
+class PipelineMainDiarization(PipelineMainBase[AudioDiarizationInput]):
     """
     Diarize the audio and update topics
     """
@@ -404,11 +410,10 @@ class PipelineMainDiarization(PipelineMainBase):
             pipeline.logger.info("Audio is local, skipping diarization")
             return
 
-        topics = self.get_transcript_topics(transcript)
         audio_url = await transcript.get_audio_url()
         audio_diarization_input = AudioDiarizationInput(
             audio_url=audio_url,
-            topics=topics,
+            topics=self.wrap_transcript_topics(transcript.topics),
         )
 
         # as tempting to use pipeline.push, prefer to use the runner
@@ -421,7 +426,7 @@ class PipelineMainDiarization(PipelineMainBase):
         return pipeline
 
 
-class PipelineMainFromTopics(PipelineMainBase):
+class PipelineMainFromTopics(PipelineMainBase[TitleSummaryWithIdProcessorType]):
     """
     Pseudo class for generating a pipeline from topics
     """
@@ -443,7 +448,7 @@ class PipelineMainFromTopics(PipelineMainBase):
         pipeline.logger.info(f"{self.__class__.__name__} pipeline created")
 
         # push topics
-        topics = self.get_transcript_topics(transcript)
+        topics = PipelineMainBase.wrap_transcript_topics(transcript.topics)
         for topic in topics:
             await self.push(topic)
 
@@ -524,8 +529,6 @@ async def pipeline_convert_to_mp3(transcript: Transcript, logger: Logger):
     # Convert to mp3
     mp3_filename = transcript.audio_mp3_filename
 
-    import av
-
     with av.open(wav_filename.as_posix()) as in_container:
         in_stream = in_container.streams.audio[0]
         with av.open(mp3_filename.as_posix(), "w") as out_container:
@@ -604,7 +607,7 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
                         meeting.id
                     )
     except Exception as e:
-        logger.error(f"Failed to get fetch consent: {e}")
+        logger.error(f"Failed to get fetch consent: {e}", exc_info=e)
         consent_denied = True
 
     if not consent_denied:
@@ -627,7 +630,7 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
                 f"Deleted original Whereby recording: {recording.bucket_name}/{recording.object_key}"
             )
         except Exception as e:
-            logger.error(f"Failed to delete Whereby recording: {e}")
+            logger.error(f"Failed to delete Whereby recording: {e}", exc_info=e)
 
     # non-transactional, files marked for deletion not actually deleted is possible
     await transcripts_controller.update(transcript, {"audio_deleted": True})
@@ -640,7 +643,7 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
                 f"Deleted processed audio from storage: {transcript.storage_audio_path}"
             )
         except Exception as e:
-            logger.error(f"Failed to delete processed audio: {e}")
+            logger.error(f"Failed to delete processed audio: {e}", exc_info=e)
 
     # 3. Delete local audio files
     try:
@@ -649,7 +652,7 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
         if hasattr(transcript, "audio_wav_filename") and transcript.audio_wav_filename:
             transcript.audio_wav_filename.unlink(missing_ok=True)
     except Exception as e:
-        logger.error(f"Failed to delete local audio files: {e}")
+        logger.error(f"Failed to delete local audio files: {e}", exc_info=e)
 
     logger.info("Consent cleanup done")
 
@@ -794,8 +797,6 @@ def pipeline_post(*, transcript_id: str):
 
 @get_transcript
 async def pipeline_process(transcript: Transcript, logger: Logger):
-    import av
-
     try:
         if transcript.audio_location == "storage":
             await transcripts_controller.download_mp3_from_storage(transcript)

server/reflector/pipelines/runner.py

@@ -16,14 +16,17 @@ During its lifecycle, it will emit the following status:
 """
 
 import asyncio
+from typing import Generic, TypeVar
 
 from pydantic import BaseModel, ConfigDict
 
 from reflector.logger import logger
 from reflector.processors import Pipeline
 
+PipelineMessage = TypeVar("PipelineMessage")
 
-class PipelineRunner(BaseModel):
+
+class PipelineRunner(BaseModel, Generic[PipelineMessage]):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     status: str = "idle"
@@ -67,7 +70,7 @@ class PipelineRunner(BaseModel):
         coro = self.run()
         asyncio.run(coro)
 
-    async def push(self, data):
+    async def push(self, data: PipelineMessage):
         """
         Push data to the pipeline
         """
@@ -92,7 +95,11 @@ class PipelineRunner(BaseModel):
         pass
 
     async def _add_cmd(
-        self, cmd: str, data, max_retries: int = 3, retry_time_limit: int = 3
+        self,
+        cmd: str,
+        data: PipelineMessage,
+        max_retries: int = 3,
+        retry_time_limit: int = 3,
     ):
         """
         Enqueue a command to be executed in the runner.
@@ -143,7 +150,10 @@ class PipelineRunner(BaseModel):
                 cmd, data = await self._q_cmd.get()
                 func = getattr(self, f"cmd_{cmd.lower()}")
                 if func:
-                    await func(data)
+                    if cmd.upper() == "FLUSH":
+                        await func()
+                    else:
+                        await func(data)
                 else:
                     raise Exception(f"Unknown command {cmd}")
         except Exception:
@@ -152,13 +162,13 @@ class PipelineRunner(BaseModel):
             self._ev_done.set()
             raise
 
-    async def cmd_push(self, data):
+    async def cmd_push(self, data: PipelineMessage):
         if self._is_first_push:
             await self._set_status("push")
             self._is_first_push = False
         await self.pipeline.push(data)
 
-    async def cmd_flush(self, data):
+    async def cmd_flush(self):
         await self._set_status("flush")
         await self.pipeline.flush()
         await self._set_status("ended")

server/reflector/processors/audio_diarization.py

@@ -1,5 +1,9 @@
 from reflector.processors.base import Processor
-from reflector.processors.types import AudioDiarizationInput, TitleSummary, Word
+from reflector.processors.types import (
+    AudioDiarizationInput,
+    TitleSummary,
+    Word,
+)
 
 
 class AudioDiarizationProcessor(Processor):

server/reflector/processors/summary/summary_builder.py

@@ -6,7 +6,7 @@ This script is used to generate a summary of a meeting notes transcript.
 
 import asyncio
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
 from textwrap import dedent
 from typing import Type, TypeVar
@@ -474,7 +474,7 @@ if __name__ == "__main__":
 
         if args.save:
             # write the summary to a file, on the format summary-<iso date>.md
-            filename = f"summary-{datetime.now().isoformat()}.md"
+            filename = f"summary-{datetime.now(timezone.utc).isoformat()}.md"
             with open(filename, "w", encoding="utf-8") as f:
                 f.write(sm.as_markdown())
 

server/reflector/processors/types.py

@@ -2,9 +2,10 @@ import io
 import re
 import tempfile
 from pathlib import Path
+from typing import Annotated
 
 from profanityfilter import ProfanityFilter
-from pydantic import BaseModel, PrivateAttr
+from pydantic import BaseModel, Field, PrivateAttr
 
 from reflector.redis_cache import redis_cache
 
@@ -48,20 +49,70 @@ class AudioFile(BaseModel):
             self._path.unlink()
 
 
+# non-negative seconds with float part
+Seconds = Annotated[float, Field(ge=0.0, description="Time in seconds with float part")]
+
+
 class Word(BaseModel):
     text: str
-    start: float
-    end: float
+    start: Seconds
+    end: Seconds
     speaker: int = 0
 
 
 class TranscriptSegment(BaseModel):
     text: str
-    start: float
-    end: float
+    start: Seconds
+    end: Seconds
     speaker: int = 0
 
 
+def words_to_segments(words: list[Word]) -> list[TranscriptSegment]:
+    # from a list of word, create a list of segments
+    # join the word that are less than 2 seconds apart
+    # but separate if the speaker changes, or if the punctuation is a . , ; : ? !
+    segments = []
+    current_segment = None
+    MAX_SEGMENT_LENGTH = 120
+
+    for word in words:
+        if current_segment is None:
+            current_segment = TranscriptSegment(
+                text=word.text,
+                start=word.start,
+                end=word.end,
+                speaker=word.speaker,
+            )
+            continue
+
+        # If the word is attach to another speaker, push the current segment
+        # and start a new one
+        if word.speaker != current_segment.speaker:
+            segments.append(current_segment)
+            current_segment = TranscriptSegment(
+                text=word.text,
+                start=word.start,
+                end=word.end,
+                speaker=word.speaker,
+            )
+            continue
+
+        # if the word is the end of a sentence, and we have enough content,
+        # add the word to the current segment and push it
+        current_segment.text += word.text
+        current_segment.end = word.end
+
+        have_punc = PUNC_RE.search(word.text)
+        if have_punc and (len(current_segment.text) > MAX_SEGMENT_LENGTH):
+            segments.append(current_segment)
+            current_segment = None
+
+    if current_segment:
+        segments.append(current_segment)
+
+    return segments
+
+
 class Transcript(BaseModel):
     translation: str | None = None
     words: list[Word] = None
@@ -117,49 +168,7 @@ class Transcript(BaseModel):
         return Transcript(text=self.text, translation=self.translation, words=words)
 
     def as_segments(self) -> list[TranscriptSegment]:
-        # from a list of word, create a list of segments
-        # join the word that are less than 2 seconds apart
-        # but separate if the speaker changes, or if the punctuation is a . , ; : ? !
-        segments = []
-        current_segment = None
-        MAX_SEGMENT_LENGTH = 120
-
-        for word in self.words:
-            if current_segment is None:
-                current_segment = TranscriptSegment(
-                    text=word.text,
-                    start=word.start,
-                    end=word.end,
-                    speaker=word.speaker,
-                )
-                continue
-
-            # If the word is attach to another speaker, push the current segment
-            # and start a new one
-            if word.speaker != current_segment.speaker:
-                segments.append(current_segment)
-                current_segment = TranscriptSegment(
-                    text=word.text,
-                    start=word.start,
-                    end=word.end,
-                    speaker=word.speaker,
-                )
-                continue
-
-            # if the word is the end of a sentence, and we have enough content,
-            # add the word to the current segment and push it
-            current_segment.text += word.text
-            current_segment.end = word.end
-
-            have_punc = PUNC_RE.search(word.text)
-            if have_punc and (len(current_segment.text) > MAX_SEGMENT_LENGTH):
-                segments.append(current_segment)
-                current_segment = None
-
-        if current_segment:
-            segments.append(current_segment)
-
-        return segments
+        return words_to_segments(self.words)
 
 
 class TitleSummary(BaseModel):

server/reflector/services/ics_sync.py

@@ -0,0 +1,296 @@
+import hashlib
+from datetime import date, datetime, timedelta, timezone
+from typing import TypedDict
+
+import httpx
+import pytz
+from icalendar import Calendar, Event
+from loguru import logger
+
+from reflector.db.calendar_events import CalendarEvent, calendar_events_controller
+from reflector.db.rooms import Room, rooms_controller
+from reflector.settings import settings
+
+
+class AttendeeData(TypedDict, total=False):
+    email: str | None
+    name: str | None
+    status: str | None
+    role: str | None
+
+
+class EventData(TypedDict):
+    ics_uid: str
+    title: str | None
+    description: str | None
+    location: str | None
+    start_time: datetime
+    end_time: datetime
+    attendees: list[AttendeeData]
+    ics_raw_data: str
+
+
+class SyncStats(TypedDict):
+    events_created: int
+    events_updated: int
+    events_deleted: int
+
+
+class ICSFetchService:
+    def __init__(self):
+        self.client = httpx.AsyncClient(
+            timeout=30.0, headers={"User-Agent": "Reflector/1.0"}
+        )
+
+    async def fetch_ics(self, url: str) -> str:
+        response = await self.client.get(url)
+        response.raise_for_status()
+
+        return response.text
+
+    def parse_ics(self, ics_content: str) -> Calendar:
+        return Calendar.from_ical(ics_content)
+
+    def extract_room_events(
+        self, calendar: Calendar, room_name: str, room_url: str
+    ) -> list[EventData]:
+        events = []
+        now = datetime.now(timezone.utc)
+        window_start = now - timedelta(hours=1)
+        window_end = now + timedelta(hours=24)
+
+        for component in calendar.walk():
+            if component.name == "VEVENT":
+                # Skip cancelled events
+                status = component.get("STATUS", "").upper()
+                if status == "CANCELLED":
+                    continue
+
+                # Check if event matches this room
+                if self._event_matches_room(component, room_name, room_url):
+                    event_data = self._parse_event(component)
+
+                    # Only include events in our time window
+                    if (
+                        event_data
+                        and window_start <= event_data["start_time"] <= window_end
+                    ):
+                        events.append(event_data)
+
+        return events
+
+    def _event_matches_room(self, event: Event, room_name: str, room_url: str) -> bool:
+        location = str(event.get("LOCATION", ""))
+        description = str(event.get("DESCRIPTION", ""))
+
+        # Only match full room URL (with or without protocol)
+        patterns = [
+            room_url,  # Full URL with protocol
+            room_url.replace("https://", ""),  # Without https protocol
+            room_url.replace("http://", ""),  # Without http protocol
+        ]
+
+        # Check location and description for patterns
+        text_to_check = f"{location} {description}".lower()
+
+        for pattern in patterns:
+            if pattern.lower() in text_to_check:
+                return True
+
+        return False
+
+    def _parse_event(self, event: Event) -> EventData | None:
+        # Extract basic fields
+        uid = str(event.get("UID", ""))
+        summary = str(event.get("SUMMARY", ""))
+        description = str(event.get("DESCRIPTION", ""))
+        location = str(event.get("LOCATION", ""))
+
+        # Parse dates
+        dtstart = event.get("DTSTART")
+        dtend = event.get("DTEND")
+
+        if not dtstart:
+            return None
+
+        # Convert to datetime
+        start_time = self._normalize_datetime(
+            dtstart.dt if hasattr(dtstart, "dt") else dtstart
+        )
+        end_time = (
+            self._normalize_datetime(dtend.dt if hasattr(dtend, "dt") else dtend)
+            if dtend
+            else start_time + timedelta(hours=1)
+        )
+
+        # Parse attendees
+        attendees = self._parse_attendees(event)
+
+        # Get raw event data for storage
+        raw_data = event.to_ical().decode("utf-8")
+
+        return {
+            "ics_uid": uid,
+            "title": summary,
+            "description": description,
+            "location": location,
+            "start_time": start_time,
+            "end_time": end_time,
+            "attendees": attendees,
+            "ics_raw_data": raw_data,
+        }
+
+    def _normalize_datetime(self, dt) -> datetime:
+        # Handle date objects (all-day events)
+        if isinstance(dt, date) and not isinstance(dt, datetime):
+            # Convert to datetime at start of day in UTC
+            dt = datetime.combine(dt, datetime.min.time())
+            dt = pytz.UTC.localize(dt)
+        elif isinstance(dt, datetime):
+            # Add UTC timezone if naive
+            if dt.tzinfo is None:
+                dt = pytz.UTC.localize(dt)
+            else:
+                # Convert to UTC
+                dt = dt.astimezone(pytz.UTC)
+
+        return dt
+
+    def _parse_attendees(self, event: Event) -> list[AttendeeData]:
+        attendees = []
+
+        # Parse ATTENDEE properties
+        for attendee in event.get("ATTENDEE", []):
+            if not isinstance(attendee, list):
+                attendee = [attendee]
+
+            for att in attendee:
+                att_data: AttendeeData = {
+                    "email": str(att).replace("mailto:", "") if att else None,
+                    "name": att.params.get("CN") if hasattr(att, "params") else None,
+                    "status": att.params.get("PARTSTAT")
+                    if hasattr(att, "params")
+                    else None,
+                    "role": att.params.get("ROLE") if hasattr(att, "params") else None,
+                }
+                attendees.append(att_data)
+
+        # Add organizer
+        organizer = event.get("ORGANIZER")
+        if organizer:
+            org_data: AttendeeData = {
+                "email": str(organizer).replace("mailto:", "") if organizer else None,
+                "name": organizer.params.get("CN")
+                if hasattr(organizer, "params")
+                else None,
+                "role": "ORGANIZER",
+            }
+            attendees.append(org_data)
+
+        return attendees
+
+
+class ICSSyncService:
+    def __init__(self):
+        self.fetch_service = ICSFetchService()
+
+    async def sync_room_calendar(self, room: Room) -> dict:
+        if not room.ics_enabled or not room.ics_url:
+            return {"status": "skipped", "reason": "ICS not configured"}
+
+        try:
+            # Check if it's time to sync
+            if not self._should_sync(room):
+                return {"status": "skipped", "reason": "Not time to sync yet"}
+
+            # Fetch ICS file
+            ics_content = await self.fetch_service.fetch_ics(room.ics_url)
+
+            # Check if content changed
+            content_hash = hashlib.md5(ics_content.encode()).hexdigest()
+            if room.ics_last_etag == content_hash:
+                logger.info(f"No changes in ICS for room {room.id}")
+                return {"status": "unchanged", "hash": content_hash}
+
+            # Parse calendar
+            calendar = self.fetch_service.parse_ics(ics_content)
+
+            # Build room URL
+            room_url = f"{settings.BASE_URL}/room/{room.name}"
+
+            # Extract matching events
+            events = self.fetch_service.extract_room_events(
+                calendar, room.name, room_url
+            )
+
+            # Sync events to database
+            sync_result = await self._sync_events_to_database(room.id, events)
+
+            # Update room sync metadata
+            await rooms_controller.update(
+                room,
+                {
+                    "ics_last_sync": datetime.now(timezone.utc),
+                    "ics_last_etag": content_hash,
+                },
+                mutate=False,
+            )
+
+            return {
+                "status": "success",
+                "hash": content_hash,
+                "events_found": len(events),
+                **sync_result,
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to sync ICS for room {room.id}: {e}")
+            return {"status": "error", "error": str(e)}
+
+    def _should_sync(self, room: Room) -> bool:
+        if not room.ics_last_sync:
+            return True
+
+        time_since_sync = datetime.now(timezone.utc) - room.ics_last_sync
+        return time_since_sync.total_seconds() >= room.ics_fetch_interval
+
+    async def _sync_events_to_database(
+        self, room_id: str, events: list[EventData]
+    ) -> SyncStats:
+        created = 0
+        updated = 0
+
+        # Track current event IDs
+        current_ics_uids = []
+
+        for event_data in events:
+            # Create CalendarEvent object
+            calendar_event = CalendarEvent(room_id=room_id, **event_data)
+
+            # Upsert event
+            existing = await calendar_events_controller.get_by_ics_uid(
+                room_id, event_data["ics_uid"]
+            )
+
+            if existing:
+                updated += 1
+            else:
+                created += 1
+
+            await calendar_events_controller.upsert(calendar_event)
+            current_ics_uids.append(event_data["ics_uid"])
+
+        # Soft delete events that are no longer in calendar
+        deleted = await calendar_events_controller.soft_delete_missing(
+            room_id, current_ics_uids
+        )
+
+        return {
+            "events_created": created,
+            "events_updated": updated,
+            "events_deleted": deleted,
+        }
+
+
+# Global instance
+ics_sync_service = ICSSyncService()

server/reflector/settings.py

@@ -14,7 +14,9 @@ class Settings(BaseSettings):
     CORS_ALLOW_CREDENTIALS: bool = False
 
     # Database
-    DATABASE_URL: str = "sqlite:///./reflector.sqlite3"
+    DATABASE_URL: str = (
+        "postgresql+asyncpg://reflector:reflector@localhost:5432/reflector"
+    )
 
     # local data directory
     DATA_DIR: str = "./data"
@@ -37,6 +39,15 @@ class Settings(BaseSettings):
     TRANSCRIPT_STORAGE_AWS_ACCESS_KEY_ID: str | None = None
     TRANSCRIPT_STORAGE_AWS_SECRET_ACCESS_KEY: str | None = None
 
+    # Recording storage
+    RECORDING_STORAGE_BACKEND: str | None = None
+
+    # Recording storage configuration for AWS
+    RECORDING_STORAGE_AWS_BUCKET_NAME: str = "recording-bucket"
+    RECORDING_STORAGE_AWS_REGION: str = "us-east-1"
+    RECORDING_STORAGE_AWS_ACCESS_KEY_ID: str | None = None
+    RECORDING_STORAGE_AWS_SECRET_ACCESS_KEY: str | None = None
+
     # Translate into the target language
     TRANSLATION_BACKEND: str = "passthrough"
     TRANSLATE_URL: str | None = None
@@ -102,7 +113,6 @@ class Settings(BaseSettings):
     WHEREBY_API_URL: str = "https://api.whereby.dev/v1"
     WHEREBY_API_KEY: str | None = None
     WHEREBY_WEBHOOK_SECRET: str | None = None
-    AWS_WHEREBY_S3_BUCKET: str | None = None
     AWS_WHEREBY_ACCESS_KEY_ID: str | None = None
     AWS_WHEREBY_ACCESS_KEY_SECRET: str | None = None
     AWS_PROCESS_RECORDING_QUEUE_URL: str | None = None

server/reflector/storage/__init__.py

@@ -1,10 +1,17 @@
 from .base import Storage  # noqa
+from reflector.settings import settings
 
 
 def get_transcripts_storage() -> Storage:
-    from reflector.settings import settings
-
+    assert settings.TRANSCRIPT_STORAGE_BACKEND
     return Storage.get_instance(
         name=settings.TRANSCRIPT_STORAGE_BACKEND,
         settings_prefix="TRANSCRIPT_STORAGE_",
     )
+
+
+def get_recordings_storage() -> Storage:
+    return Storage.get_instance(
+        name=settings.RECORDING_STORAGE_BACKEND,
+        settings_prefix="RECORDING_STORAGE_",
+    )

server/reflector/tools/exportdanswer.py

@@ -9,8 +9,9 @@ async def export_db(filename: str) -> None:
     filename = pathlib.Path(filename).resolve()
     settings.DATABASE_URL = f"sqlite:///{filename}"
 
-    from reflector.db import database, transcripts
+    from reflector.db import get_database, transcripts
 
+    database = get_database()
     await database.connect()
     transcripts = await database.fetch_all(transcripts.select())
     await database.disconnect()

server/reflector/tools/exportdb.py

@@ -8,8 +8,9 @@ async def export_db(filename: str) -> None:
     filename = pathlib.Path(filename).resolve()
     settings.DATABASE_URL = f"sqlite:///{filename}"
 
-    from reflector.db import database, transcripts
+    from reflector.db import get_database, transcripts
 
+    database = get_database()
     await database.connect()
     transcripts = await database.fetch_all(transcripts.select())
     await database.disconnect()

server/reflector/tools/process_with_diarization.py

@@ -145,18 +145,17 @@ async def process_audio_file_with_diarization(
             logger.info(f"Starting diarization with {len(topics)} topics")
 
             try:
-                # Import diarization processor
                 from reflector.processors import AudioDiarizationAutoProcessor
 
-                # Create diarization processor
                 diarization_processor = AudioDiarizationAutoProcessor(
                     name=diarization_backend
                 )
-                diarization_processor.on(event_callback)
+
+                diarization_processor.set_pipeline(pipeline)
 
                 # For Modal backend, we need to upload the file to S3 first
                 if diarization_backend == "modal":
-                    from datetime import datetime
+                    from datetime import datetime, timezone
 
                     from reflector.storage import get_transcripts_storage
                     from reflector.utils.s3_temp_file import S3TemporaryFile
@@ -164,7 +163,7 @@ async def process_audio_file_with_diarization(
                     storage = get_transcripts_storage()
 
                     # Generate a unique filename in evaluation folder
-                    timestamp = datetime.utcnow().strftime("%Y%m%d_%H%M%S")
+                    timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
                     audio_filename = f"evaluation/diarization_temp/{timestamp}_{uuid.uuid4().hex}.wav"
 
                     # Use context manager for automatic cleanup

server/reflector/utils/webvtt.py

@@ -0,0 +1,63 @@
+"""WebVTT utilities for generating subtitle files from transcript data."""
+
+from typing import TYPE_CHECKING, Annotated
+
+import webvtt
+
+from reflector.processors.types import Seconds, Word, words_to_segments
+
+if TYPE_CHECKING:
+    from reflector.db.transcripts import TranscriptTopic
+
+VttTimestamp = Annotated[str, "vtt_timestamp"]
+WebVTTStr = Annotated[str, "webvtt_str"]
+
+
+def _seconds_to_timestamp(seconds: Seconds) -> VttTimestamp:
+    # lib doesn't do that
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    milliseconds = int((seconds % 1) * 1000)
+
+    return f"{hours:02d}:{minutes:02d}:{secs:02d}.{milliseconds:03d}"
+
+
+def words_to_webvtt(words: list[Word]) -> WebVTTStr:
+    """Convert words to WebVTT using existing segmentation logic."""
+    vtt = webvtt.WebVTT()
+    if not words:
+        return vtt.content
+
+    segments = words_to_segments(words)
+
+    for segment in segments:
+        text = segment.text.strip()
+        # lib doesn't do that
+        text = f"<v Speaker{segment.speaker}>{text}"
+
+        caption = webvtt.Caption(
+            start=_seconds_to_timestamp(segment.start),
+            end=_seconds_to_timestamp(segment.end),
+            text=text,
+        )
+        vtt.captions.append(caption)
+
+    return vtt.content
+
+
+def topics_to_webvtt(topics: list["TranscriptTopic"]) -> WebVTTStr:
+    if not topics:
+        return webvtt.WebVTT().content
+
+    all_words: list[Word] = []
+    for topic in topics:
+        all_words.extend(topic.words)
+
+    # assert it's in sequence
+    for i in range(len(all_words) - 1):
+        assert (
+            all_words[i].start <= all_words[i + 1].start
+        ), f"Words are not in sequence: {all_words[i].text} and {all_words[i + 1].text} are not consecutive: {all_words[i].start} > {all_words[i + 1].start}"
+
+    return words_to_webvtt(all_words)

server/reflector/views/_range_requests_response.py

@@ -44,8 +44,6 @@ def range_requests_response(
     """Returns StreamingResponse using Range Requests of a given file"""
 
     if not os.path.exists(file_path):
-        from fastapi import HTTPException
-
         raise HTTPException(status_code=404, detail="File not found")
 
     file_size = os.stat(file_path).st_size

server/reflector/views/meetings.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Annotated, Optional
 
 from fastapi import APIRouter, Depends, HTTPException, Request
@@ -35,7 +35,7 @@ async def meeting_audio_consent(
         meeting_id=meeting_id,
         user_id=user_id,
         consent_given=request.consent_given,
-        consent_timestamp=datetime.utcnow(),
+        consent_timestamp=datetime.now(timezone.utc),
     )
 
     updated_consent = await meeting_consent_controller.upsert(consent)

server/reflector/views/rooms.py

@@ -1,16 +1,16 @@
 import logging
 import sqlite3
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import Annotated, Literal, Optional
 
 import asyncpg.exceptions
 from fastapi import APIRouter, Depends, HTTPException
 from fastapi_pagination import Page
-from fastapi_pagination.ext.databases import paginate
+from fastapi_pagination.ext.databases import apaginate
 from pydantic import BaseModel
 
 import reflector.auth as auth
-from reflector.db import database
+from reflector.db import get_database
 from reflector.db.meetings import meetings_controller
 from reflector.db.rooms import rooms_controller
 from reflector.settings import settings
@@ -21,6 +21,14 @@ logger = logging.getLogger(__name__)
 router = APIRouter()
 
 
+def parse_datetime_with_timezone(iso_string: str) -> datetime:
+    """Parse ISO datetime string and ensure timezone awareness (defaults to UTC if naive)."""
+    dt = datetime.fromisoformat(iso_string)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
 class Room(BaseModel):
     id: str
     name: str
@@ -34,6 +42,11 @@ class Room(BaseModel):
     recording_type: str
     recording_trigger: str
     is_shared: bool
+    ics_url: Optional[str] = None
+    ics_fetch_interval: int = 300
+    ics_enabled: bool = False
+    ics_last_sync: Optional[datetime] = None
+    ics_last_etag: Optional[str] = None
 
 
 class Meeting(BaseModel):
@@ -56,18 +69,24 @@ class CreateRoom(BaseModel):
     recording_type: str
     recording_trigger: str
     is_shared: bool
+    ics_url: Optional[str] = None
+    ics_fetch_interval: int = 300
+    ics_enabled: bool = False
 
 
 class UpdateRoom(BaseModel):
-    name: str
-    zulip_auto_post: bool
-    zulip_stream: str
-    zulip_topic: str
-    is_locked: bool
-    room_mode: str
-    recording_type: str
-    recording_trigger: str
-    is_shared: bool
+    name: Optional[str] = None
+    zulip_auto_post: Optional[bool] = None
+    zulip_stream: Optional[str] = None
+    zulip_topic: Optional[str] = None
+    is_locked: Optional[bool] = None
+    room_mode: Optional[str] = None
+    recording_type: Optional[str] = None
+    recording_trigger: Optional[str] = None
+    is_shared: Optional[bool] = None
+    ics_url: Optional[str] = None
+    ics_fetch_interval: Optional[int] = None
+    ics_enabled: Optional[bool] = None
 
 
 class DeletionStatus(BaseModel):
@@ -83,8 +102,8 @@ async def rooms_list(
 
     user_id = user["sub"] if user else None
 
-    return await paginate(
-        database,
+    return await apaginate(
+        get_database(),
         await rooms_controller.get_all(
             user_id=user_id, order_by="-created_at", return_query=True
         ),
@@ -109,6 +128,9 @@ async def rooms_create(
         recording_type=room.recording_type,
         recording_trigger=room.recording_trigger,
         is_shared=room.is_shared,
+        ics_url=room.ics_url,
+        ics_fetch_interval=room.ics_fetch_interval,
+        ics_enabled=room.ics_enabled,
     )
 
 
@@ -150,7 +172,7 @@ async def rooms_create_meeting(
     if not room:
         raise HTTPException(status_code=404, detail="Room not found")
 
-    current_time = datetime.utcnow()
+    current_time = datetime.now(timezone.utc)
     meeting = await meetings_controller.get_active(room=room, current_time=current_time)
 
     if meeting is None:
@@ -166,8 +188,8 @@ async def rooms_create_meeting(
                 room_name=whereby_meeting["roomName"],
                 room_url=whereby_meeting["roomUrl"],
                 host_room_url=whereby_meeting["hostRoomUrl"],
-                start_date=datetime.fromisoformat(whereby_meeting["startDate"]),
-                end_date=datetime.fromisoformat(whereby_meeting["endDate"]),
+                start_date=parse_datetime_with_timezone(whereby_meeting["startDate"]),
+                end_date=parse_datetime_with_timezone(whereby_meeting["endDate"]),
                 user_id=user_id,
                 room=room,
             )
@@ -201,3 +223,217 @@ async def rooms_create_meeting(
         meeting.host_room_url = ""
 
     return meeting
+
+
+class ICSStatus(BaseModel):
+    status: str
+    last_sync: Optional[datetime] = None
+    next_sync: Optional[datetime] = None
+    last_etag: Optional[str] = None
+    events_count: int = 0
+
+
+class ICSSyncResult(BaseModel):
+    status: str
+    hash: Optional[str] = None
+    events_found: int = 0
+    events_created: int = 0
+    events_updated: int = 0
+    events_deleted: int = 0
+    error: Optional[str] = None
+
+
+@router.post("/rooms/{room_name}/ics/sync", response_model=ICSSyncResult)
+async def rooms_sync_ics(
+    room_name: str,
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
+):
+    user_id = user["sub"] if user else None
+    room = await rooms_controller.get_by_name(room_name)
+
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    if user_id != room.user_id:
+        raise HTTPException(
+            status_code=403, detail="Only room owner can trigger ICS sync"
+        )
+
+    if not room.ics_enabled or not room.ics_url:
+        raise HTTPException(status_code=400, detail="ICS not configured for this room")
+
+    from reflector.services.ics_sync import ics_sync_service
+
+    result = await ics_sync_service.sync_room_calendar(room)
+
+    if result["status"] == "error":
+        raise HTTPException(
+            status_code=500, detail=result.get("error", "Unknown error")
+        )
+
+    return ICSSyncResult(**result)
+
+
+@router.get("/rooms/{room_name}/ics/status", response_model=ICSStatus)
+async def rooms_ics_status(
+    room_name: str,
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
+):
+    user_id = user["sub"] if user else None
+    room = await rooms_controller.get_by_name(room_name)
+
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    if user_id != room.user_id:
+        raise HTTPException(
+            status_code=403, detail="Only room owner can view ICS status"
+        )
+
+    next_sync = None
+    if room.ics_enabled and room.ics_last_sync:
+        next_sync = room.ics_last_sync + timedelta(seconds=room.ics_fetch_interval)
+
+    from reflector.db.calendar_events import calendar_events_controller
+
+    events = await calendar_events_controller.get_by_room(
+        room.id, include_deleted=False
+    )
+
+    return ICSStatus(
+        status="enabled" if room.ics_enabled else "disabled",
+        last_sync=room.ics_last_sync,
+        next_sync=next_sync,
+        last_etag=room.ics_last_etag,
+        events_count=len(events),
+    )
+
+
+class CalendarEventResponse(BaseModel):
+    id: str
+    room_id: str
+    ics_uid: str
+    title: Optional[str] = None
+    description: Optional[str] = None
+    start_time: datetime
+    end_time: datetime
+    attendees: Optional[list[dict]] = None
+    location: Optional[str] = None
+    last_synced: datetime
+    created_at: datetime
+    updated_at: datetime
+
+
+@router.get("/rooms/{room_name}/meetings", response_model=list[CalendarEventResponse])
+async def rooms_list_meetings(
+    room_name: str,
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
+):
+    user_id = user["sub"] if user else None
+    room = await rooms_controller.get_by_name(room_name)
+
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    from reflector.db.calendar_events import calendar_events_controller
+
+    events = await calendar_events_controller.get_by_room(
+        room.id, include_deleted=False
+    )
+
+    if user_id != room.user_id:
+        for event in events:
+            event.description = None
+            event.attendees = None
+
+    return events
+
+
+@router.get(
+    "/rooms/{room_name}/meetings/upcoming", response_model=list[CalendarEventResponse]
+)
+async def rooms_list_upcoming_meetings(
+    room_name: str,
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
+    minutes_ahead: int = 30,
+):
+    user_id = user["sub"] if user else None
+    room = await rooms_controller.get_by_name(room_name)
+
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    from reflector.db.calendar_events import calendar_events_controller
+
+    events = await calendar_events_controller.get_upcoming(
+        room.id, minutes_ahead=minutes_ahead
+    )
+
+    if user_id != room.user_id:
+        for event in events:
+            event.description = None
+            event.attendees = None
+
+    return events
+
+
+@router.get("/rooms/{room_name}/meetings/active", response_model=list[Meeting])
+async def rooms_list_active_meetings(
+    room_name: str,
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
+):
+    """List all active meetings for a room (supports multiple active meetings)"""
+    user_id = user["sub"] if user else None
+    room = await rooms_controller.get_by_name(room_name)
+
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    current_time = datetime.now(timezone.utc)
+    meetings = await meetings_controller.get_all_active_for_room(
+        room=room, current_time=current_time
+    )
+
+    # Hide host URLs from non-owners
+    if user_id != room.user_id:
+        for meeting in meetings:
+            meeting.host_room_url = ""
+
+    return meetings
+
+
+@router.post("/rooms/{room_name}/meetings/{meeting_id}/join", response_model=Meeting)
+async def rooms_join_meeting(
+    room_name: str,
+    meeting_id: str,
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
+):
+    """Join a specific meeting by ID"""
+    user_id = user["sub"] if user else None
+    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)
+
+    if not meeting:
+        raise HTTPException(status_code=404, detail="Meeting not found")
+
+    if meeting.room_id != room.id:
+        raise HTTPException(
+            status_code=403, detail="Meeting does not belong to this room"
+        )
+
+    if not meeting.is_active:
+        raise HTTPException(status_code=400, detail="Meeting is not active")
+
+    current_time = datetime.now(timezone.utc)
+    if meeting.end_date <= current_time:
+        raise HTTPException(status_code=400, detail="Meeting has ended")
+
+    # Hide host URL from non-owners
+    if user_id != room.user_id:
+        meeting.host_room_url = ""
+
+    return meeting

server/reflector/views/transcripts.py

@@ -1,15 +1,29 @@
 from datetime import datetime, timedelta, timezone
 from typing import Annotated, Literal, Optional
 
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, Query
 from fastapi_pagination import Page
-from fastapi_pagination.ext.databases import paginate
+from fastapi_pagination.ext.databases import apaginate
 from jose import jwt
 from pydantic import BaseModel, Field, field_serializer
 
 import reflector.auth as auth
+from reflector.db import get_database
 from reflector.db.meetings import meetings_controller
 from reflector.db.rooms import rooms_controller
+from reflector.db.search import (
+    DEFAULT_SEARCH_LIMIT,
+    SearchLimit,
+    SearchLimitBase,
+    SearchOffset,
+    SearchOffsetBase,
+    SearchParameters,
+    SearchQuery,
+    SearchQueryBase,
+    SearchResult,
+    SearchTotal,
+    search_controller,
+)
 from reflector.db.transcripts import (
     SourceKind,
     TranscriptParticipant,
@@ -34,7 +48,7 @@ DOWNLOAD_EXPIRE_MINUTES = 60
 
 def create_access_token(data: dict, expires_delta: timedelta):
     to_encode = data.copy()
-    expire = datetime.utcnow() + expires_delta
+    expire = datetime.now(timezone.utc) + expires_delta
     to_encode.update({"exp": expire})
     encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=ALGORITHM)
     return encoded_jwt
@@ -100,6 +114,21 @@ class DeletionStatus(BaseModel):
     status: str
 
 
+SearchQueryParam = Annotated[SearchQueryBase, Query(description="Search query text")]
+SearchLimitParam = Annotated[SearchLimitBase, Query(description="Results per page")]
+SearchOffsetParam = Annotated[
+    SearchOffsetBase, Query(description="Number of results to skip")
+]
+
+
+class SearchResponse(BaseModel):
+    results: list[SearchResult]
+    total: SearchTotal
+    query: SearchQuery
+    limit: SearchLimit
+    offset: SearchOffset
+
+
 @router.get("/transcripts", response_model=Page[GetTranscriptMinimal])
 async def transcripts_list(
     user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
@@ -107,15 +136,13 @@ async def transcripts_list(
     room_id: str | None = None,
     search_term: str | None = None,
 ):
-    from reflector.db import database
-
     if not user and not settings.PUBLIC_MODE:
         raise HTTPException(status_code=401, detail="Not authenticated")
 
     user_id = user["sub"] if user else None
 
-    return await paginate(
-        database,
+    return await apaginate(
+        get_database(),
         await transcripts_controller.get_all(
             user_id=user_id,
             source_kind=SourceKind(source_kind) if source_kind else None,
@@ -127,6 +154,39 @@ async def transcripts_list(
     )
 
 
+@router.get("/transcripts/search", response_model=SearchResponse)
+async def transcripts_search(
+    q: SearchQueryParam,
+    limit: SearchLimitParam = DEFAULT_SEARCH_LIMIT,
+    offset: SearchOffsetParam = 0,
+    room_id: Optional[str] = None,
+    user: Annotated[
+        Optional[auth.UserInfo], Depends(auth.current_user_optional)
+    ] = None,
+):
+    """
+    Full-text search across transcript titles and content.
+    """
+    if not user and not settings.PUBLIC_MODE:
+        raise HTTPException(status_code=401, detail="Not authenticated")
+
+    user_id = user["sub"] if user else None
+
+    search_params = SearchParameters(
+        query_text=q, limit=limit, offset=offset, user_id=user_id, room_id=room_id
+    )
+
+    results, total = await search_controller.search_transcripts(search_params)
+
+    return SearchResponse(
+        results=results,
+        total=total,
+        query=search_params.query_text,
+        limit=search_params.limit,
+        offset=search_params.offset,
+    )
+
+
 @router.post("/transcripts", response_model=GetTranscript)
 async def transcripts_create(
     info: CreateTranscript,
@@ -273,8 +333,8 @@ async def transcript_update(
     if not transcript:
         raise HTTPException(status_code=404, detail="Transcript not found")
     values = info.dict(exclude_unset=True)
-    await transcripts_controller.update(transcript, values)
-    return transcript
+    updated_transcript = await transcripts_controller.update(transcript, values)
+    return updated_transcript
 
 
 @router.delete("/transcripts/{transcript_id}", response_model=DeletionStatus)

server/reflector/views/transcripts_audio.py

@@ -51,24 +51,6 @@ async def transcript_get_audio_mp3(
         transcript_id, user_id=user_id
     )
 
-    if transcript.audio_location == "storage":
-        # proxy S3 file, to prevent issue with CORS
-        url = await transcript.get_audio_url()
-        headers = {}
-
-        copy_headers = ["range", "accept-encoding"]
-        for header in copy_headers:
-            if header in request.headers:
-                headers[header] = request.headers[header]
-
-        async with httpx.AsyncClient() as client:
-            resp = await client.request(request.method, url, headers=headers)
-            return Response(
-                content=resp.content,
-                status_code=resp.status_code,
-                headers=resp.headers,
-            )
-
     if transcript.audio_location == "storage":
         # proxy S3 file, to prevent issue with CORS
         url = await transcript.get_audio_url()

server/reflector/views/transcripts_webrtc.py

@@ -26,7 +26,7 @@ async def transcript_record_webrtc(
         raise HTTPException(status_code=400, detail="Transcript is locked")
 
     # create a pipeline runner
-    from reflector.pipelines.main_live_pipeline import PipelineMainLive
+    from reflector.pipelines.main_live_pipeline import PipelineMainLive  # noqa: PLC0415
 
     pipeline_runner = PipelineMainLive(transcript_id=transcript_id)
 

server/reflector/views/whereby.py

@@ -68,8 +68,13 @@ async def whereby_webhook(event: WherebyWebhookEvent, request: Request):
         raise HTTPException(status_code=404, detail="Meeting not found")
 
     if event.type in ["room.client.joined", "room.client.left"]:
-        await meetings_controller.update_meeting(
-            meeting.id, num_clients=event.data["numClients"]
-        )
+        update_data = {"num_clients": event.data["numClients"]}
+
+        # Clear grace period if participant joined
+        if event.type == "room.client.joined" and event.data["numClients"] > 0:
+            if meeting.last_participant_left_at:
+                update_data["last_participant_left_at"] = None
+
+        await meetings_controller.update_meeting(meeting.id, **update_data)
 
     return {"status": "ok"}

server/reflector/whereby.py

@@ -23,7 +23,7 @@ async def create_meeting(room_name_prefix: str, end_date: datetime, room: Room):
             "type": room.recording_type,
             "destination": {
                 "provider": "s3",
-                "bucket": settings.AWS_WHEREBY_S3_BUCKET,
+                "bucket": settings.RECORDING_STORAGE_AWS_BUCKET_NAME,
                 "accessKeyId": settings.AWS_WHEREBY_ACCESS_KEY_ID,
                 "accessKeySecret": settings.AWS_WHEREBY_ACCESS_KEY_SECRET,
                 "fileFormat": "mp4",

server/reflector/worker/app.py

@@ -19,6 +19,7 @@ else:
             "reflector.pipelines.main_live_pipeline",
             "reflector.worker.healthcheck",
             "reflector.worker.process",
+            "reflector.worker.ics_sync",
         ]
     )
 
@@ -36,6 +37,14 @@ else:
             "task": "reflector.worker.process.reprocess_failed_recordings",
             "schedule": crontab(hour=5, minute=0),  # Midnight EST
         },
+        "sync_all_ics_calendars": {
+            "task": "reflector.worker.ics_sync.sync_all_ics_calendars",
+            "schedule": 60.0,  # Run every minute to check which rooms need sync
+        },
+        "pre_create_upcoming_meetings": {
+            "task": "reflector.worker.ics_sync.pre_create_upcoming_meetings",
+            "schedule": 30.0,  # Run every 30 seconds to pre-create meetings
+        },
     }
 
     if settings.HEALTHCHECK_URL:

server/reflector/worker/ics_sync.py

@@ -0,0 +1,209 @@
+from datetime import datetime, timedelta, timezone
+
+import structlog
+from celery import shared_task
+from celery.utils.log import get_task_logger
+
+from reflector.db import get_database
+from reflector.db.meetings import meetings_controller
+from reflector.db.rooms import rooms, rooms_controller
+from reflector.services.ics_sync import ics_sync_service
+from reflector.whereby import create_meeting, upload_logo
+
+logger = structlog.wrap_logger(get_task_logger(__name__))
+
+
+@shared_task
+def sync_room_ics(room_id: str):
+    asynctask(_sync_room_ics_async(room_id))
+
+
+async def _sync_room_ics_async(room_id: str):
+    try:
+        room = await rooms_controller.get_by_id(room_id)
+        if not room:
+            logger.warning("Room not found for ICS sync", room_id=room_id)
+            return
+
+        if not room.ics_enabled or not room.ics_url:
+            logger.debug("ICS not enabled for room", room_id=room_id)
+            return
+
+        logger.info("Starting ICS sync for room", room_id=room_id, room_name=room.name)
+        result = await ics_sync_service.sync_room_calendar(room)
+
+        if result["status"] == "success":
+            logger.info(
+                "ICS sync completed successfully",
+                room_id=room_id,
+                events_found=result.get("events_found", 0),
+                events_created=result.get("events_created", 0),
+                events_updated=result.get("events_updated", 0),
+                events_deleted=result.get("events_deleted", 0),
+            )
+        elif result["status"] == "unchanged":
+            logger.debug("ICS content unchanged", room_id=room_id)
+        elif result["status"] == "error":
+            logger.error("ICS sync failed", room_id=room_id, error=result.get("error"))
+        else:
+            logger.debug(
+                "ICS sync skipped", room_id=room_id, reason=result.get("reason")
+            )
+
+    except Exception as e:
+        logger.error("Unexpected error during ICS sync", room_id=room_id, error=str(e))
+
+
+@shared_task
+def sync_all_ics_calendars():
+    asynctask(_sync_all_ics_calendars_async())
+
+
+async def _sync_all_ics_calendars_async():
+    try:
+        logger.info("Starting sync for all ICS-enabled rooms")
+
+        # Get ALL rooms - not filtered by is_shared
+        query = rooms.select().where(
+            rooms.c.ics_enabled == True, rooms.c.ics_url != None
+        )
+        all_rooms = await get_database().fetch_all(query)
+        ics_enabled_rooms = list(all_rooms)
+
+        logger.info(f"Found {len(ics_enabled_rooms)} rooms with ICS enabled")
+
+        for room_data in ics_enabled_rooms:
+            room_id = room_data["id"]
+            room = await rooms_controller.get_by_id(room_id)
+
+            if not room:
+                continue
+
+            if not _should_sync(room):
+                logger.debug("Skipping room, not time to sync yet", room_id=room_id)
+                continue
+
+            sync_room_ics.delay(room_id)
+
+        logger.info("Queued sync tasks for all eligible rooms")
+
+    except Exception as e:
+        logger.error("Error in sync_all_ics_calendars", error=str(e))
+
+
+def _should_sync(room) -> bool:
+    if not room.ics_last_sync:
+        return True
+
+    time_since_sync = datetime.now(timezone.utc) - room.ics_last_sync
+    return time_since_sync.total_seconds() >= room.ics_fetch_interval
+
+
+@shared_task
+def pre_create_upcoming_meetings():
+    asynctask(_pre_create_upcoming_meetings_async())
+
+
+async def _pre_create_upcoming_meetings_async():
+    try:
+        logger.info("Starting pre-creation of upcoming meetings")
+
+        from reflector.db.calendar_events import calendar_events_controller
+
+        # Get ALL rooms with ICS enabled
+        query = rooms.select().where(
+            rooms.c.ics_enabled == True, rooms.c.ics_url != None
+        )
+        all_rooms = await get_database().fetch_all(query)
+        now = datetime.now(timezone.utc)
+        pre_create_window = now + timedelta(minutes=1)
+
+        for room_data in all_rooms:
+            room_id = room_data["id"]
+            room = await rooms_controller.get_by_id(room_id)
+
+            if not room:
+                continue
+
+            events = await calendar_events_controller.get_upcoming(
+                room_id, minutes_ahead=2
+            )
+
+            for event in events:
+                if event.start_time <= pre_create_window:
+                    existing_meeting = await meetings_controller.get_by_calendar_event(
+                        event.id
+                    )
+
+                    if not existing_meeting:
+                        logger.info(
+                            "Pre-creating meeting for calendar event",
+                            room_id=room_id,
+                            event_id=event.id,
+                            event_title=event.title,
+                        )
+
+                        try:
+                            end_date = event.end_time or (
+                                event.start_time + timedelta(hours=1)
+                            )
+
+                            whereby_meeting = await create_meeting(
+                                event.title or "Scheduled Meeting",
+                                end_date=end_date,
+                                room=room,
+                            )
+                            await upload_logo(
+                                whereby_meeting["roomName"], "./images/logo.png"
+                            )
+
+                            meeting = await meetings_controller.create(
+                                id=whereby_meeting["meetingId"],
+                                room_name=whereby_meeting["roomName"],
+                                room_url=whereby_meeting["roomUrl"],
+                                host_room_url=whereby_meeting["hostRoomUrl"],
+                                start_date=datetime.fromisoformat(
+                                    whereby_meeting["startDate"]
+                                ),
+                                end_date=datetime.fromisoformat(
+                                    whereby_meeting["endDate"]
+                                ),
+                                user_id=room.user_id,
+                                room=room,
+                                calendar_event_id=event.id,
+                                calendar_metadata={
+                                    "title": event.title,
+                                    "description": event.description,
+                                    "attendees": event.attendees,
+                                },
+                            )
+
+                            logger.info(
+                                "Meeting pre-created successfully",
+                                meeting_id=meeting.id,
+                                event_id=event.id,
+                            )
+
+                        except Exception as e:
+                            logger.error(
+                                "Failed to pre-create meeting",
+                                room_id=room_id,
+                                event_id=event.id,
+                                error=str(e),
+                            )
+
+        logger.info("Completed pre-creation check for upcoming meetings")
+
+    except Exception as e:
+        logger.error("Error in pre_create_upcoming_meetings", error=str(e))
+
+
+def asynctask(coro):
+    import asyncio
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        return loop.run_until_complete(coro)
+    finally:
+        loop.close()

server/reflector/worker/process.py

@@ -1,6 +1,6 @@
 import json
 import os
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from urllib.parse import unquote
 
 import av
@@ -21,6 +21,14 @@ from reflector.whereby import get_room_sessions
 logger = structlog.wrap_logger(get_task_logger(__name__))
 
 
+def parse_datetime_with_timezone(iso_string: str) -> datetime:
+    """Parse ISO datetime string and ensure timezone awareness (defaults to UTC if naive)."""
+    dt = datetime.fromisoformat(iso_string)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
 @shared_task
 def process_messages():
     queue_url = settings.AWS_PROCESS_RECORDING_QUEUE_URL
@@ -69,7 +77,7 @@ async def process_recording(bucket_name: str, object_key: str):
 
     # extract a guid and a datetime from the object key
     room_name = f"/{object_key[:36]}"
-    recorded_at = datetime.fromisoformat(object_key[37:57])
+    recorded_at = parse_datetime_with_timezone(object_key[37:57])
 
     meeting = await meetings_controller.get_by_room_name(room_name)
     room = await rooms_controller.get_by_id(meeting.room_id)
@@ -138,24 +146,76 @@ async def process_recording(bucket_name: str, object_key: str):
 @shared_task
 @asynctask
 async def process_meetings():
+    """
+    Checks which meetings are still active and deactivates those that have ended.
+    Supports multiple active meetings per room and grace period logic.
+    """
     logger.info("Processing meetings")
     meetings = await meetings_controller.get_all_active()
+    current_time = datetime.now(timezone.utc)
+
     for meeting in meetings:
-        is_active = False
+        should_deactivate = False
         end_date = meeting.end_date
         if end_date.tzinfo is None:
             end_date = end_date.replace(tzinfo=timezone.utc)
-        if end_date > datetime.now(timezone.utc):
+
+        # Check if meeting has passed its scheduled end time
+        if end_date <= current_time:
+            # For calendar meetings, force close 30 minutes after scheduled end
+            if meeting.calendar_event_id:
+                if current_time > end_date + timedelta(minutes=30):
+                    should_deactivate = True
+                    logger.info(
+                        "Meeting %s forced closed 30 min after calendar end", meeting.id
+                    )
+            else:
+                # Unscheduled meetings follow normal closure rules
+                should_deactivate = True
+
+        # Check Whereby room sessions only if not already deactivating
+        if not should_deactivate and end_date > current_time:
             response = await get_room_sessions(meeting.room_name)
             room_sessions = response.get("results", [])
-            is_active = not room_sessions or any(
+            has_active_sessions = room_sessions and any(
                 rs["endedAt"] is None for rs in room_sessions
             )
-        if not is_active:
+
+            if not has_active_sessions:
+                # No active sessions - check grace period
+                if meeting.num_clients == 0:
+                    if meeting.last_participant_left_at:
+                        # Check if grace period has expired
+                        grace_period = timedelta(minutes=meeting.grace_period_minutes)
+                        if (
+                            current_time
+                            > meeting.last_participant_left_at + grace_period
+                        ):
+                            should_deactivate = True
+                            logger.info("Meeting %s grace period expired", meeting.id)
+                    else:
+                        # First time all participants left, record the time
+                        await meetings_controller.update_meeting(
+                            meeting.id, last_participant_left_at=current_time
+                        )
+                        logger.info(
+                            "Meeting %s marked empty at %s", meeting.id, current_time
+                        )
+            else:
+                # Has active sessions - clear grace period if set
+                if meeting.last_participant_left_at:
+                    await meetings_controller.update_meeting(
+                        meeting.id, last_participant_left_at=None
+                    )
+                    logger.info(
+                        "Meeting %s reactivated - participant rejoined", meeting.id
+                    )
+
+        if should_deactivate:
             await meetings_controller.update_meeting(meeting.id, is_active=False)
             logger.info("Meeting %s is deactivated", meeting.id)
 
-    logger.info("Processed meetings")
+    logger.info("Processed %d meetings", len(meetings))
 
 
 @shared_task
@@ -177,7 +237,7 @@ async def reprocess_failed_recordings():
     reprocessed_count = 0
     try:
         paginator = s3.get_paginator("list_objects_v2")
-        bucket_name = settings.AWS_WHEREBY_S3_BUCKET
+        bucket_name = settings.RECORDING_STORAGE_AWS_BUCKET_NAME
         pages = paginator.paginate(Bucket=bucket_name)
 
         for page in pages:

server/reflector/ws_manager.py

@@ -62,6 +62,7 @@ class RedisPubSubManager:
 class WebsocketManager:
     def __init__(self, pubsub_client: RedisPubSubManager = None):
         self.rooms: dict = {}
+        self.tasks: dict = {}
         self.pubsub_client = pubsub_client
 
     async def add_user_to_room(self, room_id: str, websocket: WebSocket) -> None:
@@ -74,13 +75,17 @@ class WebsocketManager:
 
             await self.pubsub_client.connect()
             pubsub_subscriber = await self.pubsub_client.subscribe(room_id)
-            asyncio.create_task(self._pubsub_data_reader(pubsub_subscriber))
+            task = asyncio.create_task(self._pubsub_data_reader(pubsub_subscriber))
+            self.tasks[id(websocket)] = task
 
     async def send_json(self, room_id: str, message: dict) -> None:
         await self.pubsub_client.send_json(room_id, message)
 
     async def remove_user_from_room(self, room_id: str, websocket: WebSocket) -> None:
         self.rooms[room_id].remove(websocket)
+        task = self.tasks.pop(id(websocket), None)
+        if task:
+            task.cancel()
 
         if len(self.rooms[room_id]) == 0:
             del self.rooms[room_id]

server/tests/conftest.py

@@ -1,17 +1,63 @@
+import os
 from tempfile import NamedTemporaryFile
 from unittest.mock import patch
 
 import pytest
 
 
+# Pytest-docker configuration
+@pytest.fixture(scope="session")
+def docker_compose_file(pytestconfig):
+    return os.path.join(str(pytestconfig.rootdir), "tests", "docker-compose.test.yml")
+
+
+@pytest.fixture(scope="session")
+def postgres_service(docker_ip, docker_services):
+    """Ensure that PostgreSQL service is up and responsive."""
+    port = docker_services.port_for("postgres_test", 5432)
+
+    def is_responsive():
+        try:
+            import psycopg2
+
+            conn = psycopg2.connect(
+                host=docker_ip,
+                port=port,
+                dbname="reflector_test",
+                user="test_user",
+                password="test_password",
+            )
+            conn.close()
+            return True
+        except Exception:
+            return False
+
+    docker_services.wait_until_responsive(timeout=30.0, pause=0.1, check=is_responsive)
+
+    # Return connection parameters
+    return {
+        "host": docker_ip,
+        "port": port,
+        "dbname": "reflector_test",
+        "user": "test_user",
+        "password": "test_password",
+    }
+
+
 @pytest.fixture(scope="function", autouse=True)
 @pytest.mark.asyncio
-async def setup_database():
-    from reflector.db import engine, metadata  # noqa
+async def setup_database(postgres_service):
+    from reflector.db import engine, metadata, get_database  # noqa
 
     metadata.drop_all(bind=engine)
     metadata.create_all(bind=engine)
-    yield
+    database = get_database()
+
+    try:
+        await database.connect()
+        yield
+    finally:
+        await database.disconnect()
 
 
 @pytest.fixture
@@ -46,6 +92,20 @@ def dummy_processors():
         )  # noqa
 
 
+@pytest.fixture
+async def whisper_transcript():
+    from reflector.processors.audio_transcript_whisper import (
+        AudioTranscriptWhisperProcessor,
+    )
+
+    with patch(
+        "reflector.processors.audio_transcript_auto"
+        ".AudioTranscriptAutoProcessor.__new__"
+    ) as mock_audio:
+        mock_audio.return_value = AudioTranscriptWhisperProcessor()
+        yield
+
+
 @pytest.fixture
 async def dummy_transcript():
     from reflector.processors.audio_transcript import AudioTranscriptProcessor
@@ -181,6 +241,16 @@ def celery_includes():
     return ["reflector.pipelines.main_live_pipeline"]
 
 
+@pytest.fixture
+async def client():
+    from httpx import AsyncClient
+
+    from reflector.app import app
+
+    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
+        yield ac
+
+
 @pytest.fixture(scope="session")
 def fake_mp3_upload():
     with patch(
@@ -191,13 +261,10 @@ def fake_mp3_upload():
 
 
 @pytest.fixture
-async def fake_transcript_with_topics(tmpdir):
+async def fake_transcript_with_topics(tmpdir, client):
     import shutil
     from pathlib import Path
 
-    from httpx import AsyncClient
-
-    from reflector.app import app
     from reflector.db.transcripts import TranscriptTopic
     from reflector.processors.types import Word
     from reflector.settings import settings
@@ -206,8 +273,7 @@ async def fake_transcript_with_topics(tmpdir):
     settings.DATA_DIR = Path(tmpdir)
 
     # create a transcript
-    ac = AsyncClient(app=app, base_url="http://test/v1")
-    response = await ac.post("/transcripts", json={"name": "Test audio download"})
+    response = await client.post("/transcripts", json={"name": "Test audio download"})
     assert response.status_code == 200
     tid = response.json()["id"]
 

server/tests/docker-compose.test.yml

@@ -0,0 +1,13 @@
+version: '3.8'
+services:
+  postgres_test:
+    image: postgres:15
+    environment:
+      POSTGRES_DB: reflector_test
+      POSTGRES_USER: test_user
+      POSTGRES_PASSWORD: test_password
+    ports:
+      - "15432:5432"
+    command: postgres -c fsync=off -c synchronous_commit=off -c full_page_writes=off
+    tmpfs:
+      - /var/lib/postgresql/data:rw,noexec,nosuid,size=1g

server/tests/test_calendar_event.py

@@ -0,0 +1,351 @@
+"""
+Tests for CalendarEvent model.
+"""
+
+from datetime import datetime, timedelta, timezone
+
+import pytest
+
+from reflector.db.calendar_events import CalendarEvent, calendar_events_controller
+from reflector.db.rooms import rooms_controller
+
+
+@pytest.mark.asyncio
+async def test_calendar_event_create():
+    """Test creating a calendar event."""
+    # Create a room first
+    room = await rooms_controller.add(
+        name="test-room",
+        user_id="test-user",
+        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,
+    )
+
+    # Create calendar event
+    now = datetime.now(timezone.utc)
+    event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="test-event-123",
+        title="Team Meeting",
+        description="Weekly team sync",
+        start_time=now + timedelta(hours=1),
+        end_time=now + timedelta(hours=2),
+        location=f"https://example.com/room/{room.name}",
+        attendees=[
+            {"email": "alice@example.com", "name": "Alice", "status": "ACCEPTED"},
+            {"email": "bob@example.com", "name": "Bob", "status": "TENTATIVE"},
+        ],
+    )
+
+    # Save event
+    saved_event = await calendar_events_controller.upsert(event)
+
+    assert saved_event.ics_uid == "test-event-123"
+    assert saved_event.title == "Team Meeting"
+    assert saved_event.room_id == room.id
+    assert len(saved_event.attendees) == 2
+
+
+@pytest.mark.asyncio
+async def test_calendar_event_get_by_room():
+    """Test getting calendar events for a room."""
+    # Create room
+    room = await rooms_controller.add(
+        name="events-room",
+        user_id="test-user",
+        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,
+    )
+
+    now = datetime.now(timezone.utc)
+
+    # Create multiple events
+    for i in range(3):
+        event = CalendarEvent(
+            room_id=room.id,
+            ics_uid=f"event-{i}",
+            title=f"Meeting {i}",
+            start_time=now + timedelta(hours=i),
+            end_time=now + timedelta(hours=i + 1),
+        )
+        await calendar_events_controller.upsert(event)
+
+    # Get events for room
+    events = await calendar_events_controller.get_by_room(room.id)
+
+    assert len(events) == 3
+    assert all(e.room_id == room.id for e in events)
+    assert events[0].title == "Meeting 0"
+    assert events[1].title == "Meeting 1"
+    assert events[2].title == "Meeting 2"
+
+
+@pytest.mark.asyncio
+async def test_calendar_event_get_upcoming():
+    """Test getting upcoming events within time window."""
+    # Create room
+    room = await rooms_controller.add(
+        name="upcoming-room",
+        user_id="test-user",
+        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,
+    )
+
+    now = datetime.now(timezone.utc)
+
+    # Create events at different times
+    # Past event (should not be included)
+    past_event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="past-event",
+        title="Past Meeting",
+        start_time=now - timedelta(hours=2),
+        end_time=now - timedelta(hours=1),
+    )
+    await calendar_events_controller.upsert(past_event)
+
+    # Upcoming event within 30 minutes
+    upcoming_event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="upcoming-event",
+        title="Upcoming Meeting",
+        start_time=now + timedelta(minutes=15),
+        end_time=now + timedelta(minutes=45),
+    )
+    await calendar_events_controller.upsert(upcoming_event)
+
+    # Future event beyond 30 minutes
+    future_event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="future-event",
+        title="Future Meeting",
+        start_time=now + timedelta(hours=2),
+        end_time=now + timedelta(hours=3),
+    )
+    await calendar_events_controller.upsert(future_event)
+
+    # Get upcoming events (default 30 minutes)
+    upcoming = await calendar_events_controller.get_upcoming(room.id)
+
+    assert len(upcoming) == 1
+    assert upcoming[0].ics_uid == "upcoming-event"
+
+    # Get upcoming with custom window
+    upcoming_extended = await calendar_events_controller.get_upcoming(
+        room.id, minutes_ahead=180
+    )
+
+    assert len(upcoming_extended) == 2
+    assert upcoming_extended[0].ics_uid == "upcoming-event"
+    assert upcoming_extended[1].ics_uid == "future-event"
+
+
+@pytest.mark.asyncio
+async def test_calendar_event_upsert():
+    """Test upserting (create/update) calendar events."""
+    # Create room
+    room = await rooms_controller.add(
+        name="upsert-room",
+        user_id="test-user",
+        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,
+    )
+
+    now = datetime.now(timezone.utc)
+
+    # Create new event
+    event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="upsert-test",
+        title="Original Title",
+        start_time=now,
+        end_time=now + timedelta(hours=1),
+    )
+
+    created = await calendar_events_controller.upsert(event)
+    assert created.title == "Original Title"
+
+    # Update existing event
+    event.title = "Updated Title"
+    event.description = "Added description"
+
+    updated = await calendar_events_controller.upsert(event)
+    assert updated.title == "Updated Title"
+    assert updated.description == "Added description"
+    assert updated.ics_uid == "upsert-test"
+
+    # Verify only one event exists
+    events = await calendar_events_controller.get_by_room(room.id)
+    assert len(events) == 1
+    assert events[0].title == "Updated Title"
+
+
+@pytest.mark.asyncio
+async def test_calendar_event_soft_delete():
+    """Test soft deleting events no longer in calendar."""
+    # Create room
+    room = await rooms_controller.add(
+        name="delete-room",
+        user_id="test-user",
+        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,
+    )
+
+    now = datetime.now(timezone.utc)
+
+    # Create multiple events
+    for i in range(4):
+        event = CalendarEvent(
+            room_id=room.id,
+            ics_uid=f"event-{i}",
+            title=f"Meeting {i}",
+            start_time=now + timedelta(hours=i),
+            end_time=now + timedelta(hours=i + 1),
+        )
+        await calendar_events_controller.upsert(event)
+
+    # Soft delete events not in current list
+    current_ids = ["event-0", "event-2"]  # Keep events 0 and 2
+    deleted_count = await calendar_events_controller.soft_delete_missing(
+        room.id, current_ids
+    )
+
+    assert deleted_count == 2  # Should delete events 1 and 3
+
+    # Get non-deleted events
+    events = await calendar_events_controller.get_by_room(
+        room.id, include_deleted=False
+    )
+    assert len(events) == 2
+    assert {e.ics_uid for e in events} == {"event-0", "event-2"}
+
+    # Get all events including deleted
+    all_events = await calendar_events_controller.get_by_room(
+        room.id, include_deleted=True
+    )
+    assert len(all_events) == 4
+
+
+@pytest.mark.asyncio
+async def test_calendar_event_past_events_not_deleted():
+    """Test that past events are not soft deleted."""
+    # Create room
+    room = await rooms_controller.add(
+        name="past-events-room",
+        user_id="test-user",
+        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,
+    )
+
+    now = datetime.now(timezone.utc)
+
+    # Create past event
+    past_event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="past-event",
+        title="Past Meeting",
+        start_time=now - timedelta(hours=2),
+        end_time=now - timedelta(hours=1),
+    )
+    await calendar_events_controller.upsert(past_event)
+
+    # Create future event
+    future_event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="future-event",
+        title="Future Meeting",
+        start_time=now + timedelta(hours=1),
+        end_time=now + timedelta(hours=2),
+    )
+    await calendar_events_controller.upsert(future_event)
+
+    # Try to soft delete all events (only future should be deleted)
+    deleted_count = await calendar_events_controller.soft_delete_missing(room.id, [])
+
+    assert deleted_count == 1  # Only future event deleted
+
+    # Verify past event still exists
+    events = await calendar_events_controller.get_by_room(
+        room.id, include_deleted=False
+    )
+    assert len(events) == 1
+    assert events[0].ics_uid == "past-event"
+
+
+@pytest.mark.asyncio
+async def test_calendar_event_with_raw_ics_data():
+    """Test storing raw ICS data with calendar event."""
+    # Create room
+    room = await rooms_controller.add(
+        name="raw-ics-room",
+        user_id="test-user",
+        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,
+    )
+
+    raw_ics = """BEGIN:VEVENT
+UID:test-raw-123
+SUMMARY:Test Event
+DTSTART:20240101T100000Z
+DTEND:20240101T110000Z
+END:VEVENT"""
+
+    event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="test-raw-123",
+        title="Test Event",
+        start_time=datetime.now(timezone.utc),
+        end_time=datetime.now(timezone.utc) + timedelta(hours=1),
+        ics_raw_data=raw_ics,
+    )
+
+    saved = await calendar_events_controller.upsert(event)
+
+    assert saved.ics_raw_data == raw_ics
+
+    # Retrieve and verify
+    retrieved = await calendar_events_controller.get_by_ics_uid(room.id, "test-raw-123")
+    assert retrieved is not None
+    assert retrieved.ics_raw_data == raw_ics

server/tests/test_ics_background_tasks.py

@@ -0,0 +1,230 @@
+from datetime import datetime, timedelta, timezone
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from icalendar import Calendar, Event
+
+from reflector.db.calendar_events import calendar_events_controller
+from reflector.db.rooms import rooms_controller
+from reflector.worker.ics_sync import (
+    _should_sync,
+    _sync_all_ics_calendars_async,
+    _sync_room_ics_async,
+)
+
+
+@pytest.mark.asyncio
+async def test_sync_room_ics_task():
+    room = await rooms_controller.add(
+        name="task-test-room",
+        user_id="test-user",
+        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,
+        ics_url="https://calendar.example.com/task.ics",
+        ics_enabled=True,
+    )
+
+    cal = Calendar()
+    event = Event()
+    event.add("uid", "task-event-1")
+    event.add("summary", "Task Test Meeting")
+    from reflector.settings import settings
+
+    event.add("location", f"{settings.BASE_URL}/room/{room.name}")
+    now = datetime.now(timezone.utc)
+    event.add("dtstart", now + timedelta(hours=1))
+    event.add("dtend", now + timedelta(hours=2))
+    cal.add_component(event)
+    ics_content = cal.to_ical().decode("utf-8")
+
+    with patch(
+        "reflector.services.ics_sync.ICSFetchService.fetch_ics", new_callable=AsyncMock
+    ) as mock_fetch:
+        mock_fetch.return_value = ics_content
+
+        await _sync_room_ics_async(room.id)
+
+        events = await calendar_events_controller.get_by_room(room.id)
+        assert len(events) == 1
+        assert events[0].ics_uid == "task-event-1"
+
+
+@pytest.mark.asyncio
+async def test_sync_room_ics_disabled():
+    room = await rooms_controller.add(
+        name="disabled-room",
+        user_id="test-user",
+        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,
+        ics_enabled=False,
+    )
+
+    await _sync_room_ics_async(room.id)
+
+    events = await calendar_events_controller.get_by_room(room.id)
+    assert len(events) == 0
+
+
+@pytest.mark.asyncio
+async def test_sync_all_ics_calendars():
+    room1 = await rooms_controller.add(
+        name="sync-all-1",
+        user_id="test-user",
+        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,
+        ics_url="https://calendar.example.com/1.ics",
+        ics_enabled=True,
+    )
+
+    room2 = await rooms_controller.add(
+        name="sync-all-2",
+        user_id="test-user",
+        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,
+        ics_url="https://calendar.example.com/2.ics",
+        ics_enabled=True,
+    )
+
+    room3 = await rooms_controller.add(
+        name="sync-all-3",
+        user_id="test-user",
+        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,
+        ics_enabled=False,
+    )
+
+    with patch("reflector.worker.ics_sync.sync_room_ics.delay") as mock_delay:
+        await _sync_all_ics_calendars_async()
+
+        assert mock_delay.call_count == 2
+        called_room_ids = [call.args[0] for call in mock_delay.call_args_list]
+        assert room1.id in called_room_ids
+        assert room2.id in called_room_ids
+        assert room3.id not in called_room_ids
+
+
+@pytest.mark.asyncio
+async def test_should_sync_logic():
+    room = MagicMock()
+
+    room.ics_last_sync = None
+    assert _should_sync(room) is True
+
+    room.ics_last_sync = datetime.now(timezone.utc) - timedelta(seconds=100)
+    room.ics_fetch_interval = 300
+    assert _should_sync(room) is False
+
+    room.ics_last_sync = datetime.now(timezone.utc) - timedelta(seconds=400)
+    room.ics_fetch_interval = 300
+    assert _should_sync(room) is True
+
+
+@pytest.mark.asyncio
+async def test_sync_respects_fetch_interval():
+    now = datetime.now(timezone.utc)
+
+    room1 = await rooms_controller.add(
+        name="interval-test-1",
+        user_id="test-user",
+        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,
+        ics_url="https://calendar.example.com/interval.ics",
+        ics_enabled=True,
+        ics_fetch_interval=300,
+    )
+
+    await rooms_controller.update(
+        room1,
+        {"ics_last_sync": now - timedelta(seconds=100)},
+    )
+
+    room2 = await rooms_controller.add(
+        name="interval-test-2",
+        user_id="test-user",
+        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,
+        ics_url="https://calendar.example.com/interval2.ics",
+        ics_enabled=True,
+        ics_fetch_interval=60,
+    )
+
+    await rooms_controller.update(
+        room2,
+        {"ics_last_sync": now - timedelta(seconds=100)},
+    )
+
+    with patch("reflector.worker.ics_sync.sync_room_ics.delay") as mock_delay:
+        await _sync_all_ics_calendars_async()
+
+        assert mock_delay.call_count == 1
+        assert mock_delay.call_args[0][0] == room2.id
+
+
+@pytest.mark.asyncio
+async def test_sync_handles_errors_gracefully():
+    room = await rooms_controller.add(
+        name="error-task-room",
+        user_id="test-user",
+        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,
+        ics_url="https://calendar.example.com/error.ics",
+        ics_enabled=True,
+    )
+
+    with patch(
+        "reflector.services.ics_sync.ICSFetchService.fetch_ics", new_callable=AsyncMock
+    ) as mock_fetch:
+        mock_fetch.side_effect = Exception("Network error")
+
+        await _sync_room_ics_async(room.id)
+
+        events = await calendar_events_controller.get_by_room(room.id)
+        assert len(events) == 0

server/tests/test_ics_sync.py

@@ -0,0 +1,289 @@
+from datetime import datetime, timedelta, timezone
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from icalendar import Calendar, Event
+
+from reflector.db.calendar_events import calendar_events_controller
+from reflector.db.rooms import rooms_controller
+from reflector.services.ics_sync import ICSFetchService, ICSSyncService
+
+
+@pytest.mark.asyncio
+async def test_ics_fetch_service_event_matching():
+    service = ICSFetchService()
+    room_name = "test-room"
+    room_url = "https://example.com/room/test-room"
+
+    # Create test event
+    event = Event()
+    event.add("uid", "test-123")
+    event.add("summary", "Test Meeting")
+
+    # Test matching with full URL in location
+    event.add("location", "https://example.com/room/test-room")
+    assert service._event_matches_room(event, room_name, room_url) is True
+
+    # Test matching with URL without protocol
+    event["location"] = "example.com/room/test-room"
+    assert service._event_matches_room(event, room_name, room_url) is True
+
+    # Test matching in description
+    event["location"] = "Conference Room A"
+    event.add("description", f"Join at {room_url}")
+    assert service._event_matches_room(event, room_name, room_url) is True
+
+    # Test non-matching
+    event["location"] = "Different Room"
+    event["description"] = "No room URL here"
+    assert service._event_matches_room(event, room_name, room_url) is False
+
+    # Test partial paths should NOT match anymore
+    event["location"] = "/room/test-room"
+    assert service._event_matches_room(event, room_name, room_url) is False
+
+    event["location"] = f"Room: {room_name}"
+    assert service._event_matches_room(event, room_name, room_url) is False
+
+
+@pytest.mark.asyncio
+async def test_ics_fetch_service_parse_event():
+    service = ICSFetchService()
+
+    # Create test event
+    event = Event()
+    event.add("uid", "test-456")
+    event.add("summary", "Team Standup")
+    event.add("description", "Daily team sync")
+    event.add("location", "https://example.com/room/standup")
+
+    now = datetime.now(timezone.utc)
+    event.add("dtstart", now)
+    event.add("dtend", now + timedelta(hours=1))
+
+    # Add attendees
+    event.add("attendee", "mailto:alice@example.com", parameters={"CN": "Alice"})
+    event.add("attendee", "mailto:bob@example.com", parameters={"CN": "Bob"})
+    event.add("organizer", "mailto:carol@example.com", parameters={"CN": "Carol"})
+
+    # Parse event
+    result = service._parse_event(event)
+
+    assert result is not None
+    assert result["ics_uid"] == "test-456"
+    assert result["title"] == "Team Standup"
+    assert result["description"] == "Daily team sync"
+    assert result["location"] == "https://example.com/room/standup"
+    assert len(result["attendees"]) == 3  # 2 attendees + 1 organizer
+
+
+@pytest.mark.asyncio
+async def test_ics_fetch_service_extract_room_events():
+    service = ICSFetchService()
+    room_name = "meeting"
+    room_url = "https://example.com/room/meeting"
+
+    # Create calendar with multiple events
+    cal = Calendar()
+
+    # Event 1: Matches room
+    event1 = Event()
+    event1.add("uid", "match-1")
+    event1.add("summary", "Planning Meeting")
+    event1.add("location", room_url)
+    now = datetime.now(timezone.utc)
+    event1.add("dtstart", now + timedelta(hours=2))
+    event1.add("dtend", now + timedelta(hours=3))
+    cal.add_component(event1)
+
+    # Event 2: Doesn't match room
+    event2 = Event()
+    event2.add("uid", "no-match")
+    event2.add("summary", "Other Meeting")
+    event2.add("location", "https://example.com/room/other")
+    event2.add("dtstart", now + timedelta(hours=4))
+    event2.add("dtend", now + timedelta(hours=5))
+    cal.add_component(event2)
+
+    # Event 3: Matches room in description
+    event3 = Event()
+    event3.add("uid", "match-2")
+    event3.add("summary", "Review Session")
+    event3.add("description", f"Meeting link: {room_url}")
+    event3.add("dtstart", now + timedelta(hours=6))
+    event3.add("dtend", now + timedelta(hours=7))
+    cal.add_component(event3)
+
+    # Event 4: Cancelled event (should be skipped)
+    event4 = Event()
+    event4.add("uid", "cancelled")
+    event4.add("summary", "Cancelled Meeting")
+    event4.add("location", room_url)
+    event4.add("status", "CANCELLED")
+    event4.add("dtstart", now + timedelta(hours=8))
+    event4.add("dtend", now + timedelta(hours=9))
+    cal.add_component(event4)
+
+    # Extract events
+    events = service.extract_room_events(cal, room_name, room_url)
+
+    assert len(events) == 2
+    assert events[0]["ics_uid"] == "match-1"
+    assert events[1]["ics_uid"] == "match-2"
+
+
+@pytest.mark.asyncio
+async def test_ics_sync_service_sync_room_calendar():
+    # Create room
+    room = await rooms_controller.add(
+        name="sync-test",
+        user_id="test-user",
+        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,
+        ics_url="https://calendar.example.com/test.ics",
+        ics_enabled=True,
+    )
+
+    # Mock ICS content
+    cal = Calendar()
+    event = Event()
+    event.add("uid", "sync-event-1")
+    event.add("summary", "Sync Test Meeting")
+    # Use the actual BASE_URL from settings
+    from reflector.settings import settings
+
+    event.add("location", f"{settings.BASE_URL}/room/{room.name}")
+    now = datetime.now(timezone.utc)
+    event.add("dtstart", now + timedelta(hours=1))
+    event.add("dtend", now + timedelta(hours=2))
+    cal.add_component(event)
+    ics_content = cal.to_ical().decode("utf-8")
+
+    # Create sync service and mock fetch
+    sync_service = ICSSyncService()
+
+    with patch.object(
+        sync_service.fetch_service, "fetch_ics", new_callable=AsyncMock
+    ) as mock_fetch:
+        mock_fetch.return_value = ics_content
+
+        # First sync
+        result = await sync_service.sync_room_calendar(room)
+
+        assert result["status"] == "success"
+        assert result["events_found"] == 1
+        assert result["events_created"] == 1
+        assert result["events_updated"] == 0
+        assert result["events_deleted"] == 0
+
+        # Verify event was created
+        events = await calendar_events_controller.get_by_room(room.id)
+        assert len(events) == 1
+        assert events[0].ics_uid == "sync-event-1"
+        assert events[0].title == "Sync Test Meeting"
+
+        # Second sync with same content (should be unchanged)
+        # Refresh room to get updated etag and force sync by setting old sync time
+        room = await rooms_controller.get_by_id(room.id)
+        await rooms_controller.update(
+            room, {"ics_last_sync": datetime.now(timezone.utc) - timedelta(minutes=10)}
+        )
+        result = await sync_service.sync_room_calendar(room)
+        assert result["status"] == "unchanged"
+
+        # Third sync with updated event
+        event["summary"] = "Updated Meeting Title"
+        cal = Calendar()
+        cal.add_component(event)
+        ics_content = cal.to_ical().decode("utf-8")
+        mock_fetch.return_value = ics_content
+
+        # Force sync by clearing etag
+        await rooms_controller.update(room, {"ics_last_etag": None})
+
+        result = await sync_service.sync_room_calendar(room)
+        assert result["status"] == "success"
+        assert result["events_created"] == 0
+        assert result["events_updated"] == 1
+
+        # Verify event was updated
+        events = await calendar_events_controller.get_by_room(room.id)
+        assert len(events) == 1
+        assert events[0].title == "Updated Meeting Title"
+
+
+@pytest.mark.asyncio
+async def test_ics_sync_service_should_sync():
+    service = ICSSyncService()
+
+    # Room never synced
+    room = MagicMock()
+    room.ics_last_sync = None
+    room.ics_fetch_interval = 300
+    assert service._should_sync(room) is True
+
+    # Room synced recently
+    room.ics_last_sync = datetime.now(timezone.utc) - timedelta(seconds=100)
+    assert service._should_sync(room) is False
+
+    # Room sync due
+    room.ics_last_sync = datetime.now(timezone.utc) - timedelta(seconds=400)
+    assert service._should_sync(room) is True
+
+
+@pytest.mark.asyncio
+async def test_ics_sync_service_skip_disabled():
+    service = ICSSyncService()
+
+    # Room with ICS disabled
+    room = MagicMock()
+    room.ics_enabled = False
+    room.ics_url = "https://calendar.example.com/test.ics"
+
+    result = await service.sync_room_calendar(room)
+    assert result["status"] == "skipped"
+    assert result["reason"] == "ICS not configured"
+
+    # Room without URL
+    room.ics_enabled = True
+    room.ics_url = None
+
+    result = await service.sync_room_calendar(room)
+    assert result["status"] == "skipped"
+    assert result["reason"] == "ICS not configured"
+
+
+@pytest.mark.asyncio
+async def test_ics_sync_service_error_handling():
+    # Create room
+    room = await rooms_controller.add(
+        name="error-test",
+        user_id="test-user",
+        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,
+        ics_url="https://calendar.example.com/error.ics",
+        ics_enabled=True,
+    )
+
+    sync_service = ICSSyncService()
+
+    with patch.object(
+        sync_service.fetch_service, "fetch_ics", new_callable=AsyncMock
+    ) as mock_fetch:
+        mock_fetch.side_effect = Exception("Network error")
+
+        result = await sync_service.sync_room_calendar(room)
+        assert result["status"] == "error"
+        assert "Network error" in result["error"]

server/tests/test_multiple_active_meetings.py

@@ -0,0 +1,283 @@
+"""Tests for multiple active meetings per room functionality."""
+
+from datetime import datetime, timedelta, timezone
+
+import pytest
+
+from reflector.db.calendar_events import CalendarEvent, calendar_events_controller
+from reflector.db.meetings import meetings_controller
+from reflector.db.rooms import rooms_controller
+
+
+@pytest.mark.asyncio
+async def test_multiple_active_meetings_per_room():
+    """Test that multiple active meetings can exist for the same room."""
+    # Create a room
+    room = await rooms_controller.add(
+        name="test-room",
+        user_id="test-user",
+        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)
+
+    # Create first meeting
+    meeting1 = await meetings_controller.create(
+        id="meeting-1",
+        room_name="test-meeting-1",
+        room_url="https://whereby.com/test-1",
+        host_room_url="https://whereby.com/test-1-host",
+        start_date=current_time,
+        end_date=end_time,
+        user_id="test-user",
+        room=room,
+    )
+
+    # Create second meeting for the same room (should succeed now)
+    meeting2 = await meetings_controller.create(
+        id="meeting-2",
+        room_name="test-meeting-2",
+        room_url="https://whereby.com/test-2",
+        host_room_url="https://whereby.com/test-2-host",
+        start_date=current_time,
+        end_date=end_time,
+        user_id="test-user",
+        room=room,
+    )
+
+    # Both meetings should be active
+    active_meetings = await meetings_controller.get_all_active_for_room(
+        room=room, current_time=current_time
+    )
+
+    assert len(active_meetings) == 2
+    assert meeting1.id in [m.id for m in active_meetings]
+    assert meeting2.id in [m.id for m in active_meetings]
+
+
+@pytest.mark.asyncio
+async def test_get_active_by_calendar_event():
+    """Test getting active meeting by calendar event ID."""
+    # Create a room
+    room = await rooms_controller.add(
+        name="test-room",
+        user_id="test-user",
+        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,
+    )
+
+    # Create a calendar event
+    event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="test-event-uid",
+        title="Test Meeting",
+        start_time=datetime.now(timezone.utc),
+        end_time=datetime.now(timezone.utc) + timedelta(hours=1),
+    )
+    event = await calendar_events_controller.upsert(event)
+
+    current_time = datetime.now(timezone.utc)
+    end_time = current_time + timedelta(hours=2)
+
+    # Create meeting linked to calendar event
+    meeting = await meetings_controller.create(
+        id="meeting-cal-1",
+        room_name="test-meeting-cal",
+        room_url="https://whereby.com/test-cal",
+        host_room_url="https://whereby.com/test-cal-host",
+        start_date=current_time,
+        end_date=end_time,
+        user_id="test-user",
+        room=room,
+        calendar_event_id=event.id,
+        calendar_metadata={"title": event.title},
+    )
+
+    # Should find the meeting by calendar event
+    found_meeting = await meetings_controller.get_active_by_calendar_event(
+        room=room, calendar_event_id=event.id, current_time=current_time
+    )
+
+    assert found_meeting is not None
+    assert found_meeting.id == meeting.id
+    assert found_meeting.calendar_event_id == event.id
+
+
+@pytest.mark.asyncio
+async def test_grace_period_logic():
+    """Test that meetings have a grace period after last participant leaves."""
+    # Create a room
+    room = await rooms_controller.add(
+        name="test-room",
+        user_id="test-user",
+        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)
+
+    # Create meeting
+    meeting = await meetings_controller.create(
+        id="meeting-grace",
+        room_name="test-meeting-grace",
+        room_url="https://whereby.com/test-grace",
+        host_room_url="https://whereby.com/test-grace-host",
+        start_date=current_time,
+        end_date=end_time,
+        user_id="test-user",
+        room=room,
+    )
+
+    # Test grace period logic by simulating different states
+
+    # Simulate first time all participants left
+    await meetings_controller.update_meeting(
+        meeting.id, num_clients=0, last_participant_left_at=current_time
+    )
+
+    # Within grace period (10 min) - should still be active
+    await meetings_controller.update_meeting(
+        meeting.id, last_participant_left_at=current_time - timedelta(minutes=10)
+    )
+
+    updated_meeting = await meetings_controller.get_by_id(meeting.id)
+    assert updated_meeting.is_active is True  # Still active during grace period
+
+    # Simulate grace period expired (20 min) and deactivate
+    await meetings_controller.update_meeting(
+        meeting.id, last_participant_left_at=current_time - timedelta(minutes=20)
+    )
+
+    # Manually test the grace period logic that would be in process_meetings
+    updated_meeting = await meetings_controller.get_by_id(meeting.id)
+    if updated_meeting.last_participant_left_at:
+        grace_period = timedelta(minutes=updated_meeting.grace_period_minutes)
+        if current_time > updated_meeting.last_participant_left_at + grace_period:
+            await meetings_controller.update_meeting(meeting.id, is_active=False)
+
+    updated_meeting = await meetings_controller.get_by_id(meeting.id)
+    assert updated_meeting.is_active is False  # Now deactivated
+
+
+@pytest.mark.asyncio
+async def test_calendar_meeting_force_close_after_30_min():
+    """Test that calendar meetings force close 30 minutes after scheduled end."""
+    # Create a room
+    room = await rooms_controller.add(
+        name="test-room",
+        user_id="test-user",
+        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,
+    )
+
+    # Create a calendar event
+    event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="test-event-force",
+        title="Test Meeting Force Close",
+        start_time=datetime.now(timezone.utc) - timedelta(hours=2),
+        end_time=datetime.now(timezone.utc) - timedelta(minutes=35),  # Ended 35 min ago
+    )
+    event = await calendar_events_controller.upsert(event)
+
+    current_time = datetime.now(timezone.utc)
+
+    # Create meeting linked to calendar event
+    meeting = await meetings_controller.create(
+        id="meeting-force",
+        room_name="test-meeting-force",
+        room_url="https://whereby.com/test-force",
+        host_room_url="https://whereby.com/test-force-host",
+        start_date=event.start_time,
+        end_date=event.end_time,
+        user_id="test-user",
+        room=room,
+        calendar_event_id=event.id,
+    )
+
+    # Test that calendar meetings force close 30 min after scheduled end
+    # The meeting ended 35 minutes ago, so it should be force closed
+
+    # Manually test the force close logic that would be in process_meetings
+    if meeting.calendar_event_id:
+        if current_time > meeting.end_date + timedelta(minutes=30):
+            await meetings_controller.update_meeting(meeting.id, is_active=False)
+
+    updated_meeting = await meetings_controller.get_by_id(meeting.id)
+    assert updated_meeting.is_active is False  # Force closed after 30 min
+
+
+@pytest.mark.asyncio
+async def test_participant_rejoin_clears_grace_period():
+    """Test that participant rejoining clears the grace period."""
+    # Create a room
+    room = await rooms_controller.add(
+        name="test-room",
+        user_id="test-user",
+        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)
+
+    # Create meeting with grace period already set
+    meeting = await meetings_controller.create(
+        id="meeting-rejoin",
+        room_name="test-meeting-rejoin",
+        room_url="https://whereby.com/test-rejoin",
+        host_room_url="https://whereby.com/test-rejoin-host",
+        start_date=current_time,
+        end_date=end_time,
+        user_id="test-user",
+        room=room,
+    )
+
+    # Set last_participant_left_at to simulate grace period
+    await meetings_controller.update_meeting(
+        meeting.id,
+        last_participant_left_at=current_time - timedelta(minutes=5),
+        num_clients=0,
+    )
+
+    # Simulate participant rejoining - clear grace period
+    await meetings_controller.update_meeting(
+        meeting.id, last_participant_left_at=None, num_clients=1
+    )
+
+    updated_meeting = await meetings_controller.get_by_id(meeting.id)
+    assert updated_meeting.last_participant_left_at is None  # Grace period cleared
+    assert updated_meeting.is_active is True  # Still active

server/tests/test_room_ics.py

@@ -0,0 +1,225 @@
+"""
+Tests for Room model ICS calendar integration fields.
+"""
+
+from datetime import datetime, timezone
+
+import pytest
+
+from reflector.db.rooms import rooms_controller
+
+
+@pytest.mark.asyncio
+async def test_room_create_with_ics_fields():
+    """Test creating a room with ICS calendar fields."""
+    room = await rooms_controller.add(
+        name="test-room",
+        user_id="test-user",
+        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,
+        ics_url="https://calendar.google.com/calendar/ical/test/private-token/basic.ics",
+        ics_fetch_interval=600,
+        ics_enabled=True,
+    )
+
+    assert room.name == "test-room"
+    assert (
+        room.ics_url
+        == "https://calendar.google.com/calendar/ical/test/private-token/basic.ics"
+    )
+    assert room.ics_fetch_interval == 600
+    assert room.ics_enabled is True
+    assert room.ics_last_sync is None
+    assert room.ics_last_etag is None
+
+
+@pytest.mark.asyncio
+async def test_room_update_ics_configuration():
+    """Test updating room ICS configuration."""
+    # Create room without ICS
+    room = await rooms_controller.add(
+        name="update-test",
+        user_id="test-user",
+        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,
+    )
+
+    assert room.ics_enabled is False
+    assert room.ics_url is None
+
+    # Update with ICS configuration
+    await rooms_controller.update(
+        room,
+        {
+            "ics_url": "https://outlook.office365.com/owa/calendar/test/calendar.ics",
+            "ics_fetch_interval": 300,
+            "ics_enabled": True,
+        },
+    )
+
+    assert (
+        room.ics_url == "https://outlook.office365.com/owa/calendar/test/calendar.ics"
+    )
+    assert room.ics_fetch_interval == 300
+    assert room.ics_enabled is True
+
+
+@pytest.mark.asyncio
+async def test_room_ics_sync_metadata():
+    """Test updating room ICS sync metadata."""
+    room = await rooms_controller.add(
+        name="sync-test",
+        user_id="test-user",
+        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,
+        ics_url="https://example.com/calendar.ics",
+        ics_enabled=True,
+    )
+
+    # Update sync metadata
+    sync_time = datetime.now(timezone.utc)
+    await rooms_controller.update(
+        room,
+        {
+            "ics_last_sync": sync_time,
+            "ics_last_etag": "abc123hash",
+        },
+    )
+
+    assert room.ics_last_sync == sync_time
+    assert room.ics_last_etag == "abc123hash"
+
+
+@pytest.mark.asyncio
+async def test_room_get_with_ics_fields():
+    """Test retrieving room with ICS fields."""
+    # Create room
+    created_room = await rooms_controller.add(
+        name="get-test",
+        user_id="test-user",
+        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,
+        ics_url="webcal://calendar.example.com/feed.ics",
+        ics_fetch_interval=900,
+        ics_enabled=True,
+    )
+
+    # Get by ID
+    room = await rooms_controller.get_by_id(created_room.id)
+    assert room is not None
+    assert room.ics_url == "webcal://calendar.example.com/feed.ics"
+    assert room.ics_fetch_interval == 900
+    assert room.ics_enabled is True
+
+    # Get by name
+    room = await rooms_controller.get_by_name("get-test")
+    assert room is not None
+    assert room.ics_url == "webcal://calendar.example.com/feed.ics"
+    assert room.ics_fetch_interval == 900
+    assert room.ics_enabled is True
+
+
+@pytest.mark.asyncio
+async def test_room_list_with_ics_enabled_filter():
+    """Test listing rooms filtered by ICS enabled status."""
+    # Create rooms with and without ICS
+    room1 = await rooms_controller.add(
+        name="ics-enabled-1",
+        user_id="test-user",
+        zulip_auto_post=False,
+        zulip_stream="",
+        zulip_topic="",
+        is_locked=False,
+        room_mode="normal",
+        recording_type="cloud",
+        recording_trigger="automatic-2nd-participant",
+        is_shared=True,
+        ics_enabled=True,
+        ics_url="https://calendar1.example.com/feed.ics",
+    )
+
+    room2 = await rooms_controller.add(
+        name="ics-disabled",
+        user_id="test-user",
+        zulip_auto_post=False,
+        zulip_stream="",
+        zulip_topic="",
+        is_locked=False,
+        room_mode="normal",
+        recording_type="cloud",
+        recording_trigger="automatic-2nd-participant",
+        is_shared=True,
+        ics_enabled=False,
+    )
+
+    room3 = await rooms_controller.add(
+        name="ics-enabled-2",
+        user_id="test-user",
+        zulip_auto_post=False,
+        zulip_stream="",
+        zulip_topic="",
+        is_locked=False,
+        room_mode="normal",
+        recording_type="cloud",
+        recording_trigger="automatic-2nd-participant",
+        is_shared=True,
+        ics_enabled=True,
+        ics_url="https://calendar2.example.com/feed.ics",
+    )
+
+    # Get all rooms
+    all_rooms = await rooms_controller.get_all()
+    assert len(all_rooms) == 3
+
+    # Filter for ICS-enabled rooms (would need to implement this in controller)
+    ics_rooms = [r for r in all_rooms if r["ics_enabled"]]
+    assert len(ics_rooms) == 2
+    assert all(r["ics_enabled"] for r in ics_rooms)
+
+
+@pytest.mark.asyncio
+async def test_room_default_ics_values():
+    """Test that ICS fields have correct default values."""
+    room = await rooms_controller.add(
+        name="default-test",
+        user_id="test-user",
+        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,
+        # Don't specify ICS fields
+    )
+
+    assert room.ics_url is None
+    assert room.ics_fetch_interval == 300  # Default 5 minutes
+    assert room.ics_enabled is False
+    assert room.ics_last_sync is None
+    assert room.ics_last_etag is None

server/tests/test_room_ics_api.py

@@ -0,0 +1,385 @@
+from datetime import datetime, timedelta, timezone
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from icalendar import Calendar, Event
+
+from reflector.db.calendar_events import CalendarEvent, calendar_events_controller
+from reflector.db.rooms import rooms_controller
+
+
+@pytest.fixture
+async def authenticated_client(client):
+    from reflector.app import app
+    from reflector.auth import current_user_optional
+
+    app.dependency_overrides[current_user_optional] = lambda: {
+        "sub": "test-user",
+        "email": "test@example.com",
+    }
+    yield client
+    del app.dependency_overrides[current_user_optional]
+
+
+@pytest.mark.asyncio
+async def test_create_room_with_ics_fields(authenticated_client):
+    client = authenticated_client
+    response = await client.post(
+        "/rooms",
+        json={
+            "name": "test-ics-room",
+            "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,
+            "ics_url": "https://calendar.example.com/test.ics",
+            "ics_fetch_interval": 600,
+            "ics_enabled": True,
+        },
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["name"] == "test-ics-room"
+    assert data["ics_url"] == "https://calendar.example.com/test.ics"
+    assert data["ics_fetch_interval"] == 600
+    assert data["ics_enabled"] is True
+
+
+@pytest.mark.asyncio
+async def test_update_room_ics_configuration(authenticated_client):
+    client = authenticated_client
+    response = await client.post(
+        "/rooms",
+        json={
+            "name": "update-ics-room",
+            "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,
+        },
+    )
+    assert response.status_code == 200
+    room_id = response.json()["id"]
+
+    response = await client.patch(
+        f"/rooms/{room_id}",
+        json={
+            "ics_url": "https://calendar.google.com/updated.ics",
+            "ics_fetch_interval": 300,
+            "ics_enabled": True,
+        },
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["ics_url"] == "https://calendar.google.com/updated.ics"
+    assert data["ics_fetch_interval"] == 300
+    assert data["ics_enabled"] is True
+
+
+@pytest.mark.asyncio
+async def test_trigger_ics_sync(authenticated_client):
+    client = authenticated_client
+    room = await rooms_controller.add(
+        name="sync-api-room",
+        user_id="test-user",
+        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,
+        ics_url="https://calendar.example.com/api.ics",
+        ics_enabled=True,
+    )
+
+    cal = Calendar()
+    event = Event()
+    event.add("uid", "api-test-event")
+    event.add("summary", "API Test Meeting")
+    from reflector.settings import settings
+
+    event.add("location", f"{settings.BASE_URL}/room/{room.name}")
+    now = datetime.now(timezone.utc)
+    event.add("dtstart", now + timedelta(hours=1))
+    event.add("dtend", now + timedelta(hours=2))
+    cal.add_component(event)
+    ics_content = cal.to_ical().decode("utf-8")
+
+    with patch(
+        "reflector.services.ics_sync.ICSFetchService.fetch_ics", new_callable=AsyncMock
+    ) as mock_fetch:
+        mock_fetch.return_value = ics_content
+
+        response = await client.post(f"/rooms/{room.name}/ics/sync")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["status"] == "success"
+        assert data["events_found"] == 1
+        assert data["events_created"] == 1
+
+
+@pytest.mark.asyncio
+async def test_trigger_ics_sync_unauthorized(client):
+    room = await rooms_controller.add(
+        name="sync-unauth-room",
+        user_id="owner-123",
+        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,
+        ics_url="https://calendar.example.com/api.ics",
+        ics_enabled=True,
+    )
+
+    response = await client.post(f"/rooms/{room.name}/ics/sync")
+    assert response.status_code == 403
+    assert "Only room owner can trigger ICS sync" in response.json()["detail"]
+
+
+@pytest.mark.asyncio
+async def test_trigger_ics_sync_not_configured(authenticated_client):
+    client = authenticated_client
+    room = await rooms_controller.add(
+        name="sync-not-configured",
+        user_id="test-user",
+        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,
+        ics_enabled=False,
+    )
+
+    response = await client.post(f"/rooms/{room.name}/ics/sync")
+    assert response.status_code == 400
+    assert "ICS not configured" in response.json()["detail"]
+
+
+@pytest.mark.asyncio
+async def test_get_ics_status(authenticated_client):
+    client = authenticated_client
+    room = await rooms_controller.add(
+        name="status-room",
+        user_id="test-user",
+        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,
+        ics_url="https://calendar.example.com/status.ics",
+        ics_enabled=True,
+        ics_fetch_interval=300,
+    )
+
+    now = datetime.now(timezone.utc)
+    await rooms_controller.update(
+        room,
+        {"ics_last_sync": now, "ics_last_etag": "test-etag"},
+    )
+
+    response = await client.get(f"/rooms/{room.name}/ics/status")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "enabled"
+    assert data["last_etag"] == "test-etag"
+    assert data["events_count"] == 0
+
+
+@pytest.mark.asyncio
+async def test_get_ics_status_unauthorized(client):
+    room = await rooms_controller.add(
+        name="status-unauth",
+        user_id="owner-456",
+        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,
+        ics_url="https://calendar.example.com/status.ics",
+        ics_enabled=True,
+    )
+
+    response = await client.get(f"/rooms/{room.name}/ics/status")
+    assert response.status_code == 403
+    assert "Only room owner can view ICS status" in response.json()["detail"]
+
+
+@pytest.mark.asyncio
+async def test_list_room_meetings(authenticated_client):
+    client = authenticated_client
+    room = await rooms_controller.add(
+        name="meetings-room",
+        user_id="test-user",
+        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,
+    )
+
+    now = datetime.now(timezone.utc)
+    event1 = CalendarEvent(
+        room_id=room.id,
+        ics_uid="meeting-1",
+        title="Past Meeting",
+        start_time=now - timedelta(hours=2),
+        end_time=now - timedelta(hours=1),
+    )
+    await calendar_events_controller.upsert(event1)
+
+    event2 = CalendarEvent(
+        room_id=room.id,
+        ics_uid="meeting-2",
+        title="Future Meeting",
+        description="Team sync",
+        start_time=now + timedelta(hours=1),
+        end_time=now + timedelta(hours=2),
+        attendees=[{"email": "test@example.com"}],
+    )
+    await calendar_events_controller.upsert(event2)
+
+    response = await client.get(f"/rooms/{room.name}/meetings")
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data) == 2
+    assert data[0]["title"] == "Past Meeting"
+    assert data[1]["title"] == "Future Meeting"
+    assert data[1]["description"] == "Team sync"
+    assert data[1]["attendees"] == [{"email": "test@example.com"}]
+
+
+@pytest.mark.asyncio
+async def test_list_room_meetings_non_owner(client):
+    room = await rooms_controller.add(
+        name="meetings-privacy",
+        user_id="owner-789",
+        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,
+    )
+
+    event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="private-meeting",
+        title="Meeting Title",
+        description="Sensitive info",
+        start_time=datetime.now(timezone.utc) + timedelta(hours=1),
+        end_time=datetime.now(timezone.utc) + timedelta(hours=2),
+        attendees=[{"email": "private@example.com"}],
+    )
+    await calendar_events_controller.upsert(event)
+
+    response = await client.get(f"/rooms/{room.name}/meetings")
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data) == 1
+    assert data[0]["title"] == "Meeting Title"
+    assert data[0]["description"] is None
+    assert data[0]["attendees"] is None
+
+
+@pytest.mark.asyncio
+async def test_list_upcoming_meetings(authenticated_client):
+    client = authenticated_client
+    room = await rooms_controller.add(
+        name="upcoming-room",
+        user_id="test-user",
+        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,
+    )
+
+    now = datetime.now(timezone.utc)
+
+    past_event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="past",
+        title="Past",
+        start_time=now - timedelta(hours=1),
+        end_time=now - timedelta(minutes=30),
+    )
+    await calendar_events_controller.upsert(past_event)
+
+    soon_event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="soon",
+        title="Soon",
+        start_time=now + timedelta(minutes=15),
+        end_time=now + timedelta(minutes=45),
+    )
+    await calendar_events_controller.upsert(soon_event)
+
+    later_event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="later",
+        title="Later",
+        start_time=now + timedelta(hours=2),
+        end_time=now + timedelta(hours=3),
+    )
+    await calendar_events_controller.upsert(later_event)
+
+    response = await client.get(f"/rooms/{room.name}/meetings/upcoming")
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data) == 1
+    assert data[0]["title"] == "Soon"
+
+    response = await client.get(
+        f"/rooms/{room.name}/meetings/upcoming", params={"minutes_ahead": 180}
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data) == 2
+    assert data[0]["title"] == "Soon"
+    assert data[1]["title"] == "Later"
+
+
+@pytest.mark.asyncio
+async def test_room_not_found_endpoints(client):
+    response = await client.post("/rooms/nonexistent/ics/sync")
+    assert response.status_code == 404
+
+    response = await client.get("/rooms/nonexistent/ics/status")
+    assert response.status_code == 404
+
+    response = await client.get("/rooms/nonexistent/meetings")
+    assert response.status_code == 404
+
+    response = await client.get("/rooms/nonexistent/meetings/upcoming")
+    assert response.status_code == 404

server/tests/test_search.py

@@ -0,0 +1,144 @@
+"""Tests for full-text search functionality."""
+
+import json
+from datetime import datetime, timezone
+
+import pytest
+from pydantic import ValidationError
+
+from reflector.db import get_database
+from reflector.db.search import SearchParameters, search_controller
+from reflector.db.transcripts import transcripts
+
+
+@pytest.mark.asyncio
+async def test_search_postgresql_only():
+    params = SearchParameters(query_text="any query here")
+    results, total = await search_controller.search_transcripts(params)
+    assert results == []
+    assert total == 0
+
+    try:
+        SearchParameters(query_text="")
+        assert False, "Should have raised validation error"
+    except ValidationError:
+        pass  # Expected
+
+    # Test that whitespace query raises validation error
+    try:
+        SearchParameters(query_text="   ")
+        assert False, "Should have raised validation error"
+    except ValidationError:
+        pass  # Expected
+
+
+@pytest.mark.asyncio
+async def test_search_input_validation():
+    try:
+        SearchParameters(query_text="")
+        assert False, "Should have raised ValidationError"
+    except ValidationError:
+        pass  # Expected
+
+    # Test that whitespace query raises validation error
+    try:
+        SearchParameters(query_text="   \t\n  ")
+        assert False, "Should have raised ValidationError"
+    except ValidationError:
+        pass  # Expected
+
+
+@pytest.mark.asyncio
+async def test_postgresql_search_with_data():
+    # collision is improbable
+    test_id = "test-search-e2e-7f3a9b2c"
+
+    try:
+        await get_database().execute(
+            transcripts.delete().where(transcripts.c.id == test_id)
+        )
+
+        test_data = {
+            "id": test_id,
+            "name": "Test Search Transcript",
+            "title": "Engineering Planning Meeting Q4 2024",
+            "status": "completed",
+            "locked": False,
+            "duration": 1800.0,
+            "created_at": datetime.now(timezone.utc),
+            "short_summary": "Team discussed search implementation",
+            "long_summary": "The engineering team met to plan the search feature",
+            "topics": json.dumps([]),
+            "events": json.dumps([]),
+            "participants": json.dumps([]),
+            "source_language": "en",
+            "target_language": "en",
+            "reviewed": False,
+            "audio_location": "local",
+            "share_mode": "private",
+            "source_kind": "room",
+            "webvtt": """WEBVTT
+
+00:00:00.000 --> 00:00:10.000
+Welcome to our engineering planning meeting for Q4 2024.
+
+00:00:10.000 --> 00:00:20.000
+Today we'll discuss the implementation of full-text search.
+
+00:00:20.000 --> 00:00:30.000
+The search feature should support complex queries with ranking.
+
+00:00:30.000 --> 00:00:40.000
+We need to implement PostgreSQL tsvector for better performance.""",
+        }
+
+        await get_database().execute(transcripts.insert().values(**test_data))
+
+        # Test 1: Search for a word in title
+        params = SearchParameters(query_text="planning")
+        results, total = await search_controller.search_transcripts(params)
+        assert total >= 1
+        found = any(r.id == test_id for r in results)
+        assert found, "Should find test transcript by title word"
+
+        # Test 2: Search for a word in webvtt content
+        params = SearchParameters(query_text="tsvector")
+        results, total = await search_controller.search_transcripts(params)
+        assert total >= 1
+        found = any(r.id == test_id for r in results)
+        assert found, "Should find test transcript by webvtt content"
+
+        # Test 3: Search with multiple words
+        params = SearchParameters(query_text="engineering planning")
+        results, total = await search_controller.search_transcripts(params)
+        assert total >= 1
+        found = any(r.id == test_id for r in results)
+        assert found, "Should find test transcript by multiple words"
+
+        # Test 4: Verify SearchResult structure
+        test_result = next((r for r in results if r.id == test_id), None)
+        if test_result:
+            assert test_result.title == "Engineering Planning Meeting Q4 2024"
+            assert test_result.status == "completed"
+            assert test_result.duration == 1800.0
+            assert 0 <= test_result.rank <= 1, "Rank should be normalized to 0-1"
+
+        # Test 5: Search with OR operator
+        params = SearchParameters(query_text="tsvector OR nosuchword")
+        results, total = await search_controller.search_transcripts(params)
+        assert total >= 1
+        found = any(r.id == test_id for r in results)
+        assert found, "Should find test transcript with OR query"
+
+        # Test 6: Quoted phrase search
+        params = SearchParameters(query_text='"full-text search"')
+        results, total = await search_controller.search_transcripts(params)
+        assert total >= 1
+        found = any(r.id == test_id for r in results)
+        assert found, "Should find test transcript by exact phrase"
+
+    finally:
+        await get_database().execute(
+            transcripts.delete().where(transcripts.c.id == test_id)
+        )
+        await get_database().disconnect()

server/tests/test_search_snippets.py

@@ -0,0 +1,198 @@
+"""Unit tests for search snippet generation."""
+
+from reflector.db.search import SearchController
+
+
+class TestExtractWebVTT:
+    """Test WebVTT text extraction."""
+
+    def test_extract_webvtt_with_speakers(self):
+        """Test extraction removes speaker tags and timestamps."""
+        webvtt = """WEBVTT
+
+00:00:00.000 --> 00:00:10.000
+<v Speaker0>Hello world, this is a test.
+
+00:00:10.000 --> 00:00:20.000
+<v Speaker1>Indeed it is a test of WebVTT parsing.
+"""
+        result = SearchController._extract_webvtt_text(webvtt)
+        assert "Hello world, this is a test" in result
+        assert "Indeed it is a test" in result
+        assert "<v Speaker" not in result
+        assert "00:00" not in result
+        assert "-->" not in result
+
+    def test_extract_empty_webvtt(self):
+        """Test empty WebVTT returns empty string."""
+        assert SearchController._extract_webvtt_text("") == ""
+        assert SearchController._extract_webvtt_text(None) == ""
+
+    def test_extract_malformed_webvtt(self):
+        """Test malformed WebVTT returns empty string."""
+        result = SearchController._extract_webvtt_text("Not a valid WebVTT")
+        assert result == ""
+
+
+class TestGenerateSnippets:
+    """Test snippet generation from plain text."""
+
+    def test_multiple_matches(self):
+        """Test finding multiple occurrences of search term in long text."""
+        # Create text with Python mentions far apart to get separate snippets
+        separator = " This is filler text. " * 20  # ~400 chars of padding
+        text = (
+            "Python is great for machine learning."
+            + separator
+            + "Many companies use Python for data science."
+            + separator
+            + "Python has excellent libraries for analysis."
+            + separator
+            + "The Python community is very supportive."
+        )
+
+        snippets = SearchController._generate_snippets(text, "Python")
+        # With enough separation, we should get multiple snippets
+        assert len(snippets) >= 2  # At least 2 distinct snippets
+
+        # Each snippet should contain "Python"
+        for snippet in snippets:
+            assert "python" in snippet.lower()
+
+    def test_single_match(self):
+        """Test single occurrence returns one snippet."""
+        text = "This document discusses artificial intelligence and its applications."
+        snippets = SearchController._generate_snippets(text, "artificial intelligence")
+
+        assert len(snippets) == 1
+        assert "artificial intelligence" in snippets[0].lower()
+
+    def test_no_matches(self):
+        """Test no matches returns empty list."""
+        text = "This is some random text without the search term."
+        snippets = SearchController._generate_snippets(text, "machine learning")
+
+        assert snippets == []
+
+    def test_case_insensitive_search(self):
+        """Test search is case insensitive."""
+        # Add enough text between matches to get separate snippets
+        text = (
+            "MACHINE LEARNING is important for modern applications. "
+            + "It requires lots of data and computational resources. " * 5  # Padding
+            + "Machine Learning rocks and transforms industries. "
+            + "Deep learning is a subset of it. " * 5  # More padding
+            + "Finally, machine learning will shape our future."
+        )
+
+        snippets = SearchController._generate_snippets(text, "machine learning")
+
+        # Should find at least 2 (might be 3 if text is long enough)
+        assert len(snippets) >= 2
+        for snippet in snippets:
+            assert "machine learning" in snippet.lower()
+
+    def test_partial_match_fallback(self):
+        """Test fallback to first word when exact phrase not found."""
+        text = "We use machine intelligence for processing."
+        snippets = SearchController._generate_snippets(text, "machine learning")
+
+        # Should fall back to finding "machine"
+        assert len(snippets) == 1
+        assert "machine" in snippets[0].lower()
+
+    def test_snippet_ellipsis(self):
+        """Test ellipsis added for truncated snippets."""
+        # Long text where match is in the middle
+        text = "a " * 100 + "TARGET_WORD special content here" + " b" * 100
+        snippets = SearchController._generate_snippets(text, "TARGET_WORD")
+
+        assert len(snippets) == 1
+        assert "..." in snippets[0]  # Should have ellipsis
+        assert "TARGET_WORD" in snippets[0]
+
+    def test_overlapping_snippets_deduplicated(self):
+        """Test overlapping matches don't create duplicate snippets."""
+        text = "test test test word" * 10  # Repeated pattern
+        snippets = SearchController._generate_snippets(text, "test")
+
+        # Should get unique snippets, not duplicates
+        assert len(snippets) <= 3
+        assert len(snippets) == len(set(snippets))  # All unique
+
+    def test_empty_inputs(self):
+        """Test empty text or search term returns empty list."""
+        assert SearchController._generate_snippets("", "search") == []
+        assert SearchController._generate_snippets("text", "") == []
+        assert SearchController._generate_snippets("", "") == []
+
+    def test_max_snippets_limit(self):
+        """Test respects max_snippets parameter."""
+        # Create text with well-separated occurrences
+        separator = " filler " * 50  # Ensure snippets don't overlap
+        text = ("Python is amazing" + separator) * 10  # 10 occurrences
+
+        # Test with different limits
+        snippets_1 = SearchController._generate_snippets(text, "Python", max_snippets=1)
+        assert len(snippets_1) == 1
+
+        snippets_2 = SearchController._generate_snippets(text, "Python", max_snippets=2)
+        assert len(snippets_2) == 2
+
+        snippets_5 = SearchController._generate_snippets(text, "Python", max_snippets=5)
+        assert len(snippets_5) == 5  # Should get exactly 5 with enough separation
+
+    def test_snippet_length(self):
+        """Test snippet length is reasonable."""
+        text = "word " * 200  # Long text
+        snippets = SearchController._generate_snippets(text, "word")
+
+        for snippet in snippets:
+            # Default max_length is 150 + some context
+            assert len(snippet) <= 200  # Some buffer for ellipsis
+
+
+class TestFullPipeline:
+    """Test the complete WebVTT to snippets pipeline."""
+
+    def test_webvtt_to_snippets_integration(self):
+        """Test full pipeline from WebVTT to search snippets."""
+        # Create WebVTT with well-separated content for multiple snippets
+        webvtt = (
+            """WEBVTT
+
+00:00:00.000 --> 00:00:10.000
+<v Speaker0>Let's discuss machine learning applications in modern technology.
+
+00:00:10.000 --> 00:00:20.000
+<v Speaker1>"""
+            + "Various industries are adopting new technologies. " * 10
+            + """
+
+00:00:20.000 --> 00:00:30.000
+<v Speaker2>Machine learning is revolutionizing healthcare and diagnostics.
+
+00:00:30.000 --> 00:00:40.000
+<v Speaker3>"""
+            + "Financial markets show interesting patterns. " * 10
+            + """
+
+00:00:40.000 --> 00:00:50.000
+<v Speaker0>Machine learning in education provides personalized experiences.
+"""
+        )
+
+        # Extract and generate snippets
+        plain_text = SearchController._extract_webvtt_text(webvtt)
+        snippets = SearchController._generate_snippets(plain_text, "machine learning")
+
+        # Should find at least 2 snippets (text might still be close together)
+        assert len(snippets) >= 1  # At minimum one snippet containing matches
+        assert len(snippets) <= 3  # At most 3 by default
+
+        # No WebVTT artifacts in snippets
+        for snippet in snippets:
+            assert "machine learning" in snippet.lower()
+            assert "<v Speaker" not in snippet
+            assert "00:00" not in snippet
+            assert "-->" not in snippet

server/tests/test_transcripts.py

@@ -1,147 +1,128 @@
 from contextlib import asynccontextmanager
 
 import pytest
-from httpx import AsyncClient
 
 
 @pytest.mark.asyncio
-async def test_transcript_create():
-    from reflector.app import app
+async def test_transcript_create(client):
+    response = await client.post("/transcripts", json={"name": "test"})
+    assert response.status_code == 200
+    assert response.json()["name"] == "test"
+    assert response.json()["status"] == "idle"
+    assert response.json()["locked"] is False
+    assert response.json()["id"] is not None
+    assert response.json()["created_at"] is not None
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post("/transcripts", json={"name": "test"})
-        assert response.status_code == 200
-        assert response.json()["name"] == "test"
-        assert response.json()["status"] == "idle"
-        assert response.json()["locked"] is False
-        assert response.json()["id"] is not None
-        assert response.json()["created_at"] is not None
-
-        # ensure some fields are not returned
-        assert "topics" not in response.json()
-        assert "events" not in response.json()
+    # ensure some fields are not returned
+    assert "topics" not in response.json()
+    assert "events" not in response.json()
 
 
 @pytest.mark.asyncio
-async def test_transcript_get_update_name():
-    from reflector.app import app
+async def test_transcript_get_update_name(client):
+    response = await client.post("/transcripts", json={"name": "test"})
+    assert response.status_code == 200
+    assert response.json()["name"] == "test"
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post("/transcripts", json={"name": "test"})
-        assert response.status_code == 200
-        assert response.json()["name"] == "test"
+    tid = response.json()["id"]
 
-        tid = response.json()["id"]
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["name"] == "test"
 
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["name"] == "test"
+    response = await client.patch(f"/transcripts/{tid}", json={"name": "test2"})
+    assert response.status_code == 200
+    assert response.json()["name"] == "test2"
 
-        response = await ac.patch(f"/transcripts/{tid}", json={"name": "test2"})
-        assert response.status_code == 200
-        assert response.json()["name"] == "test2"
-
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["name"] == "test2"
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["name"] == "test2"
 
 
 @pytest.mark.asyncio
-async def test_transcript_get_update_locked():
-    from reflector.app import app
+async def test_transcript_get_update_locked(client):
+    response = await client.post("/transcripts", json={"name": "test"})
+    assert response.status_code == 200
+    assert response.json()["locked"] is False
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post("/transcripts", json={"name": "test"})
-        assert response.status_code == 200
-        assert response.json()["locked"] is False
+    tid = response.json()["id"]
 
-        tid = response.json()["id"]
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["locked"] is False
 
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["locked"] is False
+    response = await client.patch(f"/transcripts/{tid}", json={"locked": True})
+    assert response.status_code == 200
+    assert response.json()["locked"] is True
 
-        response = await ac.patch(f"/transcripts/{tid}", json={"locked": True})
-        assert response.status_code == 200
-        assert response.json()["locked"] is True
-
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["locked"] is True
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["locked"] is True
 
 
 @pytest.mark.asyncio
-async def test_transcript_get_update_summary():
-    from reflector.app import app
+async def test_transcript_get_update_summary(client):
+    response = await client.post("/transcripts", json={"name": "test"})
+    assert response.status_code == 200
+    assert response.json()["long_summary"] is None
+    assert response.json()["short_summary"] is None
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post("/transcripts", json={"name": "test"})
-        assert response.status_code == 200
-        assert response.json()["long_summary"] is None
-        assert response.json()["short_summary"] is None
+    tid = response.json()["id"]
 
-        tid = response.json()["id"]
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["long_summary"] is None
+    assert response.json()["short_summary"] is None
 
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["long_summary"] is None
-        assert response.json()["short_summary"] is None
+    response = await client.patch(
+        f"/transcripts/{tid}",
+        json={"long_summary": "test_long", "short_summary": "test_short"},
+    )
+    assert response.status_code == 200
+    assert response.json()["long_summary"] == "test_long"
+    assert response.json()["short_summary"] == "test_short"
 
-        response = await ac.patch(
-            f"/transcripts/{tid}",
-            json={"long_summary": "test_long", "short_summary": "test_short"},
-        )
-        assert response.status_code == 200
-        assert response.json()["long_summary"] == "test_long"
-        assert response.json()["short_summary"] == "test_short"
-
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["long_summary"] == "test_long"
-        assert response.json()["short_summary"] == "test_short"
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["long_summary"] == "test_long"
+    assert response.json()["short_summary"] == "test_short"
 
 
 @pytest.mark.asyncio
-async def test_transcript_get_update_title():
-    from reflector.app import app
+async def test_transcript_get_update_title(client):
+    response = await client.post("/transcripts", json={"name": "test"})
+    assert response.status_code == 200
+    assert response.json()["title"] is None
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post("/transcripts", json={"name": "test"})
-        assert response.status_code == 200
-        assert response.json()["title"] is None
+    tid = response.json()["id"]
 
-        tid = response.json()["id"]
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["title"] is None
 
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["title"] is None
+    response = await client.patch(f"/transcripts/{tid}", json={"title": "test_title"})
+    assert response.status_code == 200
+    assert response.json()["title"] == "test_title"
 
-        response = await ac.patch(f"/transcripts/{tid}", json={"title": "test_title"})
-        assert response.status_code == 200
-        assert response.json()["title"] == "test_title"
-
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["title"] == "test_title"
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["title"] == "test_title"
 
 
 @pytest.mark.asyncio
-async def test_transcripts_list_anonymous():
+async def test_transcripts_list_anonymous(client):
     # XXX this test is a bit fragile, as it depends on the storage which
     #     is shared between tests
-    from reflector.app import app
     from reflector.settings import settings
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.get("/transcripts")
-        assert response.status_code == 401
+    response = await client.get("/transcripts")
+    assert response.status_code == 401
 
     # if public mode, it should be allowed
     try:
         settings.PUBLIC_MODE = True
-        async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-            response = await ac.get("/transcripts")
-            assert response.status_code == 200
+        response = await client.get("/transcripts")
+        assert response.status_code == 200
     finally:
         settings.PUBLIC_MODE = False
 
@@ -197,67 +178,59 @@ async def authenticated_client2():
 
 
 @pytest.mark.asyncio
-async def test_transcripts_list_authenticated(authenticated_client):
+async def test_transcripts_list_authenticated(authenticated_client, client):
     # XXX this test is a bit fragile, as it depends on the storage which
     #     is shared between tests
-    from reflector.app import app
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post("/transcripts", json={"name": "testxx1"})
-        assert response.status_code == 200
-        assert response.json()["name"] == "testxx1"
+    response = await client.post("/transcripts", json={"name": "testxx1"})
+    assert response.status_code == 200
+    assert response.json()["name"] == "testxx1"
 
-        response = await ac.post("/transcripts", json={"name": "testxx2"})
-        assert response.status_code == 200
-        assert response.json()["name"] == "testxx2"
+    response = await client.post("/transcripts", json={"name": "testxx2"})
+    assert response.status_code == 200
+    assert response.json()["name"] == "testxx2"
 
-        response = await ac.get("/transcripts")
-        assert response.status_code == 200
-        assert len(response.json()["items"]) >= 2
-        names = [t["name"] for t in response.json()["items"]]
-        assert "testxx1" in names
-        assert "testxx2" in names
+    response = await client.get("/transcripts")
+    assert response.status_code == 200
+    assert len(response.json()["items"]) >= 2
+    names = [t["name"] for t in response.json()["items"]]
+    assert "testxx1" in names
+    assert "testxx2" in names
 
 
 @pytest.mark.asyncio
-async def test_transcript_delete():
-    from reflector.app import app
+async def test_transcript_delete(client):
+    response = await client.post("/transcripts", json={"name": "testdel1"})
+    assert response.status_code == 200
+    assert response.json()["name"] == "testdel1"
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post("/transcripts", json={"name": "testdel1"})
-        assert response.status_code == 200
-        assert response.json()["name"] == "testdel1"
+    tid = response.json()["id"]
+    response = await client.delete(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["status"] == "ok"
 
-        tid = response.json()["id"]
-        response = await ac.delete(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["status"] == "ok"
-
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 404
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 404
 
 
 @pytest.mark.asyncio
-async def test_transcript_mark_reviewed():
-    from reflector.app import app
+async def test_transcript_mark_reviewed(client):
+    response = await client.post("/transcripts", json={"name": "test"})
+    assert response.status_code == 200
+    assert response.json()["name"] == "test"
+    assert response.json()["reviewed"] is False
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post("/transcripts", json={"name": "test"})
-        assert response.status_code == 200
-        assert response.json()["name"] == "test"
-        assert response.json()["reviewed"] is False
+    tid = response.json()["id"]
 
-        tid = response.json()["id"]
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["name"] == "test"
+    assert response.json()["reviewed"] is False
 
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["name"] == "test"
-        assert response.json()["reviewed"] is False
+    response = await client.patch(f"/transcripts/{tid}", json={"reviewed": True})
+    assert response.status_code == 200
+    assert response.json()["reviewed"] is True
 
-        response = await ac.patch(f"/transcripts/{tid}", json={"reviewed": True})
-        assert response.status_code == 200
-        assert response.json()["reviewed"] is True
-
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["reviewed"] is True
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["reviewed"] is True

server/tests/test_transcripts_audio_download.py

@@ -2,20 +2,17 @@ import shutil
 from pathlib import Path
 
 import pytest
-from httpx import AsyncClient
 
 
 @pytest.fixture
-async def fake_transcript(tmpdir):
-    from reflector.app import app
+async def fake_transcript(tmpdir, client):
     from reflector.settings import settings
     from reflector.views.transcripts import transcripts_controller
 
     settings.DATA_DIR = Path(tmpdir)
 
     # create a transcript
-    ac = AsyncClient(app=app, base_url="http://test/v1")
-    response = await ac.post("/transcripts", json={"name": "Test audio download"})
+    response = await client.post("/transcripts", json={"name": "Test audio download"})
     assert response.status_code == 200
     tid = response.json()["id"]
 
@@ -39,17 +36,17 @@ async def fake_transcript(tmpdir):
         ["/mp3", "audio/mpeg"],
     ],
 )
-async def test_transcript_audio_download(fake_transcript, url_suffix, content_type):
-    from reflector.app import app
-
-    ac = AsyncClient(app=app, base_url="http://test/v1")
-    response = await ac.get(f"/transcripts/{fake_transcript.id}/audio{url_suffix}")
+async def test_transcript_audio_download(
+    fake_transcript, url_suffix, content_type, client
+):
+    response = await client.get(f"/transcripts/{fake_transcript.id}/audio{url_suffix}")
     assert response.status_code == 200
     assert response.headers["content-type"] == content_type
 
     # test get 404
-    ac = AsyncClient(app=app, base_url="http://test/v1")
-    response = await ac.get(f"/transcripts/{fake_transcript.id}XXX/audio{url_suffix}")
+    response = await client.get(
+        f"/transcripts/{fake_transcript.id}XXX/audio{url_suffix}"
+    )
     assert response.status_code == 404
 
 
@@ -61,18 +58,16 @@ async def test_transcript_audio_download(fake_transcript, url_suffix, content_ty
     ],
 )
 async def test_transcript_audio_download_head(
-    fake_transcript, url_suffix, content_type
+    fake_transcript, url_suffix, content_type, client
 ):
-    from reflector.app import app
-
-    ac = AsyncClient(app=app, base_url="http://test/v1")
-    response = await ac.head(f"/transcripts/{fake_transcript.id}/audio{url_suffix}")
+    response = await client.head(f"/transcripts/{fake_transcript.id}/audio{url_suffix}")
     assert response.status_code == 200
     assert response.headers["content-type"] == content_type
 
     # test head 404
-    ac = AsyncClient(app=app, base_url="http://test/v1")
-    response = await ac.head(f"/transcripts/{fake_transcript.id}XXX/audio{url_suffix}")
+    response = await client.head(
+        f"/transcripts/{fake_transcript.id}XXX/audio{url_suffix}"
+    )
     assert response.status_code == 404
 
 
@@ -84,12 +79,9 @@ async def test_transcript_audio_download_head(
     ],
 )
 async def test_transcript_audio_download_range(
-    fake_transcript, url_suffix, content_type
+    fake_transcript, url_suffix, content_type, client
 ):
-    from reflector.app import app
-
-    ac = AsyncClient(app=app, base_url="http://test/v1")
-    response = await ac.get(
+    response = await client.get(
         f"/transcripts/{fake_transcript.id}/audio{url_suffix}",
         headers={"range": "bytes=0-100"},
     )
@@ -107,12 +99,9 @@ async def test_transcript_audio_download_range(
     ],
 )
 async def test_transcript_audio_download_range_with_seek(
-    fake_transcript, url_suffix, content_type
+    fake_transcript, url_suffix, content_type, client
 ):
-    from reflector.app import app
-
-    ac = AsyncClient(app=app, base_url="http://test/v1")
-    response = await ac.get(
+    response = await client.get(
         f"/transcripts/{fake_transcript.id}/audio{url_suffix}",
         headers={"range": "bytes=100-"},
     )
@@ -122,13 +111,10 @@ async def test_transcript_audio_download_range_with_seek(
 
 
 @pytest.mark.asyncio
-async def test_transcript_delete_with_audio(fake_transcript):
-    from reflector.app import app
-
-    ac = AsyncClient(app=app, base_url="http://test/v1")
-    response = await ac.delete(f"/transcripts/{fake_transcript.id}")
+async def test_transcript_delete_with_audio(fake_transcript, client):
+    response = await client.delete(f"/transcripts/{fake_transcript.id}")
     assert response.status_code == 200
     assert response.json()["status"] == "ok"
 
-    response = await ac.get(f"/transcripts/{fake_transcript.id}")
+    response = await client.get(f"/transcripts/{fake_transcript.id}")
     assert response.status_code == 404

server/tests/test_transcripts_participants.py

@@ -1,164 +1,151 @@
 import pytest
-from httpx import AsyncClient
 
 
 @pytest.mark.asyncio
-async def test_transcript_participants():
-    from reflector.app import app
+async def test_transcript_participants(client):
+    response = await client.post("/transcripts", json={"name": "test"})
+    assert response.status_code == 200
+    assert response.json()["participants"] == []
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post("/transcripts", json={"name": "test"})
-        assert response.status_code == 200
-        assert response.json()["participants"] == []
+    # create a participant
+    transcript_id = response.json()["id"]
+    response = await client.post(
+        f"/transcripts/{transcript_id}/participants", json={"name": "test"}
+    )
+    assert response.status_code == 200
+    assert response.json()["id"] is not None
+    assert response.json()["speaker"] is None
+    assert response.json()["name"] == "test"
 
-        # create a participant
-        transcript_id = response.json()["id"]
-        response = await ac.post(
-            f"/transcripts/{transcript_id}/participants", json={"name": "test"}
-        )
-        assert response.status_code == 200
-        assert response.json()["id"] is not None
-        assert response.json()["speaker"] is None
-        assert response.json()["name"] == "test"
+    # create another one with a speaker
+    response = await client.post(
+        f"/transcripts/{transcript_id}/participants",
+        json={"name": "test2", "speaker": 1},
+    )
+    assert response.status_code == 200
+    assert response.json()["id"] is not None
+    assert response.json()["speaker"] == 1
+    assert response.json()["name"] == "test2"
 
-        # create another one with a speaker
-        response = await ac.post(
-            f"/transcripts/{transcript_id}/participants",
-            json={"name": "test2", "speaker": 1},
-        )
-        assert response.status_code == 200
-        assert response.json()["id"] is not None
-        assert response.json()["speaker"] == 1
-        assert response.json()["name"] == "test2"
+    # get all participants via transcript
+    response = await client.get(f"/transcripts/{transcript_id}")
+    assert response.status_code == 200
+    assert len(response.json()["participants"]) == 2
 
-        # get all participants via transcript
-        response = await ac.get(f"/transcripts/{transcript_id}")
-        assert response.status_code == 200
-        assert len(response.json()["participants"]) == 2
-
-        # get participants via participants endpoint
-        response = await ac.get(f"/transcripts/{transcript_id}/participants")
-        assert response.status_code == 200
-        assert len(response.json()) == 2
+    # get participants via participants endpoint
+    response = await client.get(f"/transcripts/{transcript_id}/participants")
+    assert response.status_code == 200
+    assert len(response.json()) == 2
 
 
 @pytest.mark.asyncio
-async def test_transcript_participants_same_speaker():
-    from reflector.app import app
+async def test_transcript_participants_same_speaker(client):
+    response = await client.post("/transcripts", json={"name": "test"})
+    assert response.status_code == 200
+    assert response.json()["participants"] == []
+    transcript_id = response.json()["id"]
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post("/transcripts", json={"name": "test"})
-        assert response.status_code == 200
-        assert response.json()["participants"] == []
-        transcript_id = response.json()["id"]
+    # create a participant
+    response = await client.post(
+        f"/transcripts/{transcript_id}/participants",
+        json={"name": "test", "speaker": 1},
+    )
+    assert response.status_code == 200
+    assert response.json()["speaker"] == 1
 
-        # create a participant
-        response = await ac.post(
-            f"/transcripts/{transcript_id}/participants",
-            json={"name": "test", "speaker": 1},
-        )
-        assert response.status_code == 200
-        assert response.json()["speaker"] == 1
-
-        # create another one with the same speaker
-        response = await ac.post(
-            f"/transcripts/{transcript_id}/participants",
-            json={"name": "test2", "speaker": 1},
-        )
-        assert response.status_code == 400
+    # create another one with the same speaker
+    response = await client.post(
+        f"/transcripts/{transcript_id}/participants",
+        json={"name": "test2", "speaker": 1},
+    )
+    assert response.status_code == 400
 
 
 @pytest.mark.asyncio
-async def test_transcript_participants_update_name():
-    from reflector.app import app
+async def test_transcript_participants_update_name(client):
+    response = await client.post("/transcripts", json={"name": "test"})
+    assert response.status_code == 200
+    assert response.json()["participants"] == []
+    transcript_id = response.json()["id"]
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post("/transcripts", json={"name": "test"})
-        assert response.status_code == 200
-        assert response.json()["participants"] == []
-        transcript_id = response.json()["id"]
+    # create a participant
+    response = await client.post(
+        f"/transcripts/{transcript_id}/participants",
+        json={"name": "test", "speaker": 1},
+    )
+    assert response.status_code == 200
+    assert response.json()["speaker"] == 1
 
-        # create a participant
-        response = await ac.post(
-            f"/transcripts/{transcript_id}/participants",
-            json={"name": "test", "speaker": 1},
-        )
-        assert response.status_code == 200
-        assert response.json()["speaker"] == 1
+    # update the participant
+    participant_id = response.json()["id"]
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/participants/{participant_id}",
+        json={"name": "test2"},
+    )
+    assert response.status_code == 200
+    assert response.json()["name"] == "test2"
 
-        # update the participant
-        participant_id = response.json()["id"]
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/participants/{participant_id}",
-            json={"name": "test2"},
-        )
-        assert response.status_code == 200
-        assert response.json()["name"] == "test2"
+    # verify the participant was updated
+    response = await client.get(
+        f"/transcripts/{transcript_id}/participants/{participant_id}"
+    )
+    assert response.status_code == 200
+    assert response.json()["name"] == "test2"
 
-        # verify the participant was updated
-        response = await ac.get(
-            f"/transcripts/{transcript_id}/participants/{participant_id}"
-        )
-        assert response.status_code == 200
-        assert response.json()["name"] == "test2"
-
-        # verify the participant was updated in transcript
-        response = await ac.get(f"/transcripts/{transcript_id}")
-        assert response.status_code == 200
-        assert len(response.json()["participants"]) == 1
-        assert response.json()["participants"][0]["name"] == "test2"
+    # verify the participant was updated in transcript
+    response = await client.get(f"/transcripts/{transcript_id}")
+    assert response.status_code == 200
+    assert len(response.json()["participants"]) == 1
+    assert response.json()["participants"][0]["name"] == "test2"
 
 
 @pytest.mark.asyncio
-async def test_transcript_participants_update_speaker():
-    from reflector.app import app
+async def test_transcript_participants_update_speaker(client):
+    response = await client.post("/transcripts", json={"name": "test"})
+    assert response.status_code == 200
+    assert response.json()["participants"] == []
+    transcript_id = response.json()["id"]
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post("/transcripts", json={"name": "test"})
-        assert response.status_code == 200
-        assert response.json()["participants"] == []
-        transcript_id = response.json()["id"]
+    # create a participant
+    response = await client.post(
+        f"/transcripts/{transcript_id}/participants",
+        json={"name": "test", "speaker": 1},
+    )
+    assert response.status_code == 200
+    participant1_id = response.json()["id"]
 
-        # create a participant
-        response = await ac.post(
-            f"/transcripts/{transcript_id}/participants",
-            json={"name": "test", "speaker": 1},
-        )
-        assert response.status_code == 200
-        participant1_id = response.json()["id"]
+    # create another participant
+    response = await client.post(
+        f"/transcripts/{transcript_id}/participants",
+        json={"name": "test2", "speaker": 2},
+    )
+    assert response.status_code == 200
+    participant2_id = response.json()["id"]
 
-        # create another participant
-        response = await ac.post(
-            f"/transcripts/{transcript_id}/participants",
-            json={"name": "test2", "speaker": 2},
-        )
-        assert response.status_code == 200
-        participant2_id = response.json()["id"]
+    # update the participant, refused as speaker is already taken
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/participants/{participant2_id}",
+        json={"speaker": 1},
+    )
+    assert response.status_code == 400
 
-        # update the participant, refused as speaker is already taken
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/participants/{participant2_id}",
-            json={"speaker": 1},
-        )
-        assert response.status_code == 400
+    # delete the participant 1
+    response = await client.delete(
+        f"/transcripts/{transcript_id}/participants/{participant1_id}"
+    )
+    assert response.status_code == 200
 
-        # delete the participant 1
-        response = await ac.delete(
-            f"/transcripts/{transcript_id}/participants/{participant1_id}"
-        )
-        assert response.status_code == 200
+    # update the participant 2 again, should be accepted now
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/participants/{participant2_id}",
+        json={"speaker": 1},
+    )
+    assert response.status_code == 200
 
-        # update the participant 2 again, should be accepted now
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/participants/{participant2_id}",
-            json={"speaker": 1},
-        )
-        assert response.status_code == 200
-
-        # ensure participant2 name is still there
-        response = await ac.get(
-            f"/transcripts/{transcript_id}/participants/{participant2_id}"
-        )
-        assert response.status_code == 200
-        assert response.json()["name"] == "test2"
-        assert response.json()["speaker"] == 1
+    # ensure participant2 name is still there
+    response = await client.get(
+        f"/transcripts/{transcript_id}/participants/{participant2_id}"
+    )
+    assert response.status_code == 200
+    assert response.json()["name"] == "test2"
+    assert response.json()["speaker"] == 1

server/tests/test_transcripts_process.py

@@ -1,7 +1,26 @@
 import asyncio
+import time
 
 import pytest
-from httpx import AsyncClient
+from httpx import ASGITransport, AsyncClient
+
+
+@pytest.fixture
+async def app_lifespan():
+    from asgi_lifespan import LifespanManager
+
+    from reflector.app import app
+
+    async with LifespanManager(app) as manager:
+        yield manager.app
+
+
+@pytest.fixture
+async def client(app_lifespan):
+    yield AsyncClient(
+        transport=ASGITransport(app=app_lifespan),
+        base_url="http://test/v1",
+    )
 
 
 @pytest.mark.usefixtures("setup_database")
@@ -10,23 +29,21 @@ from httpx import AsyncClient
 @pytest.mark.asyncio
 async def test_transcript_process(
     tmpdir,
+    whisper_transcript,
     dummy_llm,
     dummy_processors,
     dummy_diarization,
     dummy_storage,
+    client,
 ):
-    from reflector.app import app
-
-    ac = AsyncClient(app=app, base_url="http://test/v1")
-
     # create a transcript
-    response = await ac.post("/transcripts", json={"name": "test"})
+    response = await client.post("/transcripts", json={"name": "test"})
     assert response.status_code == 200
     assert response.json()["status"] == "idle"
     tid = response.json()["id"]
 
     # upload mp3
-    response = await ac.post(
+    response = await client.post(
         f"/transcripts/{tid}/record/upload?chunk_number=0&total_chunks=1",
         files={
             "chunk": (
@@ -39,30 +56,38 @@ async def test_transcript_process(
     assert response.status_code == 200
     assert response.json()["status"] == "ok"
 
-    # wait for processing to finish
-    while True:
+    # wait for processing to finish (max 10 minutes)
+    timeout_seconds = 600  # 10 minutes
+    start_time = time.monotonic()
+    while (time.monotonic() - start_time) < timeout_seconds:
         # fetch the transcript and check if it is ended
-        resp = await ac.get(f"/transcripts/{tid}")
+        resp = await client.get(f"/transcripts/{tid}")
         assert resp.status_code == 200
         if resp.json()["status"] in ("ended", "error"):
             break
         await asyncio.sleep(1)
+    else:
+        pytest.fail(f"Initial processing timed out after {timeout_seconds} seconds")
 
     # restart the processing
-    response = await ac.post(
+    response = await client.post(
         f"/transcripts/{tid}/process",
     )
     assert response.status_code == 200
     assert response.json()["status"] == "ok"
 
-    # wait for processing to finish
-    while True:
+    # wait for processing to finish (max 10 minutes)
+    timeout_seconds = 600  # 10 minutes
+    start_time = time.monotonic()
+    while (time.monotonic() - start_time) < timeout_seconds:
         # fetch the transcript and check if it is ended
-        resp = await ac.get(f"/transcripts/{tid}")
+        resp = await client.get(f"/transcripts/{tid}")
         assert resp.status_code == 200
         if resp.json()["status"] in ("ended", "error"):
             break
         await asyncio.sleep(1)
+    else:
+        pytest.fail(f"Restart processing timed out after {timeout_seconds} seconds")
 
     # check the transcript is ended
     transcript = resp.json()
@@ -71,7 +96,7 @@ async def test_transcript_process(
     assert transcript["title"] == "Llm Title"
 
     # check topics and transcript
-    response = await ac.get(f"/transcripts/{tid}/topics")
+    response = await client.get(f"/transcripts/{tid}/topics")
     assert response.status_code == 200
     assert len(response.json()) == 1
     assert "want to share" in response.json()[0]["transcript"]

server/tests/test_transcripts_recording_deletion.py

@@ -0,0 +1,34 @@
+from datetime import datetime, timezone
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from reflector.db.recordings import Recording, recordings_controller
+from reflector.db.transcripts import SourceKind, transcripts_controller
+
+
+@pytest.mark.asyncio
+async def test_recording_deleted_with_transcript():
+    recording = await recordings_controller.create(
+        Recording(
+            bucket_name="test-bucket",
+            object_key="recording.mp4",
+            recorded_at=datetime.now(timezone.utc),
+        )
+    )
+    transcript = await transcripts_controller.add(
+        name="Test Transcript",
+        source_kind=SourceKind.ROOM,
+        recording_id=recording.id,
+    )
+
+    with patch("reflector.db.transcripts.get_recordings_storage") as mock_get_storage:
+        storage_instance = mock_get_storage.return_value
+        storage_instance.delete_file = AsyncMock()
+
+        await transcripts_controller.remove_by_id(transcript.id)
+
+        storage_instance.delete_file.assert_awaited_once_with(recording.object_key)
+
+    assert await recordings_controller.get_by_id(recording.id) is None
+    assert await transcripts_controller.get_by_id(transcript.id) is None

server/tests/test_transcripts_rtc_ws.py

@@ -6,10 +6,10 @@
 import asyncio
 import json
 import threading
+import time
 from pathlib import Path
 
 import pytest
-from httpx import AsyncClient
 from httpx_ws import aconnect_ws
 from uvicorn import Config, Server
 
@@ -21,34 +21,97 @@ class ThreadedUvicorn:
 
     async def start(self):
         self.thread.start()
-        while not self.server.started:
+        timeout_seconds = 600  # 10 minutes
+        start_time = time.monotonic()
+        while (
+            not self.server.started
+            and (time.monotonic() - start_time) < timeout_seconds
+        ):
             await asyncio.sleep(0.1)
+        if not self.server.started:
+            raise TimeoutError(
+                f"Server failed to start after {timeout_seconds} seconds"
+            )
 
     def stop(self):
         if self.thread.is_alive():
             self.server.should_exit = True
-            while self.thread.is_alive():
-                continue
+            timeout_seconds = 600  # 10 minutes
+            start_time = time.time()
+            while (
+                self.thread.is_alive() and (time.time() - start_time) < timeout_seconds
+            ):
+                time.sleep(0.1)
+            if self.thread.is_alive():
+                raise TimeoutError(
+                    f"Thread failed to stop after {timeout_seconds} seconds"
+                )
 
 
 @pytest.fixture
-async def appserver(tmpdir, setup_database, celery_session_app, celery_session_worker):
+def appserver(tmpdir, setup_database, celery_session_app, celery_session_worker):
+    import threading
+
     from reflector.app import app
+    from reflector.db import get_database
     from reflector.settings import settings
 
     DATA_DIR = settings.DATA_DIR
     settings.DATA_DIR = Path(tmpdir)
 
-    # start server
+    # start server in a separate thread with its own event loop
     host = "127.0.0.1"
     port = 1255
-    config = Config(app=app, host=host, port=port)
-    server = ThreadedUvicorn(config)
-    await server.start()
+    server_started = threading.Event()
+    server_exception = None
+    server_instance = None
 
-    yield (server, host, port)
+    def run_server():
+        nonlocal server_exception, server_instance
+        try:
+            # Create a new event loop for this thread
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            config = Config(app=app, host=host, port=port, loop=loop)
+            server_instance = Server(config)
+
+            async def start_server():
+                # Initialize database connection in this event loop
+                database = get_database()
+                await database.connect()
+                try:
+                    await server_instance.serve()
+                finally:
+                    await database.disconnect()
+
+            # Signal that server is starting
+            server_started.set()
+            loop.run_until_complete(start_server())
+        except Exception as e:
+            server_exception = e
+            server_started.set()
+        finally:
+            loop.close()
+
+    server_thread = threading.Thread(target=run_server, daemon=True)
+    server_thread.start()
+
+    # Wait for server to start
+    server_started.wait(timeout=30)
+    if server_exception:
+        raise server_exception
+
+    # Wait a bit more for the server to be fully ready
+    time.sleep(1)
+
+    yield server_instance, host, port
+
+    # Stop server
+    if server_instance:
+        server_instance.should_exit = True
+        server_thread.join(timeout=30)
 
-    server.stop()
     settings.DATA_DIR = DATA_DIR
 
 
@@ -71,6 +134,7 @@ async def test_transcript_rtc_and_websocket(
     dummy_storage,
     fake_mp3_upload,
     appserver,
+    client,
 ):
     # goal: start the server, exchange RTC, receive websocket events
     # because of that, we need to start the server in a thread
@@ -79,8 +143,7 @@ async def test_transcript_rtc_and_websocket(
 
     # create a transcript
     base_url = f"http://{host}:{port}/v1"
-    ac = AsyncClient(base_url=base_url)
-    response = await ac.post("/transcripts", json={"name": "Test RTC"})
+    response = await client.post("/transcripts", json={"name": "Test RTC"})
     assert response.status_code == 200
     tid = response.json()["id"]
 
@@ -92,12 +155,16 @@ async def test_transcript_rtc_and_websocket(
         async with aconnect_ws(f"{base_url}/transcripts/{tid}/events") as ws:
             print("Test websocket: CONNECTED")
             try:
-                while True:
+                timeout_seconds = 600  # 10 minutes
+                start_time = time.monotonic()
+                while (time.monotonic() - start_time) < timeout_seconds:
                     msg = await ws.receive_json()
                     print(f"Test websocket: JSON {msg}")
                     if msg is None:
                         break
                     events.append(msg)
+                else:
+                    print(f"Test websocket: TIMEOUT after {timeout_seconds} seconds")
             except Exception as e:
                 print(f"Test websocket: EXCEPTION {e}")
             finally:
@@ -121,11 +188,11 @@ async def test_transcript_rtc_and_websocket(
 
     url = f"{base_url}/transcripts/{tid}/record/webrtc"
     path = Path(__file__).parent / "records" / "test_short.wav"
-    client = StreamClient(signaling, url=url, play_from=path.as_posix())
-    await client.start()
+    stream_client = StreamClient(signaling, url=url, play_from=path.as_posix())
+    await stream_client.start()
 
-    timeout = 20
-    while not client.is_ended():
+    timeout = 120
+    while not stream_client.is_ended():
         await asyncio.sleep(1)
         timeout -= 1
         if timeout < 0:
@@ -133,21 +200,24 @@ async def test_transcript_rtc_and_websocket(
 
     # XXX aiortc is long to close the connection
     # instead of waiting a long time, we just send a STOP
-    client.channel.send(json.dumps({"cmd": "STOP"}))
-    await client.stop()
+    stream_client.channel.send(json.dumps({"cmd": "STOP"}))
+    await stream_client.stop()
 
     # wait the processing to finish
-    timeout = 20
+    timeout = 120
     while True:
         # fetch the transcript and check if it is ended
-        resp = await ac.get(f"/transcripts/{tid}")
+        resp = await client.get(f"/transcripts/{tid}")
         assert resp.status_code == 200
         if resp.json()["status"] in ("ended", "error"):
             break
         await asyncio.sleep(1)
+        timeout -= 1
+        if timeout < 0:
+            raise TimeoutError("Timeout while waiting for transcript to be ended")
 
     if resp.json()["status"] != "ended":
-        raise TimeoutError("Timeout while waiting for transcript to be ended")
+        raise TimeoutError("Transcript processing failed")
 
     # stop websocket task
     websocket_task.cancel()
@@ -190,7 +260,7 @@ async def test_transcript_rtc_and_websocket(
     ev = events[eventnames.index("WAVEFORM")]
     assert isinstance(ev["data"]["waveform"], list)
     assert len(ev["data"]["waveform"]) >= 250
-    waveform_resp = await ac.get(f"/transcripts/{tid}/audio/waveform")
+    waveform_resp = await client.get(f"/transcripts/{tid}/audio/waveform")
     assert waveform_resp.status_code == 200
     assert waveform_resp.headers["content-type"] == "application/json"
     assert isinstance(waveform_resp.json()["data"], list)
@@ -210,7 +280,7 @@ async def test_transcript_rtc_and_websocket(
     assert "DURATION" in eventnames
 
     # check that audio/mp3 is available
-    audio_resp = await ac.get(f"/transcripts/{tid}/audio/mp3")
+    audio_resp = await client.get(f"/transcripts/{tid}/audio/mp3")
     assert audio_resp.status_code == 200
     assert audio_resp.headers["Content-Type"] == "audio/mpeg"
 
@@ -229,6 +299,7 @@ async def test_transcript_rtc_and_websocket_and_fr(
     dummy_storage,
     fake_mp3_upload,
     appserver,
+    client,
 ):
     # goal: start the server, exchange RTC, receive websocket events
     # because of that, we need to start the server in a thread
@@ -238,8 +309,7 @@ async def test_transcript_rtc_and_websocket_and_fr(
 
     # create a transcript
     base_url = f"http://{host}:{port}/v1"
-    ac = AsyncClient(base_url=base_url)
-    response = await ac.post(
+    response = await client.post(
         "/transcripts", json={"name": "Test RTC", "target_language": "fr"}
     )
     assert response.status_code == 200
@@ -253,12 +323,16 @@ async def test_transcript_rtc_and_websocket_and_fr(
         async with aconnect_ws(f"{base_url}/transcripts/{tid}/events") as ws:
             print("Test websocket: CONNECTED")
             try:
-                while True:
+                timeout_seconds = 600  # 10 minutes
+                start_time = time.monotonic()
+                while (time.monotonic() - start_time) < timeout_seconds:
                     msg = await ws.receive_json()
                     print(f"Test websocket: JSON {msg}")
                     if msg is None:
                         break
                     events.append(msg)
+                else:
+                    print(f"Test websocket: TIMEOUT after {timeout_seconds} seconds")
             except Exception as e:
                 print(f"Test websocket: EXCEPTION {e}")
             finally:
@@ -282,11 +356,11 @@ async def test_transcript_rtc_and_websocket_and_fr(
 
     url = f"{base_url}/transcripts/{tid}/record/webrtc"
     path = Path(__file__).parent / "records" / "test_short.wav"
-    client = StreamClient(signaling, url=url, play_from=path.as_posix())
-    await client.start()
+    stream_client = StreamClient(signaling, url=url, play_from=path.as_posix())
+    await stream_client.start()
 
-    timeout = 20
-    while not client.is_ended():
+    timeout = 120
+    while not stream_client.is_ended():
         await asyncio.sleep(1)
         timeout -= 1
         if timeout < 0:
@@ -294,25 +368,28 @@ async def test_transcript_rtc_and_websocket_and_fr(
 
     # XXX aiortc is long to close the connection
     # instead of waiting a long time, we just send a STOP
-    client.channel.send(json.dumps({"cmd": "STOP"}))
+    stream_client.channel.send(json.dumps({"cmd": "STOP"}))
 
     # wait the processing to finish
     await asyncio.sleep(2)
 
-    await client.stop()
+    await stream_client.stop()
 
     # wait the processing to finish
-    timeout = 20
+    timeout = 120
     while True:
         # fetch the transcript and check if it is ended
-        resp = await ac.get(f"/transcripts/{tid}")
+        resp = await client.get(f"/transcripts/{tid}")
         assert resp.status_code == 200
         if resp.json()["status"] == "ended":
             break
         await asyncio.sleep(1)
+        timeout -= 1
+        if timeout < 0:
+            raise TimeoutError("Timeout while waiting for transcript to be ended")
 
     if resp.json()["status"] != "ended":
-        raise TimeoutError("Timeout while waiting for transcript to be ended")
+        raise TimeoutError("Transcript processing failed")
 
     await asyncio.sleep(2)
 

server/tests/test_transcripts_speaker.py

@@ -1,401 +1,390 @@
 import pytest
-from httpx import AsyncClient
 
 
 @pytest.mark.asyncio
-async def test_transcript_reassign_speaker(fake_transcript_with_topics):
-    from reflector.app import app
-
+async def test_transcript_reassign_speaker(fake_transcript_with_topics, client):
     transcript_id = fake_transcript_with_topics.id
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        # check the transcript exists
-        response = await ac.get(f"/transcripts/{transcript_id}")
-        assert response.status_code == 200
+    # check the transcript exists
+    response = await client.get(f"/transcripts/{transcript_id}")
+    assert response.status_code == 200
 
-        # check initial topics of the transcript
-        response = await ac.get(f"/transcripts/{transcript_id}/topics/with-words")
-        assert response.status_code == 200
-        topics = response.json()
-        assert len(topics) == 2
+    # check initial topics of the transcript
+    response = await client.get(f"/transcripts/{transcript_id}/topics/with-words")
+    assert response.status_code == 200
+    topics = response.json()
+    assert len(topics) == 2
 
-        # check through words
-        assert topics[0]["words"][0]["speaker"] == 0
-        assert topics[0]["words"][1]["speaker"] == 0
-        assert topics[1]["words"][0]["speaker"] == 0
-        assert topics[1]["words"][1]["speaker"] == 0
-        # check through segments
-        assert len(topics[0]["segments"]) == 1
-        assert topics[0]["segments"][0]["speaker"] == 0
-        assert len(topics[1]["segments"]) == 1
-        assert topics[1]["segments"][0]["speaker"] == 0
+    # check through words
+    assert topics[0]["words"][0]["speaker"] == 0
+    assert topics[0]["words"][1]["speaker"] == 0
+    assert topics[1]["words"][0]["speaker"] == 0
+    assert topics[1]["words"][1]["speaker"] == 0
+    # check through segments
+    assert len(topics[0]["segments"]) == 1
+    assert topics[0]["segments"][0]["speaker"] == 0
+    assert len(topics[1]["segments"]) == 1
+    assert topics[1]["segments"][0]["speaker"] == 0
 
-        # reassign speaker
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/speaker/assign",
-            json={
-                "speaker": 1,
-                "timestamp_from": 0,
-                "timestamp_to": 1,
-            },
-        )
-        assert response.status_code == 200
+    # reassign speaker
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/speaker/assign",
+        json={
+            "speaker": 1,
+            "timestamp_from": 0,
+            "timestamp_to": 1,
+        },
+    )
+    assert response.status_code == 200
 
-        # check topics again
-        response = await ac.get(f"/transcripts/{transcript_id}/topics/with-words")
-        assert response.status_code == 200
-        topics = response.json()
-        assert len(topics) == 2
+    # check topics again
+    response = await client.get(f"/transcripts/{transcript_id}/topics/with-words")
+    assert response.status_code == 200
+    topics = response.json()
+    assert len(topics) == 2
 
-        # check through words
-        assert topics[0]["words"][0]["speaker"] == 1
-        assert topics[0]["words"][1]["speaker"] == 1
-        assert topics[1]["words"][0]["speaker"] == 0
-        assert topics[1]["words"][1]["speaker"] == 0
-        # check segments
-        assert len(topics[0]["segments"]) == 1
-        assert topics[0]["segments"][0]["speaker"] == 1
-        assert len(topics[1]["segments"]) == 1
-        assert topics[1]["segments"][0]["speaker"] == 0
+    # check through words
+    assert topics[0]["words"][0]["speaker"] == 1
+    assert topics[0]["words"][1]["speaker"] == 1
+    assert topics[1]["words"][0]["speaker"] == 0
+    assert topics[1]["words"][1]["speaker"] == 0
+    # check segments
+    assert len(topics[0]["segments"]) == 1
+    assert topics[0]["segments"][0]["speaker"] == 1
+    assert len(topics[1]["segments"]) == 1
+    assert topics[1]["segments"][0]["speaker"] == 0
 
-        # reassign speaker, middle of 2 topics
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/speaker/assign",
-            json={
-                "speaker": 2,
-                "timestamp_from": 1,
-                "timestamp_to": 2.5,
-            },
-        )
-        assert response.status_code == 200
+    # reassign speaker, middle of 2 topics
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/speaker/assign",
+        json={
+            "speaker": 2,
+            "timestamp_from": 1,
+            "timestamp_to": 2.5,
+        },
+    )
+    assert response.status_code == 200
 
-        # check topics again
-        response = await ac.get(f"/transcripts/{transcript_id}/topics/with-words")
-        assert response.status_code == 200
-        topics = response.json()
-        assert len(topics) == 2
+    # check topics again
+    response = await client.get(f"/transcripts/{transcript_id}/topics/with-words")
+    assert response.status_code == 200
+    topics = response.json()
+    assert len(topics) == 2
 
-        # check through words
-        assert topics[0]["words"][0]["speaker"] == 1
-        assert topics[0]["words"][1]["speaker"] == 2
-        assert topics[1]["words"][0]["speaker"] == 2
-        assert topics[1]["words"][1]["speaker"] == 0
-        # check segments
-        assert len(topics[0]["segments"]) == 2
-        assert topics[0]["segments"][0]["speaker"] == 1
-        assert topics[0]["segments"][1]["speaker"] == 2
-        assert len(topics[1]["segments"]) == 2
-        assert topics[1]["segments"][0]["speaker"] == 2
-        assert topics[1]["segments"][1]["speaker"] == 0
+    # check through words
+    assert topics[0]["words"][0]["speaker"] == 1
+    assert topics[0]["words"][1]["speaker"] == 2
+    assert topics[1]["words"][0]["speaker"] == 2
+    assert topics[1]["words"][1]["speaker"] == 0
+    # check segments
+    assert len(topics[0]["segments"]) == 2
+    assert topics[0]["segments"][0]["speaker"] == 1
+    assert topics[0]["segments"][1]["speaker"] == 2
+    assert len(topics[1]["segments"]) == 2
+    assert topics[1]["segments"][0]["speaker"] == 2
+    assert topics[1]["segments"][1]["speaker"] == 0
 
-        # reassign speaker, everything
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/speaker/assign",
-            json={
-                "speaker": 4,
-                "timestamp_from": 0,
-                "timestamp_to": 100,
-            },
-        )
-        assert response.status_code == 200
+    # reassign speaker, everything
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/speaker/assign",
+        json={
+            "speaker": 4,
+            "timestamp_from": 0,
+            "timestamp_to": 100,
+        },
+    )
+    assert response.status_code == 200
 
-        # check topics again
-        response = await ac.get(f"/transcripts/{transcript_id}/topics/with-words")
-        assert response.status_code == 200
-        topics = response.json()
-        assert len(topics) == 2
+    # check topics again
+    response = await client.get(f"/transcripts/{transcript_id}/topics/with-words")
+    assert response.status_code == 200
+    topics = response.json()
+    assert len(topics) == 2
 
-        # check through words
-        assert topics[0]["words"][0]["speaker"] == 4
-        assert topics[0]["words"][1]["speaker"] == 4
-        assert topics[1]["words"][0]["speaker"] == 4
-        assert topics[1]["words"][1]["speaker"] == 4
-        # check segments
-        assert len(topics[0]["segments"]) == 1
-        assert topics[0]["segments"][0]["speaker"] == 4
-        assert len(topics[1]["segments"]) == 1
-        assert topics[1]["segments"][0]["speaker"] == 4
+    # check through words
+    assert topics[0]["words"][0]["speaker"] == 4
+    assert topics[0]["words"][1]["speaker"] == 4
+    assert topics[1]["words"][0]["speaker"] == 4
+    assert topics[1]["words"][1]["speaker"] == 4
+    # check segments
+    assert len(topics[0]["segments"]) == 1
+    assert topics[0]["segments"][0]["speaker"] == 4
+    assert len(topics[1]["segments"]) == 1
+    assert topics[1]["segments"][0]["speaker"] == 4
 
 
 @pytest.mark.asyncio
-async def test_transcript_merge_speaker(fake_transcript_with_topics):
-    from reflector.app import app
-
+async def test_transcript_merge_speaker(fake_transcript_with_topics, client):
     transcript_id = fake_transcript_with_topics.id
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        # check the transcript exists
-        response = await ac.get(f"/transcripts/{transcript_id}")
-        assert response.status_code == 200
+    # check the transcript exists
+    response = await client.get(f"/transcripts/{transcript_id}")
+    assert response.status_code == 200
 
-        # check initial topics of the transcript
-        response = await ac.get(f"/transcripts/{transcript_id}/topics/with-words")
-        assert response.status_code == 200
-        topics = response.json()
-        assert len(topics) == 2
+    # check initial topics of the transcript
+    response = await client.get(f"/transcripts/{transcript_id}/topics/with-words")
+    assert response.status_code == 200
+    topics = response.json()
+    assert len(topics) == 2
 
-        # check through words
-        assert topics[0]["words"][0]["speaker"] == 0
-        assert topics[0]["words"][1]["speaker"] == 0
-        assert topics[1]["words"][0]["speaker"] == 0
-        assert topics[1]["words"][1]["speaker"] == 0
+    # check through words
+    assert topics[0]["words"][0]["speaker"] == 0
+    assert topics[0]["words"][1]["speaker"] == 0
+    assert topics[1]["words"][0]["speaker"] == 0
+    assert topics[1]["words"][1]["speaker"] == 0
 
-        # reassign speaker
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/speaker/assign",
-            json={
-                "speaker": 1,
-                "timestamp_from": 0,
-                "timestamp_to": 1,
-            },
-        )
-        assert response.status_code == 200
+    # reassign speaker
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/speaker/assign",
+        json={
+            "speaker": 1,
+            "timestamp_from": 0,
+            "timestamp_to": 1,
+        },
+    )
+    assert response.status_code == 200
 
-        # check topics again
-        response = await ac.get(f"/transcripts/{transcript_id}/topics/with-words")
-        assert response.status_code == 200
-        topics = response.json()
-        assert len(topics) == 2
+    # check topics again
+    response = await client.get(f"/transcripts/{transcript_id}/topics/with-words")
+    assert response.status_code == 200
+    topics = response.json()
+    assert len(topics) == 2
 
-        # check through words
-        assert topics[0]["words"][0]["speaker"] == 1
-        assert topics[0]["words"][1]["speaker"] == 1
-        assert topics[1]["words"][0]["speaker"] == 0
-        assert topics[1]["words"][1]["speaker"] == 0
+    # check through words
+    assert topics[0]["words"][0]["speaker"] == 1
+    assert topics[0]["words"][1]["speaker"] == 1
+    assert topics[1]["words"][0]["speaker"] == 0
+    assert topics[1]["words"][1]["speaker"] == 0
 
-        # merge speakers
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/speaker/merge",
-            json={
-                "speaker_from": 1,
-                "speaker_to": 0,
-            },
-        )
-        assert response.status_code == 200
+    # merge speakers
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/speaker/merge",
+        json={
+            "speaker_from": 1,
+            "speaker_to": 0,
+        },
+    )
+    assert response.status_code == 200
 
-        # check topics again
-        response = await ac.get(f"/transcripts/{transcript_id}/topics/with-words")
-        assert response.status_code == 200
-        topics = response.json()
-        assert len(topics) == 2
+    # check topics again
+    response = await client.get(f"/transcripts/{transcript_id}/topics/with-words")
+    assert response.status_code == 200
+    topics = response.json()
+    assert len(topics) == 2
 
-        # check through words
-        assert topics[0]["words"][0]["speaker"] == 0
-        assert topics[0]["words"][1]["speaker"] == 0
-        assert topics[1]["words"][0]["speaker"] == 0
-        assert topics[1]["words"][1]["speaker"] == 0
+    # check through words
+    assert topics[0]["words"][0]["speaker"] == 0
+    assert topics[0]["words"][1]["speaker"] == 0
+    assert topics[1]["words"][0]["speaker"] == 0
+    assert topics[1]["words"][1]["speaker"] == 0
 
 
 @pytest.mark.asyncio
-async def test_transcript_reassign_with_participant(fake_transcript_with_topics):
-    from reflector.app import app
-
+async def test_transcript_reassign_with_participant(
+    fake_transcript_with_topics, client
+):
     transcript_id = fake_transcript_with_topics.id
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        # check the transcript exists
-        response = await ac.get(f"/transcripts/{transcript_id}")
-        assert response.status_code == 200
-        transcript = response.json()
-        assert len(transcript["participants"]) == 0
+    # check the transcript exists
+    response = await client.get(f"/transcripts/{transcript_id}")
+    assert response.status_code == 200
+    transcript = response.json()
+    assert len(transcript["participants"]) == 0
 
-        # create 2 participants
-        response = await ac.post(
-            f"/transcripts/{transcript_id}/participants",
-            json={
-                "name": "Participant 1",
-            },
-        )
-        assert response.status_code == 200
-        participant1_id = response.json()["id"]
+    # create 2 participants
+    response = await client.post(
+        f"/transcripts/{transcript_id}/participants",
+        json={
+            "name": "Participant 1",
+        },
+    )
+    assert response.status_code == 200
+    participant1_id = response.json()["id"]
 
-        response = await ac.post(
-            f"/transcripts/{transcript_id}/participants",
-            json={
-                "name": "Participant 2",
-            },
-        )
-        assert response.status_code == 200
-        participant2_id = response.json()["id"]
+    response = await client.post(
+        f"/transcripts/{transcript_id}/participants",
+        json={
+            "name": "Participant 2",
+        },
+    )
+    assert response.status_code == 200
+    participant2_id = response.json()["id"]
 
-        # check participants speakers
-        response = await ac.get(f"/transcripts/{transcript_id}/participants")
-        assert response.status_code == 200
-        participants = response.json()
-        assert len(participants) == 2
-        assert participants[0]["name"] == "Participant 1"
-        assert participants[0]["speaker"] is None
-        assert participants[1]["name"] == "Participant 2"
-        assert participants[1]["speaker"] is None
+    # check participants speakers
+    response = await client.get(f"/transcripts/{transcript_id}/participants")
+    assert response.status_code == 200
+    participants = response.json()
+    assert len(participants) == 2
+    assert participants[0]["name"] == "Participant 1"
+    assert participants[0]["speaker"] is None
+    assert participants[1]["name"] == "Participant 2"
+    assert participants[1]["speaker"] is None
 
-        # check initial topics of the transcript
-        response = await ac.get(f"/transcripts/{transcript_id}/topics/with-words")
-        assert response.status_code == 200
-        topics = response.json()
-        assert len(topics) == 2
+    # check initial topics of the transcript
+    response = await client.get(f"/transcripts/{transcript_id}/topics/with-words")
+    assert response.status_code == 200
+    topics = response.json()
+    assert len(topics) == 2
 
-        # check through words
-        assert topics[0]["words"][0]["speaker"] == 0
-        assert topics[0]["words"][1]["speaker"] == 0
-        assert topics[1]["words"][0]["speaker"] == 0
-        assert topics[1]["words"][1]["speaker"] == 0
-        # check through segments
-        assert len(topics[0]["segments"]) == 1
-        assert topics[0]["segments"][0]["speaker"] == 0
-        assert len(topics[1]["segments"]) == 1
-        assert topics[1]["segments"][0]["speaker"] == 0
+    # check through words
+    assert topics[0]["words"][0]["speaker"] == 0
+    assert topics[0]["words"][1]["speaker"] == 0
+    assert topics[1]["words"][0]["speaker"] == 0
+    assert topics[1]["words"][1]["speaker"] == 0
+    # check through segments
+    assert len(topics[0]["segments"]) == 1
+    assert topics[0]["segments"][0]["speaker"] == 0
+    assert len(topics[1]["segments"]) == 1
+    assert topics[1]["segments"][0]["speaker"] == 0
 
-        # reassign speaker from a participant
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/speaker/assign",
-            json={
-                "participant": participant1_id,
-                "timestamp_from": 0,
-                "timestamp_to": 1,
-            },
-        )
-        assert response.status_code == 200
+    # reassign speaker from a participant
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/speaker/assign",
+        json={
+            "participant": participant1_id,
+            "timestamp_from": 0,
+            "timestamp_to": 1,
+        },
+    )
+    assert response.status_code == 200
 
-        # check participants if speaker has been assigned
-        # first participant should have 1, because it's not used yet.
-        response = await ac.get(f"/transcripts/{transcript_id}/participants")
-        assert response.status_code == 200
-        participants = response.json()
-        assert len(participants) == 2
-        assert participants[0]["name"] == "Participant 1"
-        assert participants[0]["speaker"] == 1
-        assert participants[1]["name"] == "Participant 2"
-        assert participants[1]["speaker"] is None
+    # check participants if speaker has been assigned
+    # first participant should have 1, because it's not used yet.
+    response = await client.get(f"/transcripts/{transcript_id}/participants")
+    assert response.status_code == 200
+    participants = response.json()
+    assert len(participants) == 2
+    assert participants[0]["name"] == "Participant 1"
+    assert participants[0]["speaker"] == 1
+    assert participants[1]["name"] == "Participant 2"
+    assert participants[1]["speaker"] is None
 
-        # check topics again
-        response = await ac.get(f"/transcripts/{transcript_id}/topics/with-words")
-        assert response.status_code == 200
-        topics = response.json()
-        assert len(topics) == 2
+    # check topics again
+    response = await client.get(f"/transcripts/{transcript_id}/topics/with-words")
+    assert response.status_code == 200
+    topics = response.json()
+    assert len(topics) == 2
 
-        # check through words
-        assert topics[0]["words"][0]["speaker"] == 1
-        assert topics[0]["words"][1]["speaker"] == 1
-        assert topics[1]["words"][0]["speaker"] == 0
-        assert topics[1]["words"][1]["speaker"] == 0
-        # check segments
-        assert len(topics[0]["segments"]) == 1
-        assert topics[0]["segments"][0]["speaker"] == 1
-        assert len(topics[1]["segments"]) == 1
-        assert topics[1]["segments"][0]["speaker"] == 0
+    # check through words
+    assert topics[0]["words"][0]["speaker"] == 1
+    assert topics[0]["words"][1]["speaker"] == 1
+    assert topics[1]["words"][0]["speaker"] == 0
+    assert topics[1]["words"][1]["speaker"] == 0
+    # check segments
+    assert len(topics[0]["segments"]) == 1
+    assert topics[0]["segments"][0]["speaker"] == 1
+    assert len(topics[1]["segments"]) == 1
+    assert topics[1]["segments"][0]["speaker"] == 0
 
-        # reassign participant, middle of 2 topics
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/speaker/assign",
-            json={
-                "participant": participant2_id,
-                "timestamp_from": 1,
-                "timestamp_to": 2.5,
-            },
-        )
-        assert response.status_code == 200
+    # reassign participant, middle of 2 topics
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/speaker/assign",
+        json={
+            "participant": participant2_id,
+            "timestamp_from": 1,
+            "timestamp_to": 2.5,
+        },
+    )
+    assert response.status_code == 200
 
-        # check participants if speaker has been assigned
-        # first participant should have 1, because it's not used yet.
-        response = await ac.get(f"/transcripts/{transcript_id}/participants")
-        assert response.status_code == 200
-        participants = response.json()
-        assert len(participants) == 2
-        assert participants[0]["name"] == "Participant 1"
-        assert participants[0]["speaker"] == 1
-        assert participants[1]["name"] == "Participant 2"
-        assert participants[1]["speaker"] == 2
+    # check participants if speaker has been assigned
+    # first participant should have 1, because it's not used yet.
+    response = await client.get(f"/transcripts/{transcript_id}/participants")
+    assert response.status_code == 200
+    participants = response.json()
+    assert len(participants) == 2
+    assert participants[0]["name"] == "Participant 1"
+    assert participants[0]["speaker"] == 1
+    assert participants[1]["name"] == "Participant 2"
+    assert participants[1]["speaker"] == 2
 
-        # check topics again
-        response = await ac.get(f"/transcripts/{transcript_id}/topics/with-words")
-        assert response.status_code == 200
-        topics = response.json()
-        assert len(topics) == 2
+    # check topics again
+    response = await client.get(f"/transcripts/{transcript_id}/topics/with-words")
+    assert response.status_code == 200
+    topics = response.json()
+    assert len(topics) == 2
 
-        # check through words
-        assert topics[0]["words"][0]["speaker"] == 1
-        assert topics[0]["words"][1]["speaker"] == 2
-        assert topics[1]["words"][0]["speaker"] == 2
-        assert topics[1]["words"][1]["speaker"] == 0
-        # check segments
-        assert len(topics[0]["segments"]) == 2
-        assert topics[0]["segments"][0]["speaker"] == 1
-        assert topics[0]["segments"][1]["speaker"] == 2
-        assert len(topics[1]["segments"]) == 2
-        assert topics[1]["segments"][0]["speaker"] == 2
-        assert topics[1]["segments"][1]["speaker"] == 0
+    # check through words
+    assert topics[0]["words"][0]["speaker"] == 1
+    assert topics[0]["words"][1]["speaker"] == 2
+    assert topics[1]["words"][0]["speaker"] == 2
+    assert topics[1]["words"][1]["speaker"] == 0
+    # check segments
+    assert len(topics[0]["segments"]) == 2
+    assert topics[0]["segments"][0]["speaker"] == 1
+    assert topics[0]["segments"][1]["speaker"] == 2
+    assert len(topics[1]["segments"]) == 2
+    assert topics[1]["segments"][0]["speaker"] == 2
+    assert topics[1]["segments"][1]["speaker"] == 0
 
-        # reassign speaker, everything
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/speaker/assign",
-            json={
-                "participant": participant1_id,
-                "timestamp_from": 0,
-                "timestamp_to": 100,
-            },
-        )
-        assert response.status_code == 200
+    # reassign speaker, everything
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/speaker/assign",
+        json={
+            "participant": participant1_id,
+            "timestamp_from": 0,
+            "timestamp_to": 100,
+        },
+    )
+    assert response.status_code == 200
 
-        # check topics again
-        response = await ac.get(f"/transcripts/{transcript_id}/topics/with-words")
-        assert response.status_code == 200
-        topics = response.json()
-        assert len(topics) == 2
+    # check topics again
+    response = await client.get(f"/transcripts/{transcript_id}/topics/with-words")
+    assert response.status_code == 200
+    topics = response.json()
+    assert len(topics) == 2
 
-        # check through words
-        assert topics[0]["words"][0]["speaker"] == 1
-        assert topics[0]["words"][1]["speaker"] == 1
-        assert topics[1]["words"][0]["speaker"] == 1
-        assert topics[1]["words"][1]["speaker"] == 1
-        # check segments
-        assert len(topics[0]["segments"]) == 1
-        assert topics[0]["segments"][0]["speaker"] == 1
-        assert len(topics[1]["segments"]) == 1
-        assert topics[1]["segments"][0]["speaker"] == 1
+    # check through words
+    assert topics[0]["words"][0]["speaker"] == 1
+    assert topics[0]["words"][1]["speaker"] == 1
+    assert topics[1]["words"][0]["speaker"] == 1
+    assert topics[1]["words"][1]["speaker"] == 1
+    # check segments
+    assert len(topics[0]["segments"]) == 1
+    assert topics[0]["segments"][0]["speaker"] == 1
+    assert len(topics[1]["segments"]) == 1
+    assert topics[1]["segments"][0]["speaker"] == 1
 
 
 @pytest.mark.asyncio
-async def test_transcript_reassign_edge_cases(fake_transcript_with_topics):
-    from reflector.app import app
-
+async def test_transcript_reassign_edge_cases(fake_transcript_with_topics, client):
     transcript_id = fake_transcript_with_topics.id
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        # check the transcript exists
-        response = await ac.get(f"/transcripts/{transcript_id}")
-        assert response.status_code == 200
-        transcript = response.json()
-        assert len(transcript["participants"]) == 0
+    # check the transcript exists
+    response = await client.get(f"/transcripts/{transcript_id}")
+    assert response.status_code == 200
+    transcript = response.json()
+    assert len(transcript["participants"]) == 0
 
-        # try reassign without any participant_id or speaker
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/speaker/assign",
-            json={
-                "timestamp_from": 0,
-                "timestamp_to": 1,
-            },
-        )
-        assert response.status_code == 400
+    # try reassign without any participant_id or speaker
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/speaker/assign",
+        json={
+            "timestamp_from": 0,
+            "timestamp_to": 1,
+        },
+    )
+    assert response.status_code == 400
 
-        # try reassing with both participant_id and speaker
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/speaker/assign",
-            json={
-                "participant": "123",
-                "speaker": 1,
-                "timestamp_from": 0,
-                "timestamp_to": 1,
-            },
-        )
-        assert response.status_code == 400
+    # try reassing with both participant_id and speaker
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/speaker/assign",
+        json={
+            "participant": "123",
+            "speaker": 1,
+            "timestamp_from": 0,
+            "timestamp_to": 1,
+        },
+    )
+    assert response.status_code == 400
 
-        # try reassing with non-existing participant_id
-        response = await ac.patch(
-            f"/transcripts/{transcript_id}/speaker/assign",
-            json={
-                "participant": "123",
-                "timestamp_from": 0,
-                "timestamp_to": 1,
-            },
-        )
-        assert response.status_code == 404
+    # try reassing with non-existing participant_id
+    response = await client.patch(
+        f"/transcripts/{transcript_id}/speaker/assign",
+        json={
+            "participant": "123",
+            "timestamp_from": 0,
+            "timestamp_to": 1,
+        },
+    )
+    assert response.status_code == 404

server/tests/test_transcripts_topics.py

@@ -1,26 +1,22 @@
 import pytest
-from httpx import AsyncClient
 
 
 @pytest.mark.asyncio
-async def test_transcript_topics(fake_transcript_with_topics):
-    from reflector.app import app
-
+async def test_transcript_topics(fake_transcript_with_topics, client):
     transcript_id = fake_transcript_with_topics.id
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        # check the transcript exists
-        response = await ac.get(f"/transcripts/{transcript_id}/topics")
-        assert response.status_code == 200
-        assert len(response.json()) == 2
-        topic_id = response.json()[0]["id"]
+    # check the transcript exists
+    response = await client.get(f"/transcripts/{transcript_id}/topics")
+    assert response.status_code == 200
+    assert len(response.json()) == 2
+    topic_id = response.json()[0]["id"]
 
-        # get words per speakers
-        response = await ac.get(
-            f"/transcripts/{transcript_id}/topics/{topic_id}/words-per-speaker"
-        )
-        assert response.status_code == 200
-        data = response.json()
-        assert len(data["words_per_speaker"]) == 1
-        assert data["words_per_speaker"][0]["speaker"] == 0
-        assert len(data["words_per_speaker"][0]["words"]) == 2
+    # get words per speakers
+    response = await client.get(
+        f"/transcripts/{transcript_id}/topics/{topic_id}/words-per-speaker"
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data["words_per_speaker"]) == 1
+    assert data["words_per_speaker"][0]["speaker"] == 0
+    assert len(data["words_per_speaker"][0]["words"]) == 2

server/tests/test_transcripts_translation.py

@@ -1,63 +1,53 @@
 import pytest
-from httpx import AsyncClient
 
 
 @pytest.mark.asyncio
-async def test_transcript_create_default_translation():
-    from reflector.app import app
+async def test_transcript_create_default_translation(client):
+    response = await client.post("/transcripts", json={"name": "test en"})
+    assert response.status_code == 200
+    assert response.json()["name"] == "test en"
+    assert response.json()["source_language"] == "en"
+    assert response.json()["target_language"] == "en"
+    tid = response.json()["id"]
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post("/transcripts", json={"name": "test en"})
-        assert response.status_code == 200
-        assert response.json()["name"] == "test en"
-        assert response.json()["source_language"] == "en"
-        assert response.json()["target_language"] == "en"
-        tid = response.json()["id"]
-
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["name"] == "test en"
-        assert response.json()["source_language"] == "en"
-        assert response.json()["target_language"] == "en"
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["name"] == "test en"
+    assert response.json()["source_language"] == "en"
+    assert response.json()["target_language"] == "en"
 
 
 @pytest.mark.asyncio
-async def test_transcript_create_en_fr_translation():
-    from reflector.app import app
+async def test_transcript_create_en_fr_translation(client):
+    response = await client.post(
+        "/transcripts", json={"name": "test en/fr", "target_language": "fr"}
+    )
+    assert response.status_code == 200
+    assert response.json()["name"] == "test en/fr"
+    assert response.json()["source_language"] == "en"
+    assert response.json()["target_language"] == "fr"
+    tid = response.json()["id"]
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post(
-            "/transcripts", json={"name": "test en/fr", "target_language": "fr"}
-        )
-        assert response.status_code == 200
-        assert response.json()["name"] == "test en/fr"
-        assert response.json()["source_language"] == "en"
-        assert response.json()["target_language"] == "fr"
-        tid = response.json()["id"]
-
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["name"] == "test en/fr"
-        assert response.json()["source_language"] == "en"
-        assert response.json()["target_language"] == "fr"
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["name"] == "test en/fr"
+    assert response.json()["source_language"] == "en"
+    assert response.json()["target_language"] == "fr"
 
 
 @pytest.mark.asyncio
-async def test_transcript_create_fr_en_translation():
-    from reflector.app import app
+async def test_transcript_create_fr_en_translation(client):
+    response = await client.post(
+        "/transcripts", json={"name": "test fr/en", "source_language": "fr"}
+    )
+    assert response.status_code == 200
+    assert response.json()["name"] == "test fr/en"
+    assert response.json()["source_language"] == "fr"
+    assert response.json()["target_language"] == "en"
+    tid = response.json()["id"]
 
-    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-        response = await ac.post(
-            "/transcripts", json={"name": "test fr/en", "source_language": "fr"}
-        )
-        assert response.status_code == 200
-        assert response.json()["name"] == "test fr/en"
-        assert response.json()["source_language"] == "fr"
-        assert response.json()["target_language"] == "en"
-        tid = response.json()["id"]
-
-        response = await ac.get(f"/transcripts/{tid}")
-        assert response.status_code == 200
-        assert response.json()["name"] == "test fr/en"
-        assert response.json()["source_language"] == "fr"
-        assert response.json()["target_language"] == "en"
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["name"] == "test fr/en"
+    assert response.json()["source_language"] == "fr"
+    assert response.json()["target_language"] == "en"

server/tests/test_transcripts_upload.py

@@ -1,7 +1,7 @@
 import asyncio
+import time
 
 import pytest
-from httpx import AsyncClient
 
 
 @pytest.mark.usefixtures("setup_database")
@@ -14,19 +14,16 @@ async def test_transcript_upload_file(
     dummy_processors,
     dummy_diarization,
     dummy_storage,
+    client,
 ):
-    from reflector.app import app
-
-    ac = AsyncClient(app=app, base_url="http://test/v1")
-
     # create a transcript
-    response = await ac.post("/transcripts", json={"name": "test"})
+    response = await client.post("/transcripts", json={"name": "test"})
     assert response.status_code == 200
     assert response.json()["status"] == "idle"
     tid = response.json()["id"]
 
     # upload mp3
-    response = await ac.post(
+    response = await client.post(
         f"/transcripts/{tid}/record/upload?chunk_number=0&total_chunks=1",
         files={
             "chunk": (
@@ -39,14 +36,18 @@ async def test_transcript_upload_file(
     assert response.status_code == 200
     assert response.json()["status"] == "ok"
 
-    # wait the processing to finish
-    while True:
+    # wait the processing to finish (max 10 minutes)
+    timeout_seconds = 600  # 10 minutes
+    start_time = time.monotonic()
+    while (time.monotonic() - start_time) < timeout_seconds:
         # fetch the transcript and check if it is ended
-        resp = await ac.get(f"/transcripts/{tid}")
+        resp = await client.get(f"/transcripts/{tid}")
         assert resp.status_code == 200
         if resp.json()["status"] in ("ended", "error"):
             break
         await asyncio.sleep(1)
+    else:
+        pytest.fail(f"Processing timed out after {timeout_seconds} seconds")
 
     # check the transcript is ended
     transcript = resp.json()
@@ -55,7 +56,7 @@ async def test_transcript_upload_file(
     assert transcript["title"] == "Llm Title"
 
     # check topics and transcript
-    response = await ac.get(f"/transcripts/{tid}/topics")
+    response = await client.get(f"/transcripts/{tid}/topics")
     assert response.status_code == 200
     assert len(response.json()) == 1
     assert "want to share" in response.json()[0]["transcript"]

server/tests/test_webvtt.py

@@ -0,0 +1,151 @@
+"""Tests for WebVTT utilities."""
+
+import pytest
+
+from reflector.processors.types import Transcript, Word, words_to_segments
+from reflector.utils.webvtt import topics_to_webvtt, words_to_webvtt
+
+
+class TestWordsToWebVTT:
+    """Test words_to_webvtt function with TDD approach."""
+
+    def test_empty_words_returns_empty_webvtt(self):
+        """Should return empty WebVTT structure for empty words list."""
+
+        result = words_to_webvtt([])
+
+        assert "WEBVTT" in result
+        assert result.strip() == "WEBVTT"
+
+    def test_single_word_creates_single_caption(self):
+        """Should create one caption for a single word."""
+
+        words = [Word(text="Hello", start=0.0, end=1.0, speaker=0)]
+        result = words_to_webvtt(words)
+
+        assert "WEBVTT" in result
+        assert "00:00:00.000 --> 00:00:01.000" in result
+        assert "Hello" in result
+        assert "<v Speaker0>" in result
+
+    def test_multiple_words_same_speaker_groups_properly(self):
+        """Should group consecutive words from same speaker."""
+
+        words = [
+            Word(text="Hello", start=0.0, end=0.5, speaker=0),
+            Word(text=" world", start=0.5, end=1.0, speaker=0),
+        ]
+        result = words_to_webvtt(words)
+
+        assert "WEBVTT" in result
+        assert "Hello world" in result
+        assert "<v Speaker0>" in result
+
+    def test_speaker_change_creates_new_caption(self):
+        """Should create new caption when speaker changes."""
+
+        words = [
+            Word(text="Hello", start=0.0, end=0.5, speaker=0),
+            Word(text="Hi", start=0.6, end=1.0, speaker=1),
+        ]
+        result = words_to_webvtt(words)
+
+        lines = result.split("\n")
+        assert "<v Speaker0>" in result
+        assert "<v Speaker1>" in result
+        assert "Hello" in result
+        assert "Hi" in result
+
+    def test_punctuation_creates_segment_boundary(self):
+        """Should respect punctuation boundaries from segmentation logic."""
+
+        words = [
+            Word(text="Hello.", start=0.0, end=0.5, speaker=0),
+            Word(text=" How", start=0.6, end=1.0, speaker=0),
+            Word(text=" are", start=1.0, end=1.3, speaker=0),
+            Word(text=" you?", start=1.3, end=1.8, speaker=0),
+        ]
+        result = words_to_webvtt(words)
+
+        assert "WEBVTT" in result
+        assert "<v Speaker0>" in result
+
+
+class TestTopicsToWebVTT:
+    """Test topics_to_webvtt function."""
+
+    def test_empty_topics_returns_empty_webvtt(self):
+        """Should handle empty topics list."""
+
+        result = topics_to_webvtt([])
+        assert "WEBVTT" in result
+        assert result.strip() == "WEBVTT"
+
+    def test_extracts_words_from_topics(self):
+        """Should extract all words from topics in sequence."""
+
+        class MockTopic:
+            def __init__(self, words):
+                self.words = words
+
+        topics = [
+            MockTopic(
+                [
+                    Word(text="First", start=0.0, end=0.5, speaker=1),
+                    Word(text="Second", start=1.0, end=1.5, speaker=0),
+                ]
+            )
+        ]
+
+        result = topics_to_webvtt(topics)
+
+        assert "WEBVTT" in result
+        first_pos = result.find("First")
+        second_pos = result.find("Second")
+        assert first_pos < second_pos
+
+    def test_non_sequential_topics_raises_assertion(self):
+        """Should raise assertion error when words are not in chronological sequence."""
+
+        class MockTopic:
+            def __init__(self, words):
+                self.words = words
+
+        topics = [
+            MockTopic(
+                [
+                    Word(text="Second", start=1.0, end=1.5, speaker=0),
+                    Word(text="First", start=0.0, end=0.5, speaker=1),
+                ]
+            )
+        ]
+
+        with pytest.raises(AssertionError) as exc_info:
+            topics_to_webvtt(topics)
+
+        assert "Words are not in sequence" in str(exc_info.value)
+        assert "Second and First" in str(exc_info.value)
+
+
+class TestTranscriptWordsToSegments:
+    """Test static words_to_segments method (TDD for making it static)."""
+
+    def test_static_method_exists(self):
+        """Should have static words_to_segments method."""
+        words = [Word(text="Hello", start=0.0, end=1.0, speaker=0)]
+        segments = words_to_segments(words)
+
+        assert isinstance(segments, list)
+        assert len(segments) == 1
+        assert segments[0].text == "Hello"
+        assert segments[0].speaker == 0
+
+    def test_backward_compatibility(self):
+        """Should maintain backward compatibility with instance method."""
+        words = [Word(text="Hello", start=0.0, end=1.0, speaker=0)]
+        transcript = Transcript(words=words)
+
+        segments = transcript.as_segments()
+        assert isinstance(segments, list)
+        assert len(segments) == 1
+        assert segments[0].text == "Hello"

server/tests/test_webvtt_implementation.py

@@ -0,0 +1,34 @@
+"""Test WebVTT auto-update functionality and edge cases."""
+
+import pytest
+
+from reflector.db.transcripts import (
+    TranscriptController,
+)
+
+
+@pytest.mark.asyncio
+class TestWebVTTAutoUpdateImplementation:
+    async def test_handle_topics_update_handles_dict_conversion(self):
+        """
+        Verify that _handle_topics_update() properly converts dict data to TranscriptTopic objects.
+        """
+        values = {
+            "topics": [
+                {
+                    "id": "topic1",
+                    "title": "Test",
+                    "summary": "Test",
+                    "timestamp": 0.0,
+                    "words": [
+                        {"text": "Hello", "start": 0.0, "end": 1.0, "speaker": 0}
+                    ],
+                }
+            ]
+        }
+
+        updated_values = TranscriptController._handle_topics_update(values)
+
+        assert "webvtt" in updated_values
+        assert updated_values["webvtt"] is not None
+        assert "WEBVTT" in updated_values["webvtt"]

server/tests/test_webvtt_integration.py

@@ -0,0 +1,234 @@
+"""Integration tests for WebVTT auto-update functionality in Transcript model."""
+
+import pytest
+
+from reflector.db import get_database
+from reflector.db.transcripts import (
+    SourceKind,
+    TranscriptController,
+    TranscriptTopic,
+    transcripts,
+)
+from reflector.processors.types import Word
+
+
+@pytest.mark.asyncio
+class TestWebVTTAutoUpdate:
+    """Test that WebVTT field auto-updates when Transcript is created or modified."""
+
+    async def test_webvtt_not_updated_on_transcript_creation_without_topics(self):
+        """WebVTT should be None when creating transcript without topics."""
+        controller = TranscriptController()
+
+        transcript = await controller.add(
+            name="Test Transcript",
+            source_kind=SourceKind.FILE,
+        )
+
+        try:
+            result = await get_database().fetch_one(
+                transcripts.select().where(transcripts.c.id == transcript.id)
+            )
+
+            assert result is not None
+            assert result["webvtt"] is None
+        finally:
+            await controller.remove_by_id(transcript.id)
+
+    async def test_webvtt_updated_on_upsert_topic(self):
+        """WebVTT should update when upserting topics via upsert_topic method."""
+        controller = TranscriptController()
+
+        transcript = await controller.add(
+            name="Test Transcript",
+            source_kind=SourceKind.FILE,
+        )
+
+        try:
+            topic = TranscriptTopic(
+                id="topic1",
+                title="Test Topic",
+                summary="Test summary",
+                timestamp=0.0,
+                words=[
+                    Word(text="Hello", start=0.0, end=0.5, speaker=0),
+                    Word(text=" world", start=0.5, end=1.0, speaker=0),
+                ],
+            )
+
+            await controller.upsert_topic(transcript, topic)
+
+            result = await get_database().fetch_one(
+                transcripts.select().where(transcripts.c.id == transcript.id)
+            )
+
+            assert result is not None
+            webvtt = result["webvtt"]
+
+            assert webvtt is not None
+            assert "WEBVTT" in webvtt
+            assert "Hello world" in webvtt
+            assert "<v Speaker0>" in webvtt
+
+        finally:
+            await controller.remove_by_id(transcript.id)
+
+    async def test_webvtt_updated_on_direct_topics_update(self):
+        """WebVTT should update when updating topics field directly."""
+        controller = TranscriptController()
+
+        transcript = await controller.add(
+            name="Test Transcript",
+            source_kind=SourceKind.FILE,
+        )
+
+        try:
+            topics_data = [
+                {
+                    "id": "topic1",
+                    "title": "First Topic",
+                    "summary": "First sentence test",
+                    "timestamp": 0.0,
+                    "words": [
+                        {"text": "First", "start": 0.0, "end": 0.5, "speaker": 0},
+                        {"text": " sentence", "start": 0.5, "end": 1.0, "speaker": 0},
+                    ],
+                }
+            ]
+
+            await controller.update(transcript, {"topics": topics_data})
+
+            # Fetch from DB
+            result = await get_database().fetch_one(
+                transcripts.select().where(transcripts.c.id == transcript.id)
+            )
+
+            assert result is not None
+            webvtt = result["webvtt"]
+
+            assert webvtt is not None
+            assert "WEBVTT" in webvtt
+            assert "First sentence" in webvtt
+
+        finally:
+            await controller.remove_by_id(transcript.id)
+
+    async def test_webvtt_updated_manually_with_handle_topics_update(self):
+        """Test that _handle_topics_update works when called manually."""
+        controller = TranscriptController()
+
+        transcript = await controller.add(
+            name="Test Transcript",
+            source_kind=SourceKind.FILE,
+        )
+
+        try:
+            topic1 = TranscriptTopic(
+                id="topic1",
+                title="Topic 1",
+                summary="Manual test",
+                timestamp=0.0,
+                words=[
+                    Word(text="Manual", start=0.0, end=0.5, speaker=0),
+                    Word(text=" test", start=0.5, end=1.0, speaker=0),
+                ],
+            )
+
+            transcript.upsert_topic(topic1)
+
+            values = {"topics": transcript.topics_dump()}
+
+            await controller.update(transcript, values)
+
+            # Fetch from DB
+            result = await get_database().fetch_one(
+                transcripts.select().where(transcripts.c.id == transcript.id)
+            )
+
+            assert result is not None
+            webvtt = result["webvtt"]
+
+            assert webvtt is not None
+            assert "WEBVTT" in webvtt
+            assert "Manual test" in webvtt
+            assert "<v Speaker0>" in webvtt
+
+        finally:
+            await controller.remove_by_id(transcript.id)
+
+    async def test_webvtt_update_with_non_sequential_topics_fails(self):
+        """Test that non-sequential topics raise assertion error."""
+        controller = TranscriptController()
+
+        transcript = await controller.add(
+            name="Test Transcript",
+            source_kind=SourceKind.FILE,
+        )
+
+        try:
+            topic1 = TranscriptTopic(
+                id="topic1",
+                title="Bad Topic",
+                summary="Bad order test",
+                timestamp=1.0,
+                words=[
+                    Word(text="Second", start=2.0, end=2.5, speaker=0),
+                    Word(text="First", start=1.0, end=1.5, speaker=0),
+                ],
+            )
+
+            transcript.upsert_topic(topic1)
+            values = {"topics": transcript.topics_dump()}
+
+            with pytest.raises(AssertionError) as exc_info:
+                TranscriptController._handle_topics_update(values)
+
+            assert "Words are not in sequence" in str(exc_info.value)
+
+        finally:
+            await controller.remove_by_id(transcript.id)
+
+    async def test_multiple_speakers_in_webvtt(self):
+        """Test WebVTT generation with multiple speakers."""
+        controller = TranscriptController()
+
+        transcript = await controller.add(
+            name="Test Transcript",
+            source_kind=SourceKind.FILE,
+        )
+
+        try:
+            topic = TranscriptTopic(
+                id="topic1",
+                title="Multi Speaker",
+                summary="Multi speaker test",
+                timestamp=0.0,
+                words=[
+                    Word(text="Hello", start=0.0, end=0.5, speaker=0),
+                    Word(text="Hi", start=1.0, end=1.5, speaker=1),
+                    Word(text="Goodbye", start=2.0, end=2.5, speaker=0),
+                ],
+            )
+
+            transcript.upsert_topic(topic)
+            values = {"topics": transcript.topics_dump()}
+
+            await controller.update(transcript, values)
+
+            # Fetch from DB
+            result = await get_database().fetch_one(
+                transcripts.select().where(transcripts.c.id == transcript.id)
+            )
+
+            assert result is not None
+            webvtt = result["webvtt"]
+
+            assert webvtt is not None
+            assert "<v Speaker0>" in webvtt
+            assert "<v Speaker1>" in webvtt
+            assert "Hello" in webvtt
+            assert "Hi" in webvtt
+            assert "Goodbye" in webvtt
+
+        finally:
+            await controller.remove_by_id(transcript.id)

server/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 2
+revision = 3
 requires-python = ">=3.11, <3.13"
 resolution-markers = [
     "python_full_version >= '3.12'",
@@ -238,6 +238,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload-time = "2025-03-17T00:02:52.713Z" },
 ]
 
+[[package]]
+name = "asgi-lifespan"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "sniffio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6a/da/e7908b54e0f8043725a990bf625f2041ecf6bfe8eb7b19407f1c00b630f7/asgi-lifespan-2.1.0.tar.gz", hash = "sha256:5e2effaf0bfe39829cf2d64e7ecc47c7d86d676a6599f7afba378c31f5e3a308", size = 15627, upload-time = "2023-03-28T17:35:49.126Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2f/f5/c36551e93acba41a59939ae6a0fb77ddb3f2e8e8caa716410c65f7341f72/asgi_lifespan-2.1.0-py3-none-any.whl", hash = "sha256:ed840706680e28428c01e14afb3875d7d76d3206f3d5b2f2294e059b5c23804f", size = 10895, upload-time = "2023-03-28T17:35:47.772Z" },
+]
+
 [[package]]
 name = "async-timeout"
 version = "5.0.1"
@@ -1151,6 +1163,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f0/0f/310fb31e39e2d734ccaa2c0fb981ee41f7bd5056ce9bc29b2248bd569169/humanfriendly-10.0-py2.py3-none-any.whl", hash = "sha256:1697e1a8a8f550fd43c2865cd84542fc175a61dcb779b6fee18cf6b6ccba1477", size = 86794, upload-time = "2021-09-17T21:40:39.897Z" },
 ]
 
+[[package]]
+name = "icalendar"
+version = "6.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/08/13/e5899c916dcf1343ea65823eb7278d3e1a1d679f383f6409380594b5f322/icalendar-6.3.1.tar.gz", hash = "sha256:a697ce7b678072941e519f2745704fc29d78ef92a2dc53d9108ba6a04aeba466", size = 177169, upload-time = "2025-05-20T07:42:50.683Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6c/25/b5fc00e85d2dfaf5c806ac8b5f1de072fa11630c5b15b4ae5bbc228abd51/icalendar-6.3.1-py3-none-any.whl", hash = "sha256:7ea1d1b212df685353f74cdc6ec9646bf42fa557d1746ea645ce8779fdfbecdd", size = 242349, upload-time = "2025-05-20T07:42:48.589Z" },
+]
+
 [[package]]
 name = "idna"
 version = "3.10"
@@ -2415,6 +2440,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/bc/16/4ea354101abb1287856baa4af2732be351c7bee728065aed451b678153fd/pytest_cov-6.2.1-py3-none-any.whl", hash = "sha256:f5bc4c23f42f1cdd23c70b1dab1bbaef4fc505ba950d53e0081d0730dd7e86d5", size = 24644, upload-time = "2025-06-12T10:47:45.932Z" },
 ]
 
+[[package]]
+name = "pytest-docker"
+version = "3.2.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/79/75/285187953062ebe38108e77a7919c75e157943fa3513371c88e27d3df7b2/pytest_docker-3.2.3.tar.gz", hash = "sha256:26a1c711d99ef01e86e7c9c007f69641552c1554df4fccb065b35581cca24206", size = 13452, upload-time = "2025-07-04T07:46:17.647Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c5/c7/e057e0d1de611ce1bbb26cccf07ddf56eb30a6f6a03aa512a09dac356e03/pytest_docker-3.2.3-py3-none-any.whl", hash = "sha256:f973c35e6f2b674c8fc87e8b3354b02c15866a21994c0841a338c240a05de1eb", size = 8585, upload-time = "2025-07-04T07:46:16.439Z" },
+]
+
 [[package]]
 name = "pytest-docker-tools"
 version = "3.1.9"
@@ -2630,13 +2668,13 @@ dependencies = [
     { name = "aiortc" },
     { name = "alembic" },
     { name = "av" },
-    { name = "black" },
     { name = "celery" },
     { name = "databases", extra = ["aiosqlite", "asyncpg"] },
     { name = "fastapi", extra = ["standard"] },
     { name = "fastapi-pagination" },
     { name = "faster-whisper" },
     { name = "httpx" },
+    { name = "icalendar" },
     { name = "jsonschema" },
     { name = "llama-index" },
     { name = "llama-index-llms-openai-like" },
@@ -2660,6 +2698,7 @@ dependencies = [
     { name = "structlog" },
     { name = "transformers" },
     { name = "uvicorn", extra = ["standard"] },
+    { name = "webvtt-py" },
 ]
 
 [package.dev-dependencies]
@@ -2678,12 +2717,14 @@ evaluation = [
     { name = "tqdm" },
 ]
 tests = [
+    { name = "asgi-lifespan" },
     { name = "httpx-ws" },
     { name = "pytest" },
     { name = "pytest-aiohttp" },
     { name = "pytest-asyncio" },
     { name = "pytest-celery" },
     { name = "pytest-cov" },
+    { name = "pytest-docker" },
     { name = "pytest-httpx" },
 ]
 
@@ -2694,13 +2735,13 @@ requires-dist = [
     { name = "aiortc", specifier = ">=1.5.0" },
     { name = "alembic", specifier = ">=1.11.3" },
     { name = "av", specifier = ">=10.0.0" },
-    { name = "black", specifier = "==24.1.1" },
     { name = "celery", specifier = ">=5.3.4" },
     { name = "databases", extras = ["aiosqlite", "asyncpg"], specifier = ">=0.7.0" },
     { name = "fastapi", extras = ["standard"], specifier = ">=0.100.1" },
     { name = "fastapi-pagination", specifier = ">=0.12.6" },
     { name = "faster-whisper", specifier = ">=0.10.0" },
     { name = "httpx", specifier = ">=0.24.1" },
+    { name = "icalendar", specifier = ">=6.0.0" },
     { name = "jsonschema", specifier = ">=4.23.0" },
     { name = "llama-index", specifier = ">=0.12.52" },
     { name = "llama-index-llms-openai-like", specifier = ">=0.4.0" },
@@ -2724,6 +2765,7 @@ requires-dist = [
     { name = "structlog", specifier = ">=23.1.0" },
     { name = "transformers", specifier = ">=4.36.2" },
     { name = "uvicorn", extras = ["standard"], specifier = ">=0.23.1" },
+    { name = "webvtt-py", specifier = ">=0.5.0" },
 ]
 
 [package.metadata.requires-dev]
@@ -2740,12 +2782,14 @@ evaluation = [
     { name = "tqdm", specifier = ">=4.66.0" },
 ]
 tests = [
+    { name = "asgi-lifespan", specifier = ">=2.1.0" },
     { name = "httpx-ws", specifier = ">=0.4.1" },
     { name = "pytest", specifier = ">=7.4.0" },
     { name = "pytest-aiohttp", specifier = ">=1.0.4" },
     { name = "pytest-asyncio", specifier = ">=0.21.1" },
     { name = "pytest-celery", specifier = ">=0.0.0" },
     { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-docker", specifier = ">=3.2.3" },
     { name = "pytest-httpx", specifier = ">=0.23.1" },
 ]
 
@@ -3466,6 +3510,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
 ]
 
+[[package]]
+name = "webvtt-py"
+version = "0.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5e/f6/7c9c964681fb148e0293e6860108d378e09ccab2218f9063fd3eb87f840a/webvtt-py-0.5.1.tar.gz", hash = "sha256:2040dd325277ddadc1e0c6cc66cbc4a1d9b6b49b24c57a0c3364374c3e8a3dc1", size = 55128, upload-time = "2024-05-30T13:40:17.189Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f3/ed/aad7e0f5a462d679f7b4d2e0d8502c3096740c883b5bbed5103146480937/webvtt_py-0.5.1-py3-none-any.whl", hash = "sha256:9d517d286cfe7fc7825e9d4e2079647ce32f5678eb58e39ef544ffbb932610b7", size = 19802, upload-time = "2024-05-30T13:40:14.661Z" },
+]
+
 [[package]]
 name = "win32-setctime"
 version = "1.2.0"

www/.gitignore

@@ -44,3 +44,6 @@ config.ts
 
 # openapi logs
 openapi-ts-error-*.log
+
+# pnpm
+.pnpm-store

www/Dockerfile

@@ -1,21 +1,16 @@
 #syntax=docker/dockerfile:1.4
-FROM node:18-alpine AS base
+FROM node:22-alpine AS base
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME:$PATH"
+RUN corepack enable
 
 # Install dependencies only when needed
 FROM base AS deps
 # Check https://github.com/nodejs/docker-node/tree/b4117f9333da4138b03a546ec926ef50a31506c3#nodealpine to understand why libc6-compat might be needed.
 RUN apk add --no-cache libc6-compat
 WORKDIR /app
-
-# Install dependencies based on the preferred package manager
-COPY --link package.json yarn.lock* package-lock.json* pnpm-lock.yaml* ./
-RUN \
-  if [ -f yarn.lock ]; then yarn --frozen-lockfile; \
-  elif [ -f package-lock.json ]; then npm ci; \
-  elif [ -f pnpm-lock.yaml ]; then yarn global add pnpm && pnpm i --frozen-lockfile; \
-  else echo "Lockfile not found." && exit 1; \
-  fi
-
+COPY --link package.json pnpm-lock.yaml* ./
+RUN --mount=type=cache,id=pnpm,target=/pnpm/store pnpm install --frozen-lockfile
 
 # Rebuild the source code only when needed
 FROM base AS builder
@@ -29,7 +24,7 @@ COPY --link  . .
 ENV NEXT_TELEMETRY_DISABLED 1
 
 # If using npm comment out above and use below instead
-RUN yarn build
+RUN pnpm build
 # RUN npm run build
 
 # Production image, copy all the files and run next
@@ -41,8 +36,8 @@ ENV NODE_ENV production
 # ENV NEXT_TELEMETRY_DISABLED 1
 
 RUN \
-  addgroup --system --gid 1001 nodejs; \
-  adduser --system --uid 1001 nextjs
+    addgroup --system --gid 1001 nodejs; \
+    adduser --system --uid 1001 nextjs
 
 COPY --from=builder --link /app/public ./public
 

www/app/(app)/browse/_components/DeleteTranscriptDialog.tsx

@@ -1,12 +1,15 @@
 import React from "react";
-import { Button } from "@chakra-ui/react";
-// import { Dialog } from "@chakra-ui/react";
+import { Button, Dialog, Text } from "@chakra-ui/react";
 
 interface DeleteTranscriptDialogProps {
   isOpen: boolean;
   onClose: () => void;
   onConfirm: () => void;
   cancelRef: React.RefObject<any>;
+  isLoading?: boolean;
+  title?: string;
+  date?: string;
+  source?: string;
 }
 
 export default function DeleteTranscriptDialog({
@@ -14,35 +17,65 @@ export default function DeleteTranscriptDialog({
   onClose,
   onConfirm,
   cancelRef,
+  isLoading,
+  title,
+  date,
+  source,
 }: DeleteTranscriptDialogProps) {
-  // Temporarily return null to fix import issues
-  return null;
-
-  /* return (
+  return (
     <Dialog.Root
       open={isOpen}
-      onOpenChange={(e) => !e.open && onClose()}
+      onOpenChange={(e) => {
+        if (!e.open) onClose();
+      }}
       initialFocusEl={() => cancelRef.current}
     >
       <Dialog.Backdrop />
       <Dialog.Positioner>
         <Dialog.Content>
           <Dialog.Header fontSize="lg" fontWeight="bold">
-            Delete Transcript
+            Delete transcript
           </Dialog.Header>
           <Dialog.Body>
-            Are you sure? You can't undo this action afterwards.
+            Are you sure you want to delete this transcript? This action cannot
+            be undone.
+            {title && (
+              <Text mt={3} fontWeight="600">
+                {title}
+              </Text>
+            )}
+            {date && (
+              <Text color="gray.600" fontSize="sm">
+                Date: {date}
+              </Text>
+            )}
+            {source && (
+              <Text color="gray.600" fontSize="sm">
+                Source: {source}
+              </Text>
+            )}
           </Dialog.Body>
           <Dialog.Footer>
-            <Button ref={cancelRef} onClick={onClose}>
+            <Button
+              ref={cancelRef as any}
+              onClick={onClose}
+              disabled={!!isLoading}
+              variant="outline"
+              colorPalette="gray"
+            >
               Cancel
             </Button>
-            <Button colorPalette="red" onClick={onConfirm} ml={3}>
+            <Button
+              colorPalette="red"
+              onClick={onConfirm}
+              ml={3}
+              disabled={!!isLoading}
+            >
               Delete
             </Button>
           </Dialog.Footer>
         </Dialog.Content>
       </Dialog.Positioner>
     </Dialog.Root>
-  ); */
+  );
 }

www/app/(app)/browse/page.tsx

@@ -13,6 +13,7 @@ import SearchBar from "./_components/SearchBar";
 import TranscriptTable from "./_components/TranscriptTable";
 import TranscriptCards from "./_components/TranscriptCards";
 import DeleteTranscriptDialog from "./_components/DeleteTranscriptDialog";
+import { formatLocalDate } from "../../lib/time";
 
 export default function TranscriptBrowser() {
   const [selectedSourceKind, setSelectedSourceKind] =
@@ -96,26 +97,28 @@ export default function TranscriptBrowser() {
 
   const onCloseDeletion = () => setTranscriptToDeleteId(undefined);
 
-  const handleDeleteTranscript = (transcriptId) => (e) => {
-    e.stopPropagation();
-    if (api && !deletionLoading) {
-      setDeletionLoading(true);
-      api
-        .v1TranscriptDelete({ transcriptId })
-        .then(() => {
-          refetch();
-          setDeletionLoading(false);
-          onCloseDeletion();
-          setDeletedItemIds((deletedItemIds) => [
-            deletedItemIds,
-            ...transcriptId,
-          ]);
-        })
-        .catch((err) => {
-          setDeletionLoading(false);
-          setError(err, "There was an error deleting the transcript");
-        });
-    }
+  const confirmDeleteTranscript = (transcriptId: string) => {
+    if (!api || deletionLoading) return;
+    setDeletionLoading(true);
+    api
+      .v1TranscriptDelete({ transcriptId })
+      .then(() => {
+        refetch();
+        setDeletionLoading(false);
+        onCloseDeletion();
+        setDeletedItemIds((prev) =>
+          prev ? [...prev, transcriptId] : [transcriptId],
+        );
+      })
+      .catch((err) => {
+        setDeletionLoading(false);
+        setError(err, "There was an error deleting the transcript");
+      });
+  };
+
+  const handleDeleteTranscript = (transcriptId: string) => (e: any) => {
+    e?.stopPropagation?.();
+    setTranscriptToDeleteId(transcriptId);
   };
 
   const handleProcessTranscript = (transcriptId) => (e) => {
@@ -137,6 +140,19 @@ export default function TranscriptBrowser() {
     }
   };
 
+  const transcriptToDelete = response?.items?.find(
+    (i) => i.id === transcriptToDeleteId,
+  );
+  const dialogTitle = transcriptToDelete?.title || "Unnamed Transcript";
+  const dialogDate = transcriptToDelete?.created_at
+    ? formatLocalDate(transcriptToDelete.created_at)
+    : undefined;
+  const dialogSource = transcriptToDelete
+    ? transcriptToDelete.source_kind === "room"
+      ? transcriptToDelete.room_name || undefined
+      : transcriptToDelete.source_kind
+    : undefined;
+
   return (
     <Flex
       flexDir="column"
@@ -197,8 +213,14 @@ export default function TranscriptBrowser() {
       <DeleteTranscriptDialog
         isOpen={!!transcriptToDeleteId}
         onClose={onCloseDeletion}
-        onConfirm={() => handleDeleteTranscript(transcriptToDeleteId)(null)}
+        onConfirm={() =>
+          transcriptToDeleteId && confirmDeleteTranscript(transcriptToDeleteId)
+        }
         cancelRef={cancelRef}
+        isLoading={deletionLoading}
+        title={dialogTitle}
+        date={dialogDate}
+        source={dialogSource}
       />
     </Flex>
   );

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

@@ -0,0 +1,258 @@
+import {
+  VStack,
+  HStack,
+  Field,
+  Input,
+  Select,
+  Checkbox,
+  Button,
+  Text,
+  Alert,
+  AlertIcon,
+  AlertTitle,
+  Badge,
+  createListCollection,
+  Spinner,
+} from "@chakra-ui/react";
+import { useState } from "react";
+import { FaSync, FaCheckCircle, FaExclamationCircle } from "react-icons/fa";
+import useApi from "../../../lib/useApi";
+
+interface ICSSettingsProps {
+  roomId?: string;
+  roomName?: string;
+  icsUrl?: string;
+  icsEnabled?: boolean;
+  icsFetchInterval?: number;
+  icsLastSync?: string;
+  icsLastEtag?: string;
+  onChange: (settings: Partial<ICSSettingsData>) => void;
+  isOwner?: boolean;
+}
+
+export interface ICSSettingsData {
+  ics_url: string;
+  ics_enabled: boolean;
+  ics_fetch_interval: number;
+}
+
+const fetchIntervalOptions = [
+  { label: "1 minute", value: "1" },
+  { label: "5 minutes", value: "5" },
+  { label: "10 minutes", value: "10" },
+  { label: "30 minutes", value: "30" },
+  { label: "1 hour", value: "60" },
+];
+
+export default function ICSSettings({
+  roomId,
+  roomName,
+  icsUrl = "",
+  icsEnabled = false,
+  icsFetchInterval = 5,
+  icsLastSync,
+  icsLastEtag,
+  onChange,
+  isOwner = true,
+}: ICSSettingsProps) {
+  const [syncStatus, setSyncStatus] = useState<
+    "idle" | "syncing" | "success" | "error"
+  >("idle");
+  const [syncMessage, setSyncMessage] = useState<string>("");
+  const [testResult, setTestResult] = useState<string>("");
+  const api = useApi();
+
+  const fetchIntervalCollection = createListCollection({
+    items: fetchIntervalOptions,
+  });
+
+  const handleTestConnection = async () => {
+    if (!api || !icsUrl || !roomName) return;
+
+    setSyncStatus("syncing");
+    setTestResult("");
+
+    try {
+      // First update the room with the ICS URL
+      await api.v1RoomsPartialUpdate({
+        roomId: roomId || roomName,
+        requestBody: {
+          ics_url: icsUrl,
+          ics_enabled: true,
+          ics_fetch_interval: icsFetchInterval,
+        },
+      });
+
+      // Then trigger a sync
+      const result = await api.v1RoomsTriggerIcsSync({ roomName });
+
+      if (result.status === "success") {
+        setSyncStatus("success");
+        setTestResult(
+          `Successfully synced! Found ${result.events_found} events.`,
+        );
+      } else {
+        setSyncStatus("error");
+        setTestResult(result.error || "Sync failed");
+      }
+    } catch (err: any) {
+      setSyncStatus("error");
+      setTestResult(err.body?.detail || "Failed to test ICS connection");
+    }
+  };
+
+  const handleManualSync = async () => {
+    if (!api || !roomName) return;
+
+    setSyncStatus("syncing");
+    setSyncMessage("");
+
+    try {
+      const result = await api.v1RoomsTriggerIcsSync({ roomName });
+
+      if (result.status === "success") {
+        setSyncStatus("success");
+        setSyncMessage(
+          `Sync complete! Found ${result.events_found} events, ` +
+            `created ${result.events_created}, updated ${result.events_updated}.`,
+        );
+      } else {
+        setSyncStatus("error");
+        setSyncMessage(result.error || "Sync failed");
+      }
+    } catch (err: any) {
+      setSyncStatus("error");
+      setSyncMessage(err.body?.detail || "Failed to sync calendar");
+    }
+
+    // Clear status after 5 seconds
+    setTimeout(() => {
+      setSyncStatus("idle");
+      setSyncMessage("");
+    }, 5000);
+  };
+
+  if (!isOwner) {
+    return null; // ICS settings only visible to room owner
+  }
+
+  return (
+    <VStack spacing={4} align="stretch" mt={6}>
+      <Text fontWeight="semibold" fontSize="lg">
+        Calendar Integration (ICS)
+      </Text>
+
+      <Field.Root>
+        <Checkbox.Root
+          checked={icsEnabled}
+          onCheckedChange={(e) => onChange({ ics_enabled: e.checked })}
+        >
+          <Checkbox.HiddenInput />
+          <Checkbox.Control>
+            <Checkbox.Indicator />
+          </Checkbox.Control>
+          <Checkbox.Label>Enable ICS calendar sync</Checkbox.Label>
+        </Checkbox.Root>
+      </Field.Root>
+
+      {icsEnabled && (
+        <>
+          <Field.Root>
+            <Field.Label>ICS Calendar URL</Field.Label>
+            <Input
+              placeholder="https://calendar.google.com/calendar/ical/..."
+              value={icsUrl}
+              onChange={(e) => onChange({ ics_url: e.target.value })}
+            />
+            <Field.HelperText>
+              Enter the ICS URL from Google Calendar, Outlook, or other calendar
+              services
+            </Field.HelperText>
+          </Field.Root>
+
+          <Field.Root>
+            <Field.Label>Sync Interval</Field.Label>
+            <Select.Root
+              collection={fetchIntervalCollection}
+              value={[icsFetchInterval.toString()]}
+              onValueChange={(details) => {
+                const value = parseInt(details.value[0]);
+                onChange({ ics_fetch_interval: value });
+              }}
+            >
+              <Select.Trigger>
+                <Select.ValueText />
+              </Select.Trigger>
+              <Select.Content>
+                {fetchIntervalOptions.map((option) => (
+                  <Select.Item key={option.value} item={option}>
+                    {option.label}
+                  </Select.Item>
+                ))}
+              </Select.Content>
+            </Select.Root>
+            <Field.HelperText>
+              How often to check for calendar updates
+            </Field.HelperText>
+          </Field.Root>
+
+          {icsUrl && (
+            <HStack spacing={3}>
+              <Button
+                size="sm"
+                variant="outline"
+                onClick={handleTestConnection}
+                disabled={syncStatus === "syncing"}
+                leftIcon={
+                  syncStatus === "syncing" ? <Spinner size="sm" /> : undefined
+                }
+              >
+                Test Connection
+              </Button>
+
+              {roomName && icsLastSync && (
+                <Button
+                  size="sm"
+                  variant="outline"
+                  onClick={handleManualSync}
+                  disabled={syncStatus === "syncing"}
+                  leftIcon={<FaSync />}
+                >
+                  Sync Now
+                </Button>
+              )}
+            </HStack>
+          )}
+
+          {testResult && (
+            <Alert status={syncStatus === "success" ? "success" : "error"}>
+              <AlertIcon />
+              <Text fontSize="sm">{testResult}</Text>
+            </Alert>
+          )}
+
+          {syncMessage && (
+            <Alert status={syncStatus === "success" ? "success" : "error"}>
+              <AlertIcon />
+              <Text fontSize="sm">{syncMessage}</Text>
+            </Alert>
+          )}
+
+          {icsLastSync && (
+            <HStack spacing={4} fontSize="sm" color="gray.600">
+              <HStack>
+                <FaCheckCircle color="green" />
+                <Text>Last sync: {new Date(icsLastSync).toLocaleString()}</Text>
+              </HStack>
+              {icsLastEtag && (
+                <Badge colorScheme="blue" fontSize="xs">
+                  ETag: {icsLastEtag.slice(0, 8)}...
+                </Badge>
+              )}
+            </HStack>
+          )}
+        </>
+      )}
+    </VStack>
+  );
+}

www/app/(app)/rooms/page.tsx

@@ -19,6 +19,7 @@ import useApi from "../../lib/useApi";
 import useRoomList from "./useRoomList";
 import { ApiError, Room } from "../../api";
 import { RoomList } from "./_components/RoomList";
+import ICSSettings from "./_components/ICSSettings";
 
 interface SelectOption {
   label: string;
@@ -54,6 +55,9 @@ const roomInitialState = {
   recordingType: "cloud",
   recordingTrigger: "automatic-2nd-participant",
   isShared: false,
+  icsUrl: "",
+  icsEnabled: false,
+  icsFetchInterval: 5,
 };
 
 export default function RoomsList() {
@@ -170,6 +174,9 @@ export default function RoomsList() {
         recording_type: room.recordingType,
         recording_trigger: room.recordingTrigger,
         is_shared: room.isShared,
+        ics_url: room.icsUrl,
+        ics_enabled: room.icsEnabled,
+        ics_fetch_interval: room.icsFetchInterval,
       };
 
       if (isEditing) {
@@ -215,6 +222,9 @@ export default function RoomsList() {
       recordingType: roomData.recording_type,
       recordingTrigger: roomData.recording_trigger,
       isShared: roomData.is_shared,
+      icsUrl: roomData.ics_url || "",
+      icsEnabled: roomData.ics_enabled || false,
+      icsFetchInterval: roomData.ics_fetch_interval || 5,
     });
     setEditRoomId(roomId);
     setIsEditing(true);
@@ -553,6 +563,32 @@ export default function RoomsList() {
                   <Checkbox.Label>Shared room</Checkbox.Label>
                 </Checkbox.Root>
               </Field.Root>
+
+              <ICSSettings
+                roomId={editRoomId}
+                roomName={room.name}
+                icsUrl={room.icsUrl}
+                icsEnabled={room.icsEnabled}
+                icsFetchInterval={room.icsFetchInterval}
+                onChange={(settings) => {
+                  setRoom({
+                    ...room,
+                    icsUrl:
+                      settings.ics_url !== undefined
+                        ? settings.ics_url
+                        : room.icsUrl,
+                    icsEnabled:
+                      settings.ics_enabled !== undefined
+                        ? settings.ics_enabled
+                        : room.icsEnabled,
+                    icsFetchInterval:
+                      settings.ics_fetch_interval !== undefined
+                        ? settings.ics_fetch_interval
+                        : room.icsFetchInterval,
+                  });
+                }}
+                isOwner={true}
+              />
             </Dialog.Body>
             <Dialog.Footer>
               <Button variant="ghost" onClick={onClose}>

www/app/(app)/transcripts/[transcriptId]/page.tsx

@@ -32,7 +32,7 @@ export default function TranscriptDetails(details: TranscriptDetails) {
   const topics = useTopics(transcriptId);
   const waveform = useWaveform(
     transcriptId,
-    waiting || mp3.loading || mp3.audioDeleted === true,
+    waiting || mp3.audioDeleted === true,
   );
   const useActiveTopic = useState<Topic | null>(null);
 

www/app/(app)/transcripts/new/page.tsx

@@ -165,6 +165,8 @@ const TranscriptCreate = () => {
                     options={supportedLanguages}
                     value={targetLanguage}
                     onChange={onLanguageChange}
+                    onBlur={() => {}}
+                    onFocus={() => {}}
                     placeholder="Choose your language"
                   />
                 </Box>

www/app/(app)/transcripts/player.tsx

@@ -136,7 +136,6 @@ export default function Player(props: PlayerProps) {
         content,
         drag: false,
         resize: false,
-        top: 0,
       });
       region.on("click", (e) => {
         e.stopPropagation();

www/app/(app)/transcripts/recorder.tsx

@@ -10,7 +10,7 @@ import FileUploadButton from "./fileUploadButton";
 import useWebRTC from "./useWebRTC";
 import useAudioDevice from "./useAudioDevice";
 import { Box, Flex, IconButton, Menu, RadioGroup } from "@chakra-ui/react";
-import { LuScreenShare, LuMic, LuPlay, LuStopCircle } from "react-icons/lu";
+import { LuScreenShare, LuMic, LuPlay, LuCircleStop } from "react-icons/lu";
 
 type RecorderProps = {
   transcriptId: string;
@@ -253,7 +253,7 @@ export default function Recorder(props: RecorderProps) {
         mr={2}
         onClick={handleRecClick}
       >
-        {isRecording ? <LuStopCircle /> : <LuPlay />}
+        {isRecording ? <LuCircleStop /> : <LuPlay />}
       </IconButton>
       {!isRecording && (window as any).chrome && (
         <IconButton

www/app/(app)/transcripts/shareAndPrivacy.tsx

@@ -127,7 +127,7 @@ export default function ShareAndPrivacy(props: ShareAndPrivacyProps) {
                   {isOwner && api && (
                     <Select.Root
                       key={shareMode.value}
-                      value={[shareMode.value]}
+                      value={[shareMode.value || ""]}
                       onValueChange={(e) => updateShareMode(e.value[0])}
                       disabled={shareLoading}
                       collection={shareOptions}
@@ -145,11 +145,7 @@ export default function ShareAndPrivacy(props: ShareAndPrivacyProps) {
                       <Select.Positioner>
                         <Select.Content>
                           {shareOptions.items.map((option) => (
-                            <Select.Item
-                              key={option.value}
-                              item={option}
-                              label={option.label}
-                            >
+                            <Select.Item key={option.value} item={option}>
                               {option.label}
                               <Select.ItemIndicator />
                             </Select.Item>

www/app/(app)/transcripts/shareZulip.tsx

@@ -50,7 +50,7 @@ export default function ShareZulip(props: ShareZulipProps & BoxProps) {
     filter: streamItemsFilter,
     set: streamItemsSet,
   } = useListCollection({
-    items: [],
+    initialItems: [] as { label: string; value: string }[],
     filter: contains,
   });
 
@@ -59,7 +59,7 @@ export default function ShareZulip(props: ShareZulipProps & BoxProps) {
     filter: topicItemsFilter,
     set: topicItemsSet,
   } = useListCollection({
-    items: [],
+    initialItems: [] as { label: string; value: string }[],
     filter: contains,
   });
 

www/app/(errors)/errorMessage.tsx

@@ -1,7 +1,7 @@
 "use client";
 import { useError } from "./errorContext";
 import { useEffect, useState } from "react";
-import * as Sentry from "@sentry/react";
+import * as Sentry from "@sentry/nextjs";
 
 const ErrorMessage: React.FC = () => {
   const { error, setError, humanMessage } = useError();

www/app/[roomName]/MeetingInfo.tsx

@@ -0,0 +1,203 @@
+import {
+  Box,
+  VStack,
+  HStack,
+  Text,
+  Badge,
+  Icon,
+  Divider,
+} from "@chakra-ui/react";
+import { FaCalendarAlt, FaUsers, FaClock, FaInfoCircle } from "react-icons/fa";
+import { Meeting } from "../api";
+
+interface MeetingInfoProps {
+  meeting: Meeting;
+  isOwner: boolean;
+}
+
+export default function MeetingInfo({ meeting, isOwner }: MeetingInfoProps) {
+  const formatDuration = (start: string | Date, end: string | Date) => {
+    const startDate = new Date(start);
+    const endDate = new Date(end);
+    const now = new Date();
+
+    // If meeting hasn't started yet
+    if (startDate > now) {
+      return `Scheduled for ${startDate.toLocaleTimeString()}`;
+    }
+
+    // Calculate duration
+    const durationMs = now.getTime() - startDate.getTime();
+    const hours = Math.floor(durationMs / (1000 * 60 * 60));
+    const minutes = Math.floor((durationMs % (1000 * 60 * 60)) / (1000 * 60));
+
+    if (hours > 0) {
+      return `${hours}h ${minutes}m`;
+    }
+    return `${minutes} minutes`;
+  };
+
+  const isCalendarMeeting = !!meeting.calendar_event_id;
+  const metadata = meeting.calendar_metadata;
+
+  return (
+    <Box
+      position="absolute"
+      top="56px"
+      right="8px"
+      bg="white"
+      borderRadius="md"
+      boxShadow="lg"
+      p={4}
+      maxW="300px"
+      zIndex={999}
+    >
+      <VStack align="stretch" spacing={3}>
+        {/* Meeting Title */}
+        <HStack>
+          <Icon
+            as={isCalendarMeeting ? FaCalendarAlt : FaInfoCircle}
+            color="blue.500"
+          />
+          <Text fontWeight="semibold" fontSize="md">
+            {metadata?.title ||
+              (isCalendarMeeting ? "Calendar Meeting" : "Unscheduled Meeting")}
+          </Text>
+        </HStack>
+
+        {/* Meeting Status */}
+        <HStack spacing={2}>
+          {meeting.is_active && (
+            <Badge colorScheme="green" fontSize="xs">
+              Active
+            </Badge>
+          )}
+          {isCalendarMeeting && (
+            <Badge colorScheme="blue" fontSize="xs">
+              Calendar
+            </Badge>
+          )}
+          {meeting.is_locked && (
+            <Badge colorScheme="orange" fontSize="xs">
+              Locked
+            </Badge>
+          )}
+        </HStack>
+
+        <Divider />
+
+        {/* Meeting Details */}
+        <VStack align="stretch" spacing={2} fontSize="sm">
+          {/* Participants */}
+          <HStack>
+            <Icon as={FaUsers} color="gray.500" />
+            <Text>
+              {meeting.num_clients}{" "}
+              {meeting.num_clients === 1 ? "participant" : "participants"}
+            </Text>
+          </HStack>
+
+          {/* Duration */}
+          <HStack>
+            <Icon as={FaClock} color="gray.500" />
+            <Text>
+              Duration: {formatDuration(meeting.start_date, meeting.end_date)}
+            </Text>
+          </HStack>
+
+          {/* Calendar Description (Owner only) */}
+          {isOwner && metadata?.description && (
+            <>
+              <Divider />
+              <Box>
+                <Text
+                  fontWeight="semibold"
+                  fontSize="xs"
+                  color="gray.600"
+                  mb={1}
+                >
+                  Description
+                </Text>
+                <Text fontSize="xs" color="gray.700">
+                  {metadata.description}
+                </Text>
+              </Box>
+            </>
+          )}
+
+          {/* Attendees (Owner only) */}
+          {isOwner && metadata?.attendees && metadata.attendees.length > 0 && (
+            <>
+              <Divider />
+              <Box>
+                <Text
+                  fontWeight="semibold"
+                  fontSize="xs"
+                  color="gray.600"
+                  mb={1}
+                >
+                  Invited Attendees ({metadata.attendees.length})
+                </Text>
+                <VStack align="stretch" spacing={1}>
+                  {metadata.attendees
+                    .slice(0, 5)
+                    .map((attendee: any, idx: number) => (
+                      <HStack key={idx} fontSize="xs">
+                        <Badge
+                          colorScheme={
+                            attendee.status === "ACCEPTED"
+                              ? "green"
+                              : attendee.status === "DECLINED"
+                                ? "red"
+                                : attendee.status === "TENTATIVE"
+                                  ? "yellow"
+                                  : "gray"
+                          }
+                          fontSize="xs"
+                          size="sm"
+                        >
+                          {attendee.status?.charAt(0) || "?"}
+                        </Badge>
+                        <Text color="gray.700" isTruncated>
+                          {attendee.name || attendee.email}
+                        </Text>
+                      </HStack>
+                    ))}
+                  {metadata.attendees.length > 5 && (
+                    <Text fontSize="xs" color="gray.500" fontStyle="italic">
+                      +{metadata.attendees.length - 5} more
+                    </Text>
+                  )}
+                </VStack>
+              </Box>
+            </>
+          )}
+
+          {/* Recording Info */}
+          {meeting.recording_type !== "none" && (
+            <>
+              <Divider />
+              <HStack fontSize="xs">
+                <Badge colorScheme="red" fontSize="xs">
+                  Recording
+                </Badge>
+                <Text color="gray.600">
+                  {meeting.recording_type === "cloud" ? "Cloud" : "Local"}
+                  {meeting.recording_trigger !== "none" &&
+                    ` (${meeting.recording_trigger})`}
+                </Text>
+              </HStack>
+            </>
+          )}
+        </VStack>
+
+        {/* Meeting Times */}
+        <Divider />
+        <VStack align="stretch" spacing={1} fontSize="xs" color="gray.600">
+          <Text>Start: {new Date(meeting.start_date).toLocaleString()}</Text>
+          <Text>End: {new Date(meeting.end_date).toLocaleString()}</Text>
+        </VStack>
+      </VStack>
+    </Box>
+  );
+}

www/app/[roomName]/MeetingSelection.tsx

@@ -0,0 +1,335 @@
+"use client";
+
+import {
+  Box,
+  VStack,
+  HStack,
+  Text,
+  Button,
+  Spinner,
+  Card,
+  CardBody,
+  CardHeader,
+  Badge,
+  Divider,
+  Icon,
+  Alert,
+  AlertIcon,
+  AlertTitle,
+  AlertDescription,
+} from "@chakra-ui/react";
+import { useEffect, useState } from "react";
+import { FaUsers, FaClock, FaCalendarAlt, FaPlus } from "react-icons/fa";
+import { Meeting, CalendarEventResponse } from "../api";
+import useApi from "../lib/useApi";
+import { useRouter } from "next/navigation";
+
+interface MeetingSelectionProps {
+  roomName: string;
+  isOwner: boolean;
+  onMeetingSelect: (meeting: Meeting) => void;
+  onCreateUnscheduled: () => void;
+}
+
+const formatDateTime = (date: string | Date) => {
+  const d = new Date(date);
+  return d.toLocaleString("en-US", {
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+};
+
+const formatCountdown = (startTime: string | Date) => {
+  const now = new Date();
+  const start = new Date(startTime);
+  const diff = start.getTime() - now.getTime();
+
+  if (diff <= 0) return "Starting now";
+
+  const minutes = Math.floor(diff / 60000);
+  const hours = Math.floor(minutes / 60);
+
+  if (hours > 0) {
+    return `Starts in ${hours}h ${minutes % 60}m`;
+  }
+  return `Starts in ${minutes} minutes`;
+};
+
+export default function MeetingSelection({
+  roomName,
+  isOwner,
+  onMeetingSelect,
+  onCreateUnscheduled,
+}: MeetingSelectionProps) {
+  const [activeMeetings, setActiveMeetings] = useState<Meeting[]>([]);
+  const [upcomingEvents, setUpcomingEvents] = useState<CalendarEventResponse[]>(
+    [],
+  );
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const api = useApi();
+  const router = useRouter();
+
+  useEffect(() => {
+    if (!api) return;
+
+    const fetchMeetings = async () => {
+      try {
+        setLoading(true);
+
+        // Fetch active meetings
+        const active = await api.v1RoomsListActiveMeetings({ roomName });
+        setActiveMeetings(active);
+
+        // Fetch upcoming calendar events (30 min ahead)
+        const upcoming = await api.v1RoomsListUpcomingMeetings({
+          roomName,
+          minutesAhead: 30,
+        });
+        setUpcomingEvents(upcoming);
+
+        setError(null);
+      } catch (err) {
+        console.error("Failed to fetch meetings:", err);
+        setError("Failed to load meetings. Please try again.");
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchMeetings();
+
+    // Refresh every 30 seconds
+    const interval = setInterval(fetchMeetings, 30000);
+    return () => clearInterval(interval);
+  }, [api, roomName]);
+
+  const handleJoinMeeting = async (meetingId: string) => {
+    if (!api) return;
+
+    try {
+      const meeting = await api.v1RoomsJoinMeeting({
+        roomName,
+        meetingId,
+      });
+      onMeetingSelect(meeting);
+    } catch (err) {
+      console.error("Failed to join meeting:", err);
+      setError("Failed to join meeting. Please try again.");
+    }
+  };
+
+  const handleJoinUpcoming = (event: CalendarEventResponse) => {
+    // Navigate to waiting page with event info
+    router.push(`/room/${roomName}/wait?eventId=${event.id}`);
+  };
+
+  if (loading) {
+    return (
+      <Box p={8} textAlign="center">
+        <Spinner size="lg" color="blue.500" />
+        <Text mt={4}>Loading meetings...</Text>
+      </Box>
+    );
+  }
+
+  if (error) {
+    return (
+      <Alert status="error" borderRadius="md">
+        <AlertIcon />
+        <AlertTitle>Error</AlertTitle>
+        <AlertDescription>{error}</AlertDescription>
+      </Alert>
+    );
+  }
+
+  return (
+    <VStack spacing={6} align="stretch" p={6}>
+      <Box>
+        <Text fontSize="2xl" fontWeight="bold" mb={4}>
+          Select a Meeting
+        </Text>
+
+        {/* Active Meetings */}
+        {activeMeetings.length > 0 && (
+          <>
+            <Text fontSize="lg" fontWeight="semibold" mb={3}>
+              Active Meetings
+            </Text>
+            <VStack spacing={3} mb={6}>
+              {activeMeetings.map((meeting) => (
+                <Card key={meeting.id} width="100%" variant="outline">
+                  <CardBody>
+                    <HStack justify="space-between" align="start">
+                      <VStack align="start" spacing={2} flex={1}>
+                        <HStack>
+                          <Icon as={FaCalendarAlt} color="blue.500" />
+                          <Text fontWeight="semibold">
+                            {meeting.calendar_metadata?.title || "Meeting"}
+                          </Text>
+                        </HStack>
+
+                        {isOwner && meeting.calendar_metadata?.description && (
+                          <Text fontSize="sm" color="gray.600">
+                            {meeting.calendar_metadata.description}
+                          </Text>
+                        )}
+
+                        <HStack spacing={4} fontSize="sm" color="gray.500">
+                          <HStack>
+                            <Icon as={FaUsers} />
+                            <Text>{meeting.num_clients} participants</Text>
+                          </HStack>
+                          <HStack>
+                            <Icon as={FaClock} />
+                            <Text>
+                              Started {formatDateTime(meeting.start_date)}
+                            </Text>
+                          </HStack>
+                        </HStack>
+
+                        {isOwner && meeting.calendar_metadata?.attendees && (
+                          <HStack spacing={2} flexWrap="wrap">
+                            {meeting.calendar_metadata.attendees
+                              .slice(0, 3)
+                              .map((attendee: any, idx: number) => (
+                                <Badge
+                                  key={idx}
+                                  colorScheme="green"
+                                  fontSize="xs"
+                                >
+                                  {attendee.name || attendee.email}
+                                </Badge>
+                              ))}
+                            {meeting.calendar_metadata.attendees.length > 3 && (
+                              <Badge colorScheme="gray" fontSize="xs">
+                                +
+                                {meeting.calendar_metadata.attendees.length - 3}{" "}
+                                more
+                              </Badge>
+                            )}
+                          </HStack>
+                        )}
+                      </VStack>
+
+                      <Button
+                        colorScheme="blue"
+                        size="md"
+                        onClick={() => handleJoinMeeting(meeting.id)}
+                      >
+                        Join Now
+                      </Button>
+                    </HStack>
+                  </CardBody>
+                </Card>
+              ))}
+            </VStack>
+          </>
+        )}
+
+        {/* Upcoming Meetings */}
+        {upcomingEvents.length > 0 && (
+          <>
+            <Text fontSize="lg" fontWeight="semibold" mb={3}>
+              Upcoming Meetings
+            </Text>
+            <VStack spacing={3} mb={6}>
+              {upcomingEvents.map((event) => (
+                <Card
+                  key={event.id}
+                  width="100%"
+                  variant="outline"
+                  bg="gray.50"
+                >
+                  <CardBody>
+                    <HStack justify="space-between" align="start">
+                      <VStack align="start" spacing={2} flex={1}>
+                        <HStack>
+                          <Icon as={FaCalendarAlt} color="orange.500" />
+                          <Text fontWeight="semibold">
+                            {event.title || "Scheduled Meeting"}
+                          </Text>
+                          <Badge colorScheme="orange" fontSize="xs">
+                            {formatCountdown(event.start_time)}
+                          </Badge>
+                        </HStack>
+
+                        {isOwner && event.description && (
+                          <Text fontSize="sm" color="gray.600">
+                            {event.description}
+                          </Text>
+                        )}
+
+                        <HStack spacing={4} fontSize="sm" color="gray.500">
+                          <Text>
+                            {formatDateTime(event.start_time)} -{" "}
+                            {formatDateTime(event.end_time)}
+                          </Text>
+                        </HStack>
+
+                        {isOwner && event.attendees && (
+                          <HStack spacing={2} flexWrap="wrap">
+                            {event.attendees
+                              .slice(0, 3)
+                              .map((attendee: any, idx: number) => (
+                                <Badge
+                                  key={idx}
+                                  colorScheme="purple"
+                                  fontSize="xs"
+                                >
+                                  {attendee.name || attendee.email}
+                                </Badge>
+                              ))}
+                            {event.attendees.length > 3 && (
+                              <Badge colorScheme="gray" fontSize="xs">
+                                +{event.attendees.length - 3} more
+                              </Badge>
+                            )}
+                          </HStack>
+                        )}
+                      </VStack>
+
+                      <Button
+                        variant="outline"
+                        colorScheme="orange"
+                        size="md"
+                        onClick={() => handleJoinUpcoming(event)}
+                      >
+                        Join Early
+                      </Button>
+                    </HStack>
+                  </CardBody>
+                </Card>
+              ))}
+            </VStack>
+          </>
+        )}
+
+        <Divider my={6} />
+
+        {/* Create Unscheduled Meeting */}
+        <Card width="100%" variant="filled" bg="gray.100">
+          <CardBody>
+            <HStack justify="space-between" align="center">
+              <VStack align="start" spacing={1}>
+                <Text fontWeight="semibold">Start an Unscheduled Meeting</Text>
+                <Text fontSize="sm" color="gray.600">
+                  Create a new meeting room that's not on the calendar
+                </Text>
+              </VStack>
+              <Button
+                leftIcon={<FaPlus />}
+                colorScheme="green"
+                onClick={onCreateUnscheduled}
+              >
+                Create Meeting
+              </Button>
+            </HStack>
+          </CardBody>
+        </Card>
+      </Box>
+    </VStack>
+  );
+}

www/app/[roomName]/page.tsx

@@ -24,8 +24,9 @@ import { notFound } from "next/navigation";
 import useSessionStatus from "../lib/useSessionStatus";
 import { useRecordingConsent } from "../recordingConsentContext";
 import useApi from "../lib/useApi";
-import { Meeting } from "../api";
-import { FaBars } from "react-icons/fa6";
+import { Meeting, Room } from "../api";
+import { FaBars, FaInfoCircle } from "react-icons/fa6";
+import MeetingInfo from "./MeetingInfo";
 
 export type RoomDetails = {
   params: {
@@ -254,7 +255,10 @@ export default function Room(details: RoomDetails) {
   const roomName = details.params.roomName;
   const meeting = useRoomMeeting(roomName);
   const router = useRouter();
-  const { isLoading, isAuthenticated } = useSessionStatus();
+  const { isLoading, isAuthenticated, data: session } = useSessionStatus();
+  const [showMeetingInfo, setShowMeetingInfo] = useState(false);
+  const [room, setRoom] = useState<Room | null>(null);
+  const api = useApi();
 
   const roomUrl = meeting?.response?.host_room_url
     ? meeting?.response?.host_room_url
@@ -268,6 +272,15 @@ export default function Room(details: RoomDetails) {
     router.push("/browse");
   }, [router]);
 
+  // Fetch room details
+  useEffect(() => {
+    if (!api || !roomName) return;
+
+    api.v1RoomsRetrieve({ roomName }).then(setRoom).catch(console.error);
+  }, [api, roomName]);
+
+  const isOwner = session?.user?.id === room?.user_id;
+
   useEffect(() => {
     if (
       !isLoading &&
@@ -319,6 +332,25 @@ export default function Room(details: RoomDetails) {
               wherebyRef={wherebyRef}
             />
           )}
+          {meeting?.response && (
+            <>
+              <Button
+                position="absolute"
+                top="56px"
+                right={showMeetingInfo ? "320px" : "8px"}
+                zIndex={1000}
+                colorPalette="blue"
+                size="sm"
+                onClick={() => setShowMeetingInfo(!showMeetingInfo)}
+                leftIcon={<Icon as={FaInfoCircle} />}
+              >
+                Meeting Info
+              </Button>
+              {showMeetingInfo && (
+                <MeetingInfo meeting={meeting.response} isOwner={isOwner} />
+              )}
+            </>
+          )}
         </>
       )}
     </>

www/app/[roomName]/useRoomMeeting.tsx

@@ -40,6 +40,20 @@ const useRoomMeeting = (
   useEffect(() => {
     if (!roomName || !api) return;
 
+    // Check if meeting was pre-selected from meeting selection page
+    const storedMeeting = sessionStorage.getItem(`meeting_${roomName}`);
+    if (storedMeeting) {
+      try {
+        const meeting = JSON.parse(storedMeeting);
+        sessionStorage.removeItem(`meeting_${roomName}`); // Clean up
+        setResponse(meeting);
+        setLoading(false);
+        return;
+      } catch (e) {
+        console.error("Failed to parse stored meeting:", e);
+      }
+    }
+
     if (!response) {
       setLoading(true);
     }

www/app/api/schemas.gen.ts

@@ -30,6 +30,108 @@ export const $Body_transcript_record_upload_v1_transcripts__transcript_id__recor
       "Body_transcript_record_upload_v1_transcripts__transcript_id__record_upload_post",
   } as const;
 
+export const $CalendarEventResponse = {
+  properties: {
+    id: {
+      type: "string",
+      title: "Id",
+    },
+    room_id: {
+      type: "string",
+      title: "Room Id",
+    },
+    ics_uid: {
+      type: "string",
+      title: "Ics Uid",
+    },
+    title: {
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Title",
+    },
+    description: {
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Description",
+    },
+    start_time: {
+      type: "string",
+      format: "date-time",
+      title: "Start Time",
+    },
+    end_time: {
+      type: "string",
+      format: "date-time",
+      title: "End Time",
+    },
+    attendees: {
+      anyOf: [
+        {
+          items: {
+            additionalProperties: true,
+            type: "object",
+          },
+          type: "array",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Attendees",
+    },
+    location: {
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Location",
+    },
+    last_synced: {
+      type: "string",
+      format: "date-time",
+      title: "Last Synced",
+    },
+    created_at: {
+      type: "string",
+      format: "date-time",
+      title: "Created At",
+    },
+    updated_at: {
+      type: "string",
+      format: "date-time",
+      title: "Updated At",
+    },
+  },
+  type: "object",
+  required: [
+    "id",
+    "room_id",
+    "ics_uid",
+    "start_time",
+    "end_time",
+    "last_synced",
+    "created_at",
+    "updated_at",
+  ],
+  title: "CalendarEventResponse",
+} as const;
+
 export const $CreateParticipant = {
   properties: {
     speaker: {
@@ -91,6 +193,27 @@ export const $CreateRoom = {
       type: "boolean",
       title: "Is Shared",
     },
+    ics_url: {
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Ics Url",
+    },
+    ics_fetch_interval: {
+      type: "integer",
+      title: "Ics Fetch Interval",
+      default: 300,
+    },
+    ics_enabled: {
+      type: "boolean",
+      title: "Ics Enabled",
+      default: false,
+    },
   },
   type: "object",
   required: [
@@ -209,7 +332,6 @@ export const $GetTranscript = {
     },
     created_at: {
       type: "string",
-      format: "date-time",
       title: "Created At",
     },
     share_mode: {
@@ -395,7 +517,6 @@ export const $GetTranscriptMinimal = {
     },
     created_at: {
       type: "string",
-      format: "date-time",
       title: "Created At",
     },
     share_mode: {
@@ -689,6 +810,112 @@ export const $HTTPValidationError = {
   title: "HTTPValidationError",
 } as const;
 
+export const $ICSStatus = {
+  properties: {
+    status: {
+      type: "string",
+      title: "Status",
+    },
+    last_sync: {
+      anyOf: [
+        {
+          type: "string",
+          format: "date-time",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Last Sync",
+    },
+    next_sync: {
+      anyOf: [
+        {
+          type: "string",
+          format: "date-time",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Next Sync",
+    },
+    last_etag: {
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Last Etag",
+    },
+    events_count: {
+      type: "integer",
+      title: "Events Count",
+      default: 0,
+    },
+  },
+  type: "object",
+  required: ["status"],
+  title: "ICSStatus",
+} as const;
+
+export const $ICSSyncResult = {
+  properties: {
+    status: {
+      type: "string",
+      title: "Status",
+    },
+    hash: {
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Hash",
+    },
+    events_found: {
+      type: "integer",
+      title: "Events Found",
+      default: 0,
+    },
+    events_created: {
+      type: "integer",
+      title: "Events Created",
+      default: 0,
+    },
+    events_updated: {
+      type: "integer",
+      title: "Events Updated",
+      default: 0,
+    },
+    events_deleted: {
+      type: "integer",
+      title: "Events Deleted",
+      default: 0,
+    },
+    error: {
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Error",
+    },
+  },
+  type: "object",
+  required: ["status"],
+  title: "ICSSyncResult",
+} as const;
+
 export const $Meeting = {
   properties: {
     id: {
@@ -758,8 +985,15 @@ export const $Page_GetTranscriptMinimal_ = {
       title: "Items",
     },
     total: {
-      type: "integer",
-      minimum: 0,
+      anyOf: [
+        {
+          type: "integer",
+          minimum: 0,
+        },
+        {
+          type: "null",
+        },
+      ],
       title: "Total",
     },
     page: {
@@ -800,7 +1034,7 @@ export const $Page_GetTranscriptMinimal_ = {
     },
   },
   type: "object",
-  required: ["items", "total", "page", "size"],
+  required: ["items", "page", "size"],
   title: "Page[GetTranscriptMinimal]",
 } as const;
 
@@ -814,8 +1048,15 @@ export const $Page_Room_ = {
       title: "Items",
     },
     total: {
-      type: "integer",
-      minimum: 0,
+      anyOf: [
+        {
+          type: "integer",
+          minimum: 0,
+        },
+        {
+          type: "null",
+        },
+      ],
       title: "Total",
     },
     page: {
@@ -856,7 +1097,7 @@ export const $Page_Room_ = {
     },
   },
   type: "object",
-  required: ["items", "total", "page", "size"],
+  required: ["items", "page", "size"],
   title: "Page[Room]",
 } as const;
 
@@ -938,6 +1179,50 @@ export const $Room = {
       type: "boolean",
       title: "Is Shared",
     },
+    ics_url: {
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Ics Url",
+    },
+    ics_fetch_interval: {
+      type: "integer",
+      title: "Ics Fetch Interval",
+      default: 300,
+    },
+    ics_enabled: {
+      type: "boolean",
+      title: "Ics Enabled",
+      default: false,
+    },
+    ics_last_sync: {
+      anyOf: [
+        {
+          type: "string",
+          format: "date-time",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Ics Last Sync",
+    },
+    ics_last_etag: {
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Ics Last Etag",
+    },
   },
   type: "object",
   required: [
@@ -973,6 +1258,136 @@ export const $RtcOffer = {
   title: "RtcOffer",
 } as const;
 
+export const $SearchResponse = {
+  properties: {
+    results: {
+      items: {
+        $ref: "#/components/schemas/SearchResult",
+      },
+      type: "array",
+      title: "Results",
+    },
+    total: {
+      type: "integer",
+      minimum: 0,
+      title: "Total",
+      description: "Total number of search results",
+    },
+    query: {
+      type: "string",
+      minLength: 1,
+      title: "Query",
+      description: "Search query text",
+    },
+    limit: {
+      type: "integer",
+      maximum: 100,
+      minimum: 1,
+      title: "Limit",
+      description: "Results per page",
+    },
+    offset: {
+      type: "integer",
+      minimum: 0,
+      title: "Offset",
+      description: "Number of results to skip",
+    },
+  },
+  type: "object",
+  required: ["results", "total", "query", "limit", "offset"],
+  title: "SearchResponse",
+} as const;
+
+export const $SearchResult = {
+  properties: {
+    id: {
+      type: "string",
+      minLength: 1,
+      title: "Id",
+    },
+    title: {
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Title",
+    },
+    user_id: {
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "User Id",
+    },
+    room_id: {
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Room Id",
+    },
+    created_at: {
+      type: "string",
+      title: "Created At",
+    },
+    status: {
+      type: "string",
+      minLength: 1,
+      title: "Status",
+    },
+    rank: {
+      type: "number",
+      maximum: 1,
+      minimum: 0,
+      title: "Rank",
+    },
+    duration: {
+      anyOf: [
+        {
+          type: "number",
+          minimum: 0,
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Duration",
+      description: "Duration in seconds",
+    },
+    search_snippets: {
+      items: {
+        type: "string",
+      },
+      type: "array",
+      title: "Search Snippets",
+      description: "Text snippets around search matches",
+    },
+  },
+  type: "object",
+  required: [
+    "id",
+    "created_at",
+    "status",
+    "rank",
+    "duration",
+    "search_snippets",
+  ],
+  title: "SearchResult",
+  description: "Public search result model with computed fields.",
+} as const;
+
 export const $SourceKind = {
   type: "string",
   enum: ["room", "live", "file"],
@@ -1152,54 +1567,139 @@ export const $UpdateParticipant = {
 export const $UpdateRoom = {
   properties: {
     name: {
-      type: "string",
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
       title: "Name",
     },
     zulip_auto_post: {
-      type: "boolean",
+      anyOf: [
+        {
+          type: "boolean",
+        },
+        {
+          type: "null",
+        },
+      ],
       title: "Zulip Auto Post",
     },
     zulip_stream: {
-      type: "string",
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
       title: "Zulip Stream",
     },
     zulip_topic: {
-      type: "string",
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
       title: "Zulip Topic",
     },
     is_locked: {
-      type: "boolean",
+      anyOf: [
+        {
+          type: "boolean",
+        },
+        {
+          type: "null",
+        },
+      ],
       title: "Is Locked",
     },
     room_mode: {
-      type: "string",
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
       title: "Room Mode",
     },
     recording_type: {
-      type: "string",
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
       title: "Recording Type",
     },
     recording_trigger: {
-      type: "string",
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
       title: "Recording Trigger",
     },
     is_shared: {
-      type: "boolean",
+      anyOf: [
+        {
+          type: "boolean",
+        },
+        {
+          type: "null",
+        },
+      ],
       title: "Is Shared",
     },
+    ics_url: {
+      anyOf: [
+        {
+          type: "string",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Ics Url",
+    },
+    ics_fetch_interval: {
+      anyOf: [
+        {
+          type: "integer",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Ics Fetch Interval",
+    },
+    ics_enabled: {
+      anyOf: [
+        {
+          type: "boolean",
+        },
+        {
+          type: "null",
+        },
+      ],
+      title: "Ics Enabled",
+    },
   },
   type: "object",
-  required: [
-    "name",
-    "zulip_auto_post",
-    "zulip_stream",
-    "zulip_topic",
-    "is_locked",
-    "room_mode",
-    "recording_type",
-    "recording_trigger",
-    "is_shared",
-  ],
   title: "UpdateRoom",
 } as const;
 
@@ -1397,6 +1897,7 @@ export const $WherebyWebhookEvent = {
       title: "Type",
     },
     data: {
+      additionalProperties: true,
       type: "object",
       title: "Data",
     },
@@ -1414,11 +1915,15 @@ export const $Word = {
     },
     start: {
       type: "number",
+      minimum: 0,
       title: "Start",
+      description: "Time in seconds with float part",
     },
     end: {
       type: "number",
+      minimum: 0,
       title: "End",
+      description: "Time in seconds with float part",
     },
     speaker: {
       type: "integer",

www/app/api/services.gen.ts

@@ -16,10 +16,24 @@ import type {
   V1RoomsDeleteResponse,
   V1RoomsCreateMeetingData,
   V1RoomsCreateMeetingResponse,
+  V1RoomsSyncIcsData,
+  V1RoomsSyncIcsResponse,
+  V1RoomsIcsStatusData,
+  V1RoomsIcsStatusResponse,
+  V1RoomsListMeetingsData,
+  V1RoomsListMeetingsResponse,
+  V1RoomsListUpcomingMeetingsData,
+  V1RoomsListUpcomingMeetingsResponse,
+  V1RoomsListActiveMeetingsData,
+  V1RoomsListActiveMeetingsResponse,
+  V1RoomsJoinMeetingData,
+  V1RoomsJoinMeetingResponse,
   V1TranscriptsListData,
   V1TranscriptsListResponse,
   V1TranscriptsCreateData,
   V1TranscriptsCreateResponse,
+  V1TranscriptsSearchData,
+  V1TranscriptsSearchResponse,
   V1TranscriptGetData,
   V1TranscriptGetResponse,
   V1TranscriptUpdateData,
@@ -225,6 +239,146 @@ export class DefaultService {
     });
   }
 
+  /**
+   * Rooms Sync Ics
+   * @param data The data for the request.
+   * @param data.roomName
+   * @returns ICSSyncResult Successful Response
+   * @throws ApiError
+   */
+  public v1RoomsSyncIcs(
+    data: V1RoomsSyncIcsData,
+  ): CancelablePromise<V1RoomsSyncIcsResponse> {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/v1/rooms/{room_name}/ics/sync",
+      path: {
+        room_name: data.roomName,
+      },
+      errors: {
+        422: "Validation Error",
+      },
+    });
+  }
+
+  /**
+   * Rooms Ics Status
+   * @param data The data for the request.
+   * @param data.roomName
+   * @returns ICSStatus Successful Response
+   * @throws ApiError
+   */
+  public v1RoomsIcsStatus(
+    data: V1RoomsIcsStatusData,
+  ): CancelablePromise<V1RoomsIcsStatusResponse> {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/rooms/{room_name}/ics/status",
+      path: {
+        room_name: data.roomName,
+      },
+      errors: {
+        422: "Validation Error",
+      },
+    });
+  }
+
+  /**
+   * Rooms List Meetings
+   * @param data The data for the request.
+   * @param data.roomName
+   * @returns CalendarEventResponse Successful Response
+   * @throws ApiError
+   */
+  public v1RoomsListMeetings(
+    data: V1RoomsListMeetingsData,
+  ): CancelablePromise<V1RoomsListMeetingsResponse> {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/rooms/{room_name}/meetings",
+      path: {
+        room_name: data.roomName,
+      },
+      errors: {
+        422: "Validation Error",
+      },
+    });
+  }
+
+  /**
+   * Rooms List Upcoming Meetings
+   * @param data The data for the request.
+   * @param data.roomName
+   * @param data.minutesAhead
+   * @returns CalendarEventResponse Successful Response
+   * @throws ApiError
+   */
+  public v1RoomsListUpcomingMeetings(
+    data: V1RoomsListUpcomingMeetingsData,
+  ): CancelablePromise<V1RoomsListUpcomingMeetingsResponse> {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/rooms/{room_name}/meetings/upcoming",
+      path: {
+        room_name: data.roomName,
+      },
+      query: {
+        minutes_ahead: data.minutesAhead,
+      },
+      errors: {
+        422: "Validation Error",
+      },
+    });
+  }
+
+  /**
+   * Rooms List Active Meetings
+   * List all active meetings for a room (supports multiple active meetings)
+   * @param data The data for the request.
+   * @param data.roomName
+   * @returns Meeting Successful Response
+   * @throws ApiError
+   */
+  public v1RoomsListActiveMeetings(
+    data: V1RoomsListActiveMeetingsData,
+  ): CancelablePromise<V1RoomsListActiveMeetingsResponse> {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/rooms/{room_name}/meetings/active",
+      path: {
+        room_name: data.roomName,
+      },
+      errors: {
+        422: "Validation Error",
+      },
+    });
+  }
+
+  /**
+   * Rooms Join Meeting
+   * Join a specific meeting by ID
+   * @param data The data for the request.
+   * @param data.roomName
+   * @param data.meetingId
+   * @returns Meeting Successful Response
+   * @throws ApiError
+   */
+  public v1RoomsJoinMeeting(
+    data: V1RoomsJoinMeetingData,
+  ): CancelablePromise<V1RoomsJoinMeetingResponse> {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/v1/rooms/{room_name}/meetings/{meeting_id}/join",
+      path: {
+        room_name: data.roomName,
+        meeting_id: data.meetingId,
+      },
+      errors: {
+        422: "Validation Error",
+      },
+    });
+  }
+
   /**
    * Transcripts List
    * @param data The data for the request.
@@ -276,6 +430,35 @@ export class DefaultService {
     });
   }
 
+  /**
+   * Transcripts Search
+   * Full-text search across transcript titles and content.
+   * @param data The data for the request.
+   * @param data.q Search query text
+   * @param data.limit Results per page
+   * @param data.offset Number of results to skip
+   * @param data.roomId
+   * @returns SearchResponse Successful Response
+   * @throws ApiError
+   */
+  public v1TranscriptsSearch(
+    data: V1TranscriptsSearchData,
+  ): CancelablePromise<V1TranscriptsSearchResponse> {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/transcripts/search",
+      query: {
+        q: data.q,
+        limit: data.limit,
+        offset: data.offset,
+        room_id: data.roomId,
+      },
+      errors: {
+        422: "Validation Error",
+      },
+    });
+  }
+
   /**
    * Transcript Get
    * @param data The data for the request.

www/app/api/types.gen.ts

@@ -9,6 +9,23 @@ export type Body_transcript_record_upload_v1_transcripts__transcript_id__record_
     chunk: Blob | File;
   };
 
+export type CalendarEventResponse = {
+  id: string;
+  room_id: string;
+  ics_uid: string;
+  title?: string | null;
+  description?: string | null;
+  start_time: string;
+  end_time: string;
+  attendees?: Array<{
+    [key: string]: unknown;
+  }> | null;
+  location?: string | null;
+  last_synced: string;
+  created_at: string;
+  updated_at: string;
+};
+
 export type CreateParticipant = {
   speaker?: number | null;
   name: string;
@@ -24,6 +41,9 @@ export type CreateRoom = {
   recording_type: string;
   recording_trigger: string;
   is_shared: boolean;
+  ics_url?: string | null;
+  ics_fetch_interval?: number;
+  ics_enabled?: boolean;
 };
 
 export type CreateTranscript = {
@@ -123,6 +143,24 @@ export type HTTPValidationError = {
   detail?: Array<ValidationError>;
 };
 
+export type ICSStatus = {
+  status: string;
+  last_sync?: string | null;
+  next_sync?: string | null;
+  last_etag?: string | null;
+  events_count?: number;
+};
+
+export type ICSSyncResult = {
+  status: string;
+  hash?: string | null;
+  events_found?: number;
+  events_created?: number;
+  events_updated?: number;
+  events_deleted?: number;
+  error?: string | null;
+};
+
 export type Meeting = {
   id: string;
   room_name: string;
@@ -141,7 +179,7 @@ export type MeetingConsentRequest = {
 
 export type Page_GetTranscriptMinimal_ = {
   items: Array<GetTranscriptMinimal>;
-  total: number;
+  total?: number | null;
   page: number | null;
   size: number | null;
   pages?: number | null;
@@ -149,7 +187,7 @@ export type Page_GetTranscriptMinimal_ = {
 
 export type Page_Room_ = {
   items: Array<Room>;
-  total: number;
+  total?: number | null;
   page: number | null;
   size: number | null;
   pages?: number | null;
@@ -174,6 +212,11 @@ export type Room = {
   recording_type: string;
   recording_trigger: string;
   is_shared: boolean;
+  ics_url?: string | null;
+  ics_fetch_interval?: number;
+  ics_enabled?: boolean;
+  ics_last_sync?: string | null;
+  ics_last_etag?: string | null;
 };
 
 export type RtcOffer = {
@@ -181,6 +224,47 @@ export type RtcOffer = {
   type: string;
 };
 
+export type SearchResponse = {
+  results: Array<SearchResult>;
+  /**
+   * Total number of search results
+   */
+  total: number;
+  /**
+   * Search query text
+   */
+  query: string;
+  /**
+   * Results per page
+   */
+  limit: number;
+  /**
+   * Number of results to skip
+   */
+  offset: number;
+};
+
+/**
+ * Public search result model with computed fields.
+ */
+export type SearchResult = {
+  id: string;
+  title?: string | null;
+  user_id?: string | null;
+  room_id?: string | null;
+  created_at: string;
+  status: string;
+  rank: number;
+  /**
+   * Duration in seconds
+   */
+  duration: number | null;
+  /**
+   * Text snippets around search matches
+   */
+  search_snippets: Array<string>;
+};
+
 export type SourceKind = "room" | "live" | "file";
 
 export type SpeakerAssignment = {
@@ -225,15 +309,18 @@ export type UpdateParticipant = {
 };
 
 export type UpdateRoom = {
-  name: string;
-  zulip_auto_post: boolean;
-  zulip_stream: string;
-  zulip_topic: string;
-  is_locked: boolean;
-  room_mode: string;
-  recording_type: string;
-  recording_trigger: string;
-  is_shared: boolean;
+  name?: string | null;
+  zulip_auto_post?: boolean | null;
+  zulip_stream?: string | null;
+  zulip_topic?: string | null;
+  is_locked?: boolean | null;
+  room_mode?: string | null;
+  recording_type?: string | null;
+  recording_trigger?: string | null;
+  is_shared?: boolean | null;
+  ics_url?: string | null;
+  ics_fetch_interval?: number | null;
+  ics_enabled?: boolean | null;
 };
 
 export type UpdateTranscript = {
@@ -272,7 +359,13 @@ export type WherebyWebhookEvent = {
 
 export type Word = {
   text: string;
+  /**
+   * Time in seconds with float part
+   */
   start: number;
+  /**
+   * Time in seconds with float part
+   */
   end: number;
   speaker?: number;
 };
@@ -324,6 +417,44 @@ export type V1RoomsCreateMeetingData = {
 
 export type V1RoomsCreateMeetingResponse = Meeting;
 
+export type V1RoomsSyncIcsData = {
+  roomName: string;
+};
+
+export type V1RoomsSyncIcsResponse = ICSSyncResult;
+
+export type V1RoomsIcsStatusData = {
+  roomName: string;
+};
+
+export type V1RoomsIcsStatusResponse = ICSStatus;
+
+export type V1RoomsListMeetingsData = {
+  roomName: string;
+};
+
+export type V1RoomsListMeetingsResponse = Array<CalendarEventResponse>;
+
+export type V1RoomsListUpcomingMeetingsData = {
+  minutesAhead?: number;
+  roomName: string;
+};
+
+export type V1RoomsListUpcomingMeetingsResponse = Array<CalendarEventResponse>;
+
+export type V1RoomsListActiveMeetingsData = {
+  roomName: string;
+};
+
+export type V1RoomsListActiveMeetingsResponse = Array<Meeting>;
+
+export type V1RoomsJoinMeetingData = {
+  meetingId: string;
+  roomName: string;
+};
+
+export type V1RoomsJoinMeetingResponse = Meeting;
+
 export type V1TranscriptsListData = {
   /**
    * Page number
@@ -346,6 +477,24 @@ export type V1TranscriptsCreateData = {
 
 export type V1TranscriptsCreateResponse = GetTranscript;
 
+export type V1TranscriptsSearchData = {
+  /**
+   * Results per page
+   */
+  limit?: number;
+  /**
+   * Number of results to skip
+   */
+  offset?: number;
+  /**
+   * Search query text
+   */
+  q: string;
+  roomId?: string | null;
+};
+
+export type V1TranscriptsSearchResponse = SearchResponse;
+
 export type V1TranscriptGetData = {
   transcriptId: string;
 };
@@ -605,6 +754,96 @@ export type $OpenApiTs = {
       };
     };
   };
+  "/v1/rooms/{room_name}/ics/sync": {
+    post: {
+      req: V1RoomsSyncIcsData;
+      res: {
+        /**
+         * Successful Response
+         */
+        200: ICSSyncResult;
+        /**
+         * Validation Error
+         */
+        422: HTTPValidationError;
+      };
+    };
+  };
+  "/v1/rooms/{room_name}/ics/status": {
+    get: {
+      req: V1RoomsIcsStatusData;
+      res: {
+        /**
+         * Successful Response
+         */
+        200: ICSStatus;
+        /**
+         * Validation Error
+         */
+        422: HTTPValidationError;
+      };
+    };
+  };
+  "/v1/rooms/{room_name}/meetings": {
+    get: {
+      req: V1RoomsListMeetingsData;
+      res: {
+        /**
+         * Successful Response
+         */
+        200: Array<CalendarEventResponse>;
+        /**
+         * Validation Error
+         */
+        422: HTTPValidationError;
+      };
+    };
+  };
+  "/v1/rooms/{room_name}/meetings/upcoming": {
+    get: {
+      req: V1RoomsListUpcomingMeetingsData;
+      res: {
+        /**
+         * Successful Response
+         */
+        200: Array<CalendarEventResponse>;
+        /**
+         * Validation Error
+         */
+        422: HTTPValidationError;
+      };
+    };
+  };
+  "/v1/rooms/{room_name}/meetings/active": {
+    get: {
+      req: V1RoomsListActiveMeetingsData;
+      res: {
+        /**
+         * Successful Response
+         */
+        200: Array<Meeting>;
+        /**
+         * Validation Error
+         */
+        422: HTTPValidationError;
+      };
+    };
+  };
+  "/v1/rooms/{room_name}/meetings/{meeting_id}/join": {
+    post: {
+      req: V1RoomsJoinMeetingData;
+      res: {
+        /**
+         * Successful Response
+         */
+        200: Meeting;
+        /**
+         * Validation Error
+         */
+        422: HTTPValidationError;
+      };
+    };
+  };
   "/v1/transcripts": {
     get: {
       req: V1TranscriptsListData;
@@ -633,6 +872,21 @@ export type $OpenApiTs = {
       };
     };
   };
+  "/v1/transcripts/search": {
+    get: {
+      req: V1TranscriptsSearchData;
+      res: {
+        /**
+         * Successful Response
+         */
+        200: SearchResponse;
+        /**
+         * Validation Error
+         */
+        422: HTTPValidationError;
+      };
+    };
+  };
   "/v1/transcripts/{transcript_id}": {
     get: {
       req: V1TranscriptGetData;