chore(main): release 0.13.0 (#661)

* room form edit with enter

* mobile form enter do nothing

* restore overwritten older change

---------

Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>

CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## [0.13.0](https://github.com/Monadical-SAS/reflector/compare/v0.12.1...v0.13.0) (2025-09-19)
+
+
+### Features
+
+* room form edit with enter ([#662](https://github.com/Monadical-SAS/reflector/issues/662)) ([47716f6](https://github.com/Monadical-SAS/reflector/commit/47716f6e5ddee952609d2fa0ffabdfa865286796))
+
+
+### Bug Fixes
+
+* invalid cleanup call ([#660](https://github.com/Monadical-SAS/reflector/issues/660)) ([0abcebf](https://github.com/Monadical-SAS/reflector/commit/0abcebfc9491f87f605f21faa3e53996fafedd9a))
+
+## [0.12.1](https://github.com/Monadical-SAS/reflector/compare/v0.12.0...v0.12.1) (2025-09-17)
+
+
+### Bug Fixes
+
+* production blocked because having existing meeting with room_id null ([#657](https://github.com/Monadical-SAS/reflector/issues/657)) ([870e860](https://github.com/Monadical-SAS/reflector/commit/870e8605171a27155a9cbee215eeccb9a8d6c0a2))
+
+## [0.12.0](https://github.com/Monadical-SAS/reflector/compare/v0.11.0...v0.12.0) (2025-09-17)
+
+
+### Features
+
+* calendar integration ([#608](https://github.com/Monadical-SAS/reflector/issues/608)) ([6f680b5](https://github.com/Monadical-SAS/reflector/commit/6f680b57954c688882c4ed49f40f161c52a00a24))
+* self-hosted gpu api ([#636](https://github.com/Monadical-SAS/reflector/issues/636)) ([ab859d6](https://github.com/Monadical-SAS/reflector/commit/ab859d65a6bded904133a163a081a651b3938d42))
+
+
+### Bug Fixes
+
+* ignore player hotkeys for text inputs ([#646](https://github.com/Monadical-SAS/reflector/issues/646)) ([fa049e8](https://github.com/Monadical-SAS/reflector/commit/fa049e8d068190ce7ea015fd9fcccb8543f54a3f))
+
+## [0.11.0](https://github.com/Monadical-SAS/reflector/compare/v0.10.0...v0.11.0) (2025-09-16)
+
+
+### Features
+
+* remove profanity filter that was there for conference ([#652](https://github.com/Monadical-SAS/reflector/issues/652)) ([b42f7cf](https://github.com/Monadical-SAS/reflector/commit/b42f7cfc606783afcee792590efcc78b507468ab))
+
+
+### Bug Fixes
+
+* zulip and consent handler on the file pipeline ([#645](https://github.com/Monadical-SAS/reflector/issues/645)) ([5f143fe](https://github.com/Monadical-SAS/reflector/commit/5f143fe3640875dcb56c26694254a93189281d17))
+* zulip stream and topic selection in share dialog ([#644](https://github.com/Monadical-SAS/reflector/issues/644)) ([c546e69](https://github.com/Monadical-SAS/reflector/commit/c546e69739e68bb74fbc877eb62609928e5b8de6))
+
 ## [0.10.0](https://github.com/Monadical-SAS/reflector/compare/v0.9.0...v0.10.0) (2025-09-11)
 
 

docs/jitsi.md

@@ -1,369 +0,0 @@
-# Jitsi Integration for Reflector
-
-This document contains research and planning notes for integrating Jitsi Meet as a replacement for Whereby in Reflector.
-
-## Overview
-
-Jitsi Meet is an open-source video conferencing solution that can replace Whereby in Reflector, providing:
-- Cost reduction (no per-minute charges)
-- Direct recording access via Jibri
-- Real-time event webhooks
-- Full customization and control
-
-## Current Whereby Integration Analysis
-
-### Architecture
-1. **Room Creation**: User creates a "room" template in Reflector DB with settings
-2. **Meeting Creation**: `/rooms/{room_name}/meeting` endpoint calls Whereby API to create meeting
-3. **Recording**: Whereby handles recording automatically to S3 bucket
-4. **Webhooks**: Whereby sends events for participant tracking
-
-### Database Structure
-```python
-# Room = Template/Configuration
-class Room:
-    id, name, user_id
-    recording_type, recording_trigger  # cloud, automatic-2nd-participant
-    webhook_url, webhook_secret
-
-# Meeting = Actual Whereby Meeting Instance
-class Meeting:
-    id  # Whereby meetingId
-    room_name  # Generated by Whereby
-    room_url, host_room_url  # Whereby URLs
-    num_clients  # Updated via webhooks
-```
-
-## Jitsi Components
-
-### Core Architecture
-- **Jitsi Meet**: Web frontend (Next.js + React)
-- **Prosody**: XMPP server for messaging/rooms
-- **Jicofo**: Conference focus (orchestration)
-- **JVB**: Videobridge (media routing)
-- **Jibri**: Recording service
-- **Jigasi**: SIP gateway (optional, for phone dial-in)
-
-### Exposure Requirements
-- **Web service**: 443/80 (frontend)
-- **JVB**: 10000/UDP (media streams) - **MUST EXPOSE**
-- **Prosody**: 5280 (BOSH/WebSocket) - can proxy via web
-- **Jicofo, Jibri, Jigasi**: Internal only
-
-## Recording with Jibri
-
-### How Jibri Works
-- Each Jibri instance handles **one recording at a time**
-- Records mixed audio/video to MP4 format
-- Uses Chrome headless + ffmpeg for capture
-- Supports finalize scripts for post-processing
-
-### Jibri Pool for Scaling
-- Multiple Jibri instances join "jibribrewery" MUC
-- Jicofo distributes recording requests to available instances
-- Automatic load balancing and failover
-
-```yaml
-# Multiple Jibri instances
-jibri1:
-  environment:
-    - JIBRI_INSTANCE_ID=jibri1
-    - JIBRI_BREWERY_MUC=jibribrewery
-
-jibri2:
-  environment:
-    - JIBRI_INSTANCE_ID=jibri2
-    - JIBRI_BREWERY_MUC=jibribrewery
-```
-
-### Recording Automation Options
-1. **Environment Variables**: `ENABLE_RECORDING=1`, `AUTO_RECORDING=1`
-2. **URL Parameters**: `?config.autoRecord=true`
-3. **JWT Token**: Include recording permissions in JWT
-4. **API Control**: `api.executeCommand('startRecording')`
-
-### Post-Processing Integration
-```bash
-#!/bin/bash
-# finalize.sh - runs after recording completion
-RECORDING_FILE=$1
-MEETING_METADATA=$2
-ROOM_NAME=$3
-
-# Copy to Reflector-accessible location
-cp "$RECORDING_FILE" /shared/reflector-uploads/
-
-# Trigger Reflector processing
-curl -X POST "http://reflector-api:8000/v1/transcripts/process" \
-  -H "Content-Type: application/json" \
-  -d "{
-    \"file_path\": \"/shared/reflector-uploads/$(basename $RECORDING_FILE)\",
-    \"room_name\": \"$ROOM_NAME\",
-    \"source\": \"jitsi\"
-  }"
-```
-
-## React Integration
-
-### Official React SDK
-```bash
-npm i @jitsi/react-sdk
-```
-
-```jsx
-import { JitsiMeeting } from '@jitsi/react-sdk'
-
-<JitsiMeeting
-  room="meeting-room"
-  serverURL="https://your-jitsi.domain"
-  jwt="your-jwt-token"
-  config={{
-    startWithAudioMuted: true,
-    fileRecordingsEnabled: true,
-    autoRecord: true
-  }}
-  onParticipantJoined={(participant) => {
-    // Track participant events
-  }}
-  onRecordingStatusChanged={(status) => {
-    // Handle recording events
-  }}
-/>
-```
-
-## Authentication & Room Control
-
-### JWT-Based Access Control
-```python
-def generate_jitsi_jwt(payload):
-    return jwt.encode({
-        "aud": "jitsi",
-        "iss": "reflector",
-        "sub": "reflector-user",
-        "room": payload["room"],
-        "exp": int(payload["exp"].timestamp()),
-        "context": {
-            "user": {
-                "name": payload["user_name"],
-                "moderator": payload.get("moderator", False)
-            },
-            "features": {
-                "recording": payload.get("recording", True)
-            }
-        }
-    }, JITSI_JWT_SECRET)
-```
-
-### Prevent Anonymous Room Creation
-```bash
-# Environment configuration
-ENABLE_AUTH=1
-ENABLE_GUESTS=0
-AUTH_TYPE=jwt
-JWT_APP_ID=reflector
-JWT_APP_SECRET=your-secret-key
-```
-
-## Webhook Integration
-
-### Real-time Events via Prosody
-Custom event-sync module can send webhooks for:
-- Participant join/leave
-- Recording start/stop
-- Room creation/destruction
-- Mute/unmute events
-
-```lua
--- mod_event_sync.lua
-module:hook("muc-occupant-joined", function(event)
-    send_event({
-        type = "participant_joined",
-        room = event.room.jid,
-        participant = {
-            nick = event.occupant.nick,
-            jid = event.occupant.jid,
-        },
-        timestamp = os.time(),
-    });
-end);
-```
-
-### Jibri Recording Webhooks
-```bash
-# Environment variable
-JIBRI_WEBHOOK_SUBSCRIBERS=https://your-reflector.com/webhooks/jibri
-```
-
-## Proposed Reflector Integration
-
-### Modified Database Schema
-```python
-class Meeting(BaseModel):
-    id: str  # Our generated meeting ID
-    room_name: str  # Generated: reflector-{room.name}-{timestamp}
-    room_url: str  # https://jitsi.domain/room_name?jwt=token
-    host_room_url: str  # Same but with moderator JWT
-    # Add Jitsi-specific fields
-    jitsi_jwt: str  # JWT token
-    jitsi_room_id: str  # Internal room identifier
-    recording_status: str  # pending, recording, completed
-    recording_file_path: Optional[str]
-```
-
-### API Replacement
-```python
-# Replace whereby.py with jitsi.py
-async def create_meeting(room_name_prefix: str, end_date: datetime, room: Room):
-    # Generate unique room name
-    jitsi_room = f"reflector-{room.name}-{int(time.time())}"
-
-    # Generate JWT tokens
-    user_jwt = generate_jwt(room=jitsi_room, moderator=False, exp=end_date)
-    host_jwt = generate_jwt(room=jitsi_room, moderator=True, exp=end_date)
-
-    return {
-        "meetingId": generate_uuid4(),  # Our ID
-        "roomName": jitsi_room,
-        "roomUrl": f"https://jitsi.domain/{jitsi_room}?jwt={user_jwt}",
-        "hostRoomUrl": f"https://jitsi.domain/{jitsi_room}?jwt={host_jwt}",
-        "startDate": datetime.now().isoformat(),
-        "endDate": end_date.isoformat(),
-    }
-```
-
-### Webhook Endpoints
-```python
-# Replace whereby webhook with jitsi webhooks
-@router.post("/jitsi/events")
-async def jitsi_events_webhook(event_data: dict):
-    event_type = event_data.get("event")
-    room_name = event_data.get("room", "").split("@")[0]
-
-    meeting = await Meeting.get_by_room(room_name)
-
-    if event_type == "muc-occupant-joined":
-        # Update participant count
-        meeting.num_clients += 1
-
-    elif event_type == "jibri-recording-on":
-        meeting.recording_status = "recording"
-
-    elif event_type == "jibri-recording-off":
-        meeting.recording_status = "processing"
-        await process_meeting_recording.delay(meeting.id)
-
-@router.post("/jibri/recording-complete")
-async def recording_complete(data: dict):
-    # Handle finalize script webhook
-    room_name = data.get("room_name")
-    file_path = data.get("file_path")
-
-    meeting = await Meeting.get_by_room(room_name)
-    meeting.recording_file_path = file_path
-    meeting.recording_status = "completed"
-
-    # Start Reflector processing
-    await process_recording_for_transcription(meeting.id, file_path)
-```
-
-## Deployment with Docker
-
-### Official docker-jitsi-meet
-```bash
-# Download official release
-wget $(wget -q -O - https://api.github.com/repos/jitsi/docker-jitsi-meet/releases/latest | grep zip | cut -d\" -f4)
-
-# Setup
-mkdir -p ~/.jitsi-meet-cfg/{web,transcripts,prosody/config,prosody/prosody-plugins-custom,jicofo,jvb,jigasi,jibri}
-./gen-passwords.sh  # Generate secure passwords
-docker compose up -d
-```
-
-### Coolify Integration
-```yaml
-services:
-  web:
-    ports: ["80:80", "443:443"]
-  jvb:
-    ports: ["10000:10000/udp"]  # Must expose for media
-  jibri1:
-    environment:
-      - JIBRI_INSTANCE_ID=jibri1
-      - JIBRI_FINALIZE_RECORDING_SCRIPT_PATH=/config/finalize.sh
-  jibri2:
-    environment:
-      - JIBRI_INSTANCE_ID=jibri2
-```
-
-## Benefits vs Whereby
-
-### Cost & Control
-✅ **No per-minute charges** - significant cost savings
-✅ **Full recording control** - direct file access
-✅ **Custom branding** - complete UI control
-✅ **Self-hosted** - no vendor lock-in
-
-### Technical Advantages
-✅ **Real-time events** - immediate webhook notifications
-✅ **Rich participant metadata** - detailed tracking
-✅ **JWT security** - token-based access with expiration
-✅ **Multiple recording formats** - audio-only options
-✅ **Scalable architecture** - horizontal Jibri scaling
-
-### Integration Benefits
-✅ **Same API surface** - minimal changes to existing code
-✅ **React SDK** - better frontend integration
-✅ **Direct processing** - no S3 download delays
-✅ **Event-driven architecture** - better real-time capabilities
-
-## Implementation Plan
-
-1. **Deploy Jitsi Stack** - Set up docker-jitsi-meet with multiple Jibri instances
-2. **Create jitsi.py** - Replace whereby.py with Jitsi API functions
-3. **Update Database** - Add Jitsi-specific fields to Meeting model
-4. **Webhook Integration** - Replace Whereby webhooks with Jitsi events
-5. **Frontend Updates** - Replace Whereby embed with Jitsi React SDK
-6. **Testing & Migration** - Gradual rollout with fallback to Whereby
-
-## Recording Limitations & Considerations
-
-### Current Limitations
-- **Mixed audio only** - Jibri doesn't separate participant tracks natively
-- **One recording per Jibri** - requires multiple instances for concurrent recordings
-- **Chrome dependency** - Jibri uses headless Chrome for recording
-
-### Metadata Capabilities
-✅ **Participant join/leave timestamps** - via webhooks
-✅ **Speaking time tracking** - via audio level events
-✅ **Meeting duration** - precise timing
-✅ **Room-specific data** - custom metadata in JWT
-
-### Alternative Recording Methods
-- **Local recording** - browser-based, per-participant
-- **Custom recording** - lib-jitsi-meet for individual streams
-- **Third-party solutions** - Recall.ai, Otter.ai integrations
-
-## Security Considerations
-
-### JWT Configuration
-- **Room-specific tokens** - limit access to specific rooms
-- **Time-based expiration** - automatic cleanup
-- **Feature permissions** - control recording, moderation rights
-- **User identification** - embed user metadata in tokens
-
-### Access Control
-- **No anonymous rooms** - all rooms require valid JWT
-- **API-only creation** - prevent direct room access
-- **Webhook verification** - HMAC signature validation
-
-## Next Steps
-
-1. **Deploy test Jitsi instance** - validate recording pipeline
-2. **Prototype jitsi.py** - create equivalent API functions
-3. **Test webhook integration** - ensure event delivery works
-4. **Performance testing** - validate multiple concurrent recordings
-5. **Migration strategy** - plan gradual transition from Whereby
-
----
-
-*This document serves as the comprehensive planning and research notes for Jitsi integration in Reflector. It should be updated as implementation progresses and new insights are discovered.*

docs/video-jitsi.md

@@ -1,720 +0,0 @@
-# Jitsi Meet Integration Configuration Guide
-
-This guide explains how to configure Reflector to use your self-hosted Jitsi Meet installation for video meetings, recording, and participant tracking.
-
-## Overview
-
-Jitsi Meet is an open-source video conferencing platform that can be self-hosted. Reflector integrates with Jitsi Meet to:
-
-- Create secure meeting rooms with JWT authentication
-- Track participant join/leave events via Prosody webhooks
-- Record meetings using Jibri recording service
-- Process recordings for transcription and analysis
-
-## Requirements
-
-### Self-Hosted Jitsi Meet
-
-You need a complete Jitsi Meet installation including:
-
-1. **Jitsi Meet Web Interface** - The main meeting interface
-2. **Prosody XMPP Server** - Handles room management and authentication
-3. **Jicofo (JItsi COnference FOcus)** - Manages media sessions
-4. **Jitsi Videobridge (JVB)** - Handles WebRTC media routing
-5. **Jibri Recording Service** - Records meetings (optional but recommended)
-
-### System Requirements
-
-- **Domain with SSL Certificate** - Required for WebRTC functionality
-- **Prosody mod_event_sync** - For webhook event handling
-- **JWT Authentication** - For secure room access control
-- **Storage Solution** - For recording files (local or cloud)
-
-## Configuration Variables
-
-Add the following environment variables to your Reflector `.env` file:
-
-### Required Variables
-
-```bash
-# Jitsi Meet Domain (without https://)
-JITSI_DOMAIN=meet.example.com
-
-# JWT Secret for room authentication (generate with: openssl rand -hex 32)
-JITSI_JWT_SECRET=your-64-character-hex-secret-here
-
-# Webhook secret for event handling (generate with: openssl rand -hex 16)
-JITSI_WEBHOOK_SECRET=your-32-character-hex-secret-here
-```
-
-### Optional Variables
-
-```bash
-# Application identifier (should match Jitsi configuration)
-JITSI_APP_ID=reflector
-
-# JWT issuer and audience (should match Jitsi configuration)
-JITSI_JWT_ISSUER=reflector
-JITSI_JWT_AUDIENCE=jitsi
-```
-
-## Installation Steps
-
-### 1. Jitsi Meet Server Installation
-
-#### Quick Installation (Ubuntu/Debian)
-
-```bash
-# Add Jitsi repository
-curl -fsSL https://download.jitsi.org/jitsi-key.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/jitsi-keyring.gpg
-echo "deb [signed-by=/usr/share/keyrings/jitsi-keyring.gpg] https://download.jitsi.org stable/" | sudo tee /etc/apt/sources.list.d/jitsi-stable.list
-
-# Install Jitsi Meet
-sudo apt update
-sudo apt install jitsi-meet
-
-# Configure SSL certificate
-sudo /usr/share/jitsi-meet/scripts/install-letsencrypt-cert.sh
-```
-
-#### Docker Installation
-
-```bash
-# Clone Jitsi Docker repository
-git clone https://github.com/jitsi/docker-jitsi-meet
-cd docker-jitsi-meet
-
-# Copy environment template
-cp env.example .env
-
-# Edit configuration
-nano .env
-
-# Start services
-docker-compose up -d
-```
-
-### 2. JWT Authentication Setup
-
-#### Update Prosody Configuration
-
-Edit `/etc/prosody/conf.d/your-domain.cfg.lua`:
-
-```lua
-VirtualHost "meet.example.com"
-    authentication = "token"
-    app_id = "reflector"
-    app_secret = "your-jwt-secret-here"
-
-    -- Allow anonymous access for guests
-    c2s_require_encryption = false
-    admins = { "focusUser@auth.meet.example.com" }
-
-    modules_enabled = {
-        "bosh";
-        "pubsub";
-        "ping";
-        "roster";
-        "saslauth";
-        "tls";
-        "dialback";
-        "disco";
-        "carbons";
-        "pep";
-        "private";
-        "blocklist";
-        "vcard";
-        "version";
-        "uptime";
-        "time";
-        "ping";
-        "register";
-        "admin_adhoc";
-        "token_verification";
-        "event_sync";  -- Required for webhooks
-    }
-```
-
-#### Configure Jitsi Meet Interface
-
-Edit `/etc/jitsi/meet/your-domain-config.js`:
-
-```javascript
-var config = {
-    hosts: {
-        domain: 'meet.example.com',
-        muc: 'conference.meet.example.com'
-    },
-
-    // Enable JWT authentication
-    enableUserRolesBasedOnToken: true,
-
-    // Recording configuration
-    fileRecordingsEnabled: true,
-    liveStreamingEnabled: false,
-
-    // Reflector integration settings
-    prejoinPageEnabled: true,
-    requireDisplayName: true
-};
-```
-
-### 3. Webhook Event Configuration
-
-#### Install Event Sync Module
-
-```bash
-# Download the module
-cd /usr/share/jitsi-meet/prosody-plugins/
-wget https://raw.githubusercontent.com/jitsi-contrib/prosody-plugins/main/mod_event_sync.lua
-```
-
-#### Configure Event Sync
-
-Add to your Prosody configuration:
-
-```lua
-Component "conference.meet.example.com" "muc"
-    storage = "memory"
-    modules_enabled = {
-        "muc_meeting_id";
-        "muc_domain_mapper";
-        "polls";
-        "event_sync";  -- Enable event sync
-    }
-
-    -- Event sync webhook configuration
-    event_sync_url = "https://your-reflector-domain.com/v1/jitsi/events"
-    event_sync_secret = "your-webhook-secret-here"
-
-    -- Events to track
-    event_sync_events = {
-        "muc-occupant-joined",
-        "muc-occupant-left",
-        "jibri-recording-on",
-        "jibri-recording-off"
-    }
-
-#### Webhook Event Payload Examples
-
-**Participant Joined Event:**
-```json
-{
-  "event": "muc-occupant-joined",
-  "room": "reflector-my-room-uuid123",
-  "timestamp": "2025-01-15T10:30:00.000Z",
-  "data": {
-    "occupant_id": "participant-456",
-    "nick": "John Doe",
-    "role": "participant",
-    "affiliation": "none"
-  }
-}
-```
-
-**Recording Started Event:**
-```json
-{
-  "event": "jibri-recording-on",
-  "room": "reflector-my-room-uuid123",
-  "timestamp": "2025-01-15T10:32:00.000Z",
-  "data": {
-    "recording_id": "rec-789",
-    "initiator": "moderator-123"
-  }
-}
-```
-
-**Recording Completed Event:**
-```json
-{
-  "room_name": "reflector-my-room-uuid123",
-  "recording_file": "/var/recordings/rec-789.mp4",
-  "recording_status": "completed",
-  "timestamp": "2025-01-15T11:15:00.000Z"
-}
-```
-
-### 4. Jibri Recording Setup (Optional)
-
-#### Install Jibri
-
-```bash
-# Install Jibri package
-sudo apt install jibri
-
-# Create recording directory
-sudo mkdir -p /var/recordings
-sudo chown jibri:jibri /var/recordings
-```
-
-#### Configure Jibri
-
-Edit `/etc/jitsi/jibri/jibri.conf`:
-
-```hocon
-jibri {
-    recording {
-        recordings-directory = "/var/recordings"
-        finalize-script = "/opt/jitsi/jibri/finalize.sh"
-    }
-
-    api {
-        xmpp {
-            environments = [{
-                name = "prod environment"
-                xmpp-server-hosts = ["meet.example.com"]
-                xmpp-domain = "meet.example.com"
-
-                control-muc {
-                    domain = "internal.auth.meet.example.com"
-                    room-name = "JibriBrewery"
-                    nickname = "jibri-nickname"
-                }
-
-                control-login {
-                    domain = "auth.meet.example.com"
-                    username = "jibri"
-                    password = "jibri-password"
-                }
-            }]
-        }
-    }
-}
-```
-
-#### Create Finalize Script
-
-Create `/opt/jitsi/jibri/finalize.sh`:
-
-```bash
-#!/bin/bash
-# Jibri finalize script for Reflector integration
-
-RECORDING_FILE="$1"
-ROOM_NAME="$2"
-REFLECTOR_API_URL="${REFLECTOR_API_URL:-http://localhost:1250}"
-
-# Prepare webhook payload
-TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)
-PAYLOAD=$(cat <<EOF
-{
-    "room_name": "$ROOM_NAME",
-    "recording_file": "$RECORDING_FILE",
-    "recording_status": "completed",
-    "timestamp": "$TIMESTAMP"
-}
-EOF
-)
-
-# Generate signature
-SIGNATURE=$(echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "$JITSI_WEBHOOK_SECRET" | cut -d' ' -f2)
-
-# Send webhook to Reflector
-curl -X POST "$REFLECTOR_API_URL/v1/jibri/recording-complete" \
-    -H "Content-Type: application/json" \
-    -H "X-Jitsi-Signature: $SIGNATURE" \
-    -d "$PAYLOAD"
-
-echo "Recording finalization webhook sent for room: $ROOM_NAME"
-```
-
-Make executable:
-```bash
-sudo chmod +x /opt/jitsi/jibri/finalize.sh
-```
-
-### 5. Restart Services
-
-After configuration changes:
-
-```bash
-sudo systemctl restart prosody
-sudo systemctl restart jicofo
-sudo systemctl restart jitsi-videobridge2
-sudo systemctl restart jibri
-sudo systemctl restart nginx
-```
-
-## Room Configuration
-
-### Creating Jitsi Rooms
-
-Create rooms with Jitsi platform in Reflector:
-
-```bash
-curl -X POST "https://your-reflector-domain.com/v1/rooms" \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer $AUTH_TOKEN" \
-  -d '{
-    "name": "my-jitsi-room",
-    "platform": "jitsi",
-    "recording_type": "cloud",
-    "recording_trigger": "automatic-2nd-participant",
-    "is_locked": false,
-    "room_mode": "normal"
-  }'
-```
-
-### Meeting Creation
-
-Meetings automatically use JWT authentication:
-
-```bash
-curl -X POST "https://your-reflector-domain.com/v1/rooms/my-jitsi-room/meeting" \
-  -H "Authorization: Bearer $AUTH_TOKEN"
-```
-
-Response includes JWT-authenticated URLs:
-```json
-{
-  "id": "meeting-uuid",
-  "room_name": "reflector-my-jitsi-room-123456",
-  "room_url": "https://meet.example.com/room?jwt=user-token",
-  "host_room_url": "https://meet.example.com/room?jwt=moderator-token"
-}
-```
-
-## Features and Capabilities
-
-### JWT Authentication
-
-Reflector automatically generates JWT tokens with:
-- **Room Access Control** - Secure room entry
-- **User Roles** - Moderator vs participant permissions
-- **Expiration** - Configurable token lifetime (default 8 hours)
-- **Custom Claims** - Room-specific metadata
-
-### Recording Options
-
-**Recording Types:**
-- `"none"` - No recording
-- `"local"` - Local Jibri recording
-- `"cloud"` - Cloud recording (requires external storage)
-
-**Recording Triggers:**
-- `"none"` - Manual recording only
-- `"prompt"` - Prompt users to start
-- `"automatic"` - Start immediately
-- `"automatic-2nd-participant"` - Start when 2nd person joins
-
-### Event Tracking and Storage
-
-Reflector automatically stores all webhook events in the `meetings` table for comprehensive meeting analytics:
-
-**Supported Event Types:**
-- `muc-occupant-joined` - Participant joined the meeting
-- `muc-occupant-left` - Participant left the meeting
-- `jibri-recording-on` - Recording started
-- `jibri-recording-off` - Recording stopped
-- `recording_completed` - Recording file ready for processing
-
-**Event Storage Structure:**
-Each webhook event is stored as a JSON object in the `meetings.events` column:
-```json
-{
-  "type": "muc-occupant-joined",
-  "timestamp": "2025-01-15T10:30:00.123456Z",
-  "data": {
-    "timestamp": "2025-01-15T10:30:00Z",
-    "user_id": "participant-123",
-    "display_name": "John Doe"
-  }
-}
-```
-
-**Querying Stored Events:**
-```sql
--- Get all events for a meeting
-SELECT events FROM meeting WHERE id = 'meeting-uuid';
-
--- Count participant joins
-SELECT json_array_length(
-  json_extract(events, '$[*] ? (@.type == "muc-occupant-joined")')
-) as total_joins FROM meeting WHERE id = 'meeting-uuid';
-```
-
-## Testing and Verification
-
-### Health Check
-
-Test Jitsi webhook integration:
-
-```bash
-curl "https://your-reflector-domain.com/v1/jitsi/health"
-```
-
-Expected response:
-```json
-{
-    "status": "ok",
-    "service": "jitsi-webhooks",
-    "timestamp": "2025-01-15T10:30:00.000Z",
-    "webhook_secret_configured": true
-}
-```
-
-### JWT Token Testing
-
-Verify JWT generation works:
-```bash
-# Create a test meeting
-MEETING=$(curl -X POST "https://your-reflector-domain.com/v1/rooms/test-room/meeting" \
-  -H "Authorization: Bearer $AUTH_TOKEN" | jq -r '.room_url')
-
-echo "Test meeting URL: $MEETING"
-```
-
-### Webhook Testing
-
-#### Manual Webhook Event Testing
-
-Test participant join event:
-```bash
-# Generate proper signature
-PAYLOAD='{"event":"muc-occupant-joined","room":"reflector-test-room-uuid","timestamp":"2025-01-15T10:30:00.000Z","data":{"user_id":"test-user","display_name":"Test User"}}'
-SIGNATURE=$(echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "$JITSI_WEBHOOK_SECRET" | cut -d' ' -f2)
-
-curl -X POST "https://your-reflector-domain.com/v1/jitsi/events" \
-  -H "Content-Type: application/json" \
-  -H "X-Jitsi-Signature: $SIGNATURE" \
-  -d "$PAYLOAD"
-```
-
-Expected response:
-```json
-{
-  "status": "ok",
-  "event": "muc-occupant-joined",
-  "room": "reflector-test-room-uuid"
-}
-```
-
-#### Recording Webhook Testing
-
-Test recording completion event:
-```bash
-PAYLOAD='{"room_name":"reflector-test-room-uuid","recording_file":"/recordings/test.mp4","recording_status":"completed","timestamp":"2025-01-15T10:30:00.000Z"}'
-SIGNATURE=$(echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "$JITSI_WEBHOOK_SECRET" | cut -d' ' -f2)
-
-curl -X POST "https://your-reflector-domain.com/v1/jibri/recording-complete" \
-  -H "Content-Type: application/json" \
-  -H "X-Jitsi-Signature: $SIGNATURE" \
-  -d "$PAYLOAD"
-```
-
-#### Event Storage Verification
-
-Verify events were stored:
-```bash
-# Check meeting events via API (requires authentication)
-curl -H "Authorization: Bearer $AUTH_TOKEN" \
-  "https://your-reflector-domain.com/v1/meetings/{meeting-id}"
-```
-
-## Troubleshooting
-
-### Common Issues
-
-#### JWT Authentication Failures
-
-**Symptoms**: Users cannot join rooms, "Authentication failed" errors
-
-**Solutions**:
-1. Verify `JITSI_JWT_SECRET` matches Prosody configuration
-2. Check JWT token hasn't expired (default 8 hours)
-3. Ensure system clocks are synchronized between servers
-4. Validate JWT issuer/audience configuration matches
-
-**Debug JWT tokens**:
-```bash
-# Decode JWT payload
-echo "JWT_TOKEN_HERE" | cut -d'.' -f2 | base64 -d | jq
-```
-
-#### Webhook Events Not Received
-
-**Symptoms**: Participant counts not updating, no recording events
-
-**Solutions**:
-1. Verify `mod_event_sync` is loaded in Prosody
-2. Check webhook URL is accessible from Jitsi server
-3. Validate webhook signature generation
-4. Review Prosody and Reflector logs
-
-**Debug webhook connectivity**:
-```bash
-# Test from Jitsi server
-curl -v "https://your-reflector-domain.com/v1/jitsi/health"
-
-# Check Prosody logs
-sudo tail -f /var/log/prosody/prosody.log
-```
-
-#### Webhook Signature Verification Issues
-
-**Symptoms**: HTTP 401 "Invalid webhook signature" errors
-
-**Solutions**:
-1. Verify webhook secret matches between Jitsi and Reflector
-2. Check payload encoding (no extra whitespace)
-3. Ensure proper HMAC-SHA256 signature generation
-
-**Debug signature generation**:
-```bash
-# Test signature manually
-PAYLOAD='{"event":"test","room":"test","timestamp":"2025-01-15T10:30:00.000Z","data":{}}'
-SECRET="your-webhook-secret-here"
-
-# Generate signature (should match X-Jitsi-Signature header)
-echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "$SECRET" | cut -d' ' -f2
-
-# Test with curl
-curl -X POST "https://your-reflector-domain.com/v1/jitsi/events" \
-  -H "Content-Type: application/json" \
-  -H "X-Jitsi-Signature: $(echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "$SECRET" | cut -d' ' -f2)" \
-  -d "$PAYLOAD" -v
-```
-
-#### Event Storage Problems
-
-**Symptoms**: Events received but not stored in database
-
-**Solutions**:
-1. Check database connectivity and permissions
-2. Verify meeting exists before event processing
-3. Review Reflector application logs
-4. Ensure JSON column support in database
-
-**Debug event storage**:
-```bash
-# Check meeting exists
-curl -H "Authorization: Bearer $TOKEN" \
-  "https://your-reflector-domain.com/v1/meetings/{meeting-id}"
-
-# Monitor database queries (if using PostgreSQL)
-sudo -u postgres psql -c "SELECT * FROM pg_stat_activity WHERE query LIKE '%meeting%';"
-
-# Check Reflector logs for event processing
-sudo journalctl -u reflector -f | grep -E "(event|webhook|jitsi)"
-```
-
-#### Recording Issues
-
-**Symptoms**: Recordings not starting, finalize script errors
-
-**Solutions**:
-1. Verify Jibri service status: `sudo systemctl status jibri`
-2. Check recording directory permissions: `/var/recordings`
-3. Validate finalize script execution permissions
-4. Monitor Jibri logs: `sudo journalctl -u jibri -f`
-
-**Test finalize script**:
-```bash
-sudo -u jibri /opt/jitsi/jibri/finalize.sh "/test/recording.mp4" "test-room"
-```
-
-#### Meeting Creation Failures
-
-**Symptoms**: HTTP 500 errors when creating meetings
-
-**Solutions**:
-1. Check Reflector logs for JWT generation errors
-2. Verify all required environment variables are set
-3. Ensure Jitsi domain is accessible from Reflector
-4. Test JWT secret configuration
-
-### Debug Commands
-
-```bash
-# Verify Prosody configuration
-sudo prosodyctl check config
-
-# Check Jitsi services status
-sudo systemctl status prosody jicofo jitsi-videobridge2
-
-# Test JWT generation
-curl -X POST "https://your-reflector-domain.com/v1/rooms/test/meeting" \
-  -H "Authorization: Bearer $TOKEN" -v
-
-# Monitor webhook events
-sudo tail -f /var/log/reflector/app.log | grep jitsi
-
-# Check SSL certificates
-sudo certbot certificates
-```
-
-### Performance Optimization
-
-#### Scaling Considerations
-
-**Single Server Limits:**
-- ~50 concurrent participants per JVB instance
-- ~10 concurrent Jibri recordings
-- CPU and bandwidth become bottlenecks
-
-**Multi-Server Setup:**
-- Multiple JVB instances for scaling
-- Dedicated Jibri recording servers
-- Load balancing for high availability
-
-#### Resource Monitoring
-
-```bash
-# Monitor JVB performance
-sudo systemctl status jitsi-videobridge2
-sudo journalctl -u jitsi-videobridge2 -f
-
-# Check Prosody connections
-sudo prosodyctl mod_admin_telnet
-> c2s:show()
-> muc:rooms()
-```
-
-## Security Best Practices
-
-### JWT Security
-- Use strong, unique secrets (32+ characters)
-- Rotate JWT secrets regularly
-- Implement proper token expiration
-- Never log or expose JWT tokens
-
-### Network Security
-- Use HTTPS/WSS for all communications
-- Implement proper firewall rules
-- Consider VPN for server-to-server communication
-- Monitor for unauthorized access attempts
-
-### Recording Security
-- Encrypt recordings at rest
-- Implement access controls for recording files
-- Regular security audits of file permissions
-- Comply with data protection regulations
-
-## Migration from Whereby
-
-If migrating from Whereby to Jitsi:
-
-1. **Parallel Setup** - Configure Jitsi alongside existing Whereby
-2. **Room Migration** - Update room platform field to "jitsi"
-3. **Test Integration** - Verify meeting creation and webhooks
-4. **User Training** - Different UI and feature set
-5. **Monitor Performance** - Watch for issues during transition
-6. **Cleanup** - Remove Whereby configuration when stable
-
-## Support and Resources
-
-### Jitsi Community Resources
-- **Documentation**: [jitsi.github.io/handbook](https://jitsi.github.io/handbook/)
-- **Community Forum**: [community.jitsi.org](https://community.jitsi.org/)
-- **GitHub Issues**: [github.com/jitsi/jitsi-meet](https://github.com/jitsi/jitsi-meet)
-
-### Professional Support
-- **8x8 Commercial Support** - Professional Jitsi hosting and support
-- **Community Consulting** - Third-party Jitsi implementation services
-
-### Monitoring and Maintenance
-- Monitor system resources (CPU, memory, bandwidth)
-- Regular security updates for all components
-- Backup configuration files and certificates
-- Test disaster recovery procedures

docs/video-whereby.md

@@ -1,276 +0,0 @@
-# Whereby Integration Configuration Guide
-
-This guide explains how to configure Reflector to use Whereby as your video meeting platform for room creation, recording, and participant tracking.
-
-## Overview
-
-Whereby is a browser-based video meeting platform that provides hosted meeting rooms with recording capabilities. Reflector integrates with Whereby's API to:
-
-- Create secure meeting rooms with custom branding
-- Handle participant join/leave events via webhooks
-- Automatically record meetings to AWS S3 storage
-- Track meeting sessions and participant counts
-
-## Requirements
-
-### Whereby Account Setup
-
-1. **Whereby Account**: Sign up for a Whereby business account at [whereby.com](https://whereby.com/business)
-2. **API Access**: Request API access from Whereby support (required for programmatic room creation)
-3. **Webhook Configuration**: Configure webhooks in your Whereby dashboard to point to your Reflector instance
-
-### AWS S3 Storage
-
-Whereby requires AWS S3 for recording storage. You need:
-- AWS account with S3 access
-- Dedicated S3 bucket for Whereby recordings
-- AWS IAM credentials with S3 write permissions
-
-## Configuration Variables
-
-Add the following environment variables to your Reflector `.env` file:
-
-### Required Variables
-
-```bash
-# Whereby API Configuration
-WHEREBY_API_KEY=your-whereby-jwt-api-key
-WHEREBY_WEBHOOK_SECRET=your-webhook-secret-from-whereby
-
-# AWS S3 Storage for Recordings
-AWS_WHEREBY_ACCESS_KEY_ID=your-aws-access-key
-AWS_WHEREBY_ACCESS_KEY_SECRET=your-aws-secret-key
-RECORDING_STORAGE_AWS_BUCKET_NAME=your-s3-bucket-name
-```
-
-### Optional Variables
-
-```bash
-# Whereby API URL (defaults to production)
-WHEREBY_API_URL=https://api.whereby.dev/v1
-
-# SQS Configuration (for recording processing)
-AWS_PROCESS_RECORDING_QUEUE_URL=https://sqs.region.amazonaws.com/account/queue
-SQS_POLLING_TIMEOUT_SECONDS=60
-```
-
-## Configuration Steps
-
-### 1. Whereby API Key Setup
-
-1. **Contact Whereby Support** to request API access for your account
-2. **Generate JWT Token** in your Whereby dashboard under API settings
-3. **Copy the JWT token** and set it as `WHEREBY_API_KEY` in your environment
-
-The API key is a JWT token that looks like:
-```
-eyJ[...truncated JWT token...]
-```
-
-### 2. Webhook Configuration
-
-1. **Access Whereby Dashboard** and navigate to webhook settings
-2. **Set Webhook URL** to your Reflector instance:
-   ```
-   https://your-reflector-domain.com/v1/whereby
-   ```
-3. **Configure Events** to send the following event types:
-   - `room.client.joined` - When participants join
-   - `room.client.left` - When participants leave
-4. **Generate Webhook Secret** and set it as `WHEREBY_WEBHOOK_SECRET`
-5. **Save Configuration** in your Whereby dashboard
-
-### 3. AWS S3 Storage Setup
-
-1. **Create S3 Bucket** dedicated for Whereby recordings
-2. **Create IAM User** with programmatic access
-3. **Attach S3 Policy** with the following permissions:
-   ```json
-   {
-     "Version": "2012-10-17",
-     "Statement": [
-       {
-         "Effect": "Allow",
-         "Action": [
-           "s3:PutObject",
-           "s3:PutObjectAcl",
-           "s3:GetObject"
-         ],
-         "Resource": "arn:aws:s3:::your-bucket-name/*"
-       }
-     ]
-   }
-   ```
-4. **Configure Environment Variables** with the IAM credentials
-
-### 4. Room Configuration
-
-When creating rooms in Reflector, set the platform to use Whereby:
-
-```bash
-curl -X POST "https://your-reflector-domain.com/v1/rooms" \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer $AUTH_TOKEN" \
-  -d '{
-    "name": "my-whereby-room",
-    "platform": "whereby",
-    "recording_type": "cloud",
-    "recording_trigger": "automatic-2nd-participant",
-    "is_locked": false,
-    "room_mode": "normal"
-  }'
-```
-
-## Meeting Features
-
-### Recording Options
-
-Whereby supports three recording types:
-- **`none`**: No recording
-- **`local`**: Local recording (not recommended for production)
-- **`cloud`**: Cloud recording to S3 (recommended)
-
-### Recording Triggers
-
-Control when recordings start:
-- **`none`**: No automatic recording
-- **`prompt`**: Prompt users to start recording
-- **`automatic`**: Start immediately when meeting begins
-- **`automatic-2nd-participant`**: Start when second participant joins
-
-### Room Modes
-
-- **`normal`**: Standard meeting room
-- **`group`**: Group meeting with advanced features
-
-## Webhook Event Handling
-
-Reflector automatically handles these Whereby webhook events:
-
-### Participant Tracking
-```json
-{
-  "type": "room.client.joined",
-  "data": {
-    "meetingId": "room-uuid",
-    "numClients": 2
-  }
-}
-```
-
-### Recording Events
-Whereby sends recording completion events that trigger Reflector's processing pipeline:
-- Audio transcription
-- Speaker diarization
-- Summary generation
-
-## Troubleshooting
-
-### Common Issues
-
-#### API Authentication Errors
-**Symptoms**: 401 Unauthorized errors when creating meetings
-
-**Solutions**:
-1. Verify your `WHEREBY_API_KEY` is correct and not expired
-2. Ensure you have API access enabled on your Whereby account
-3. Contact Whereby support if API access is not available
-
-#### Webhook Signature Validation Failed
-**Symptoms**: Webhook events rejected with 401 errors
-
-**Solutions**:
-1. Verify `WHEREBY_WEBHOOK_SECRET` matches your Whereby dashboard configuration
-2. Check webhook URL is correctly configured in Whereby dashboard
-3. Ensure webhook endpoint is accessible from Whereby servers
-
-#### Recording Upload Failures
-**Symptoms**: Recordings not appearing in S3 bucket
-
-**Solutions**:
-1. Verify AWS credentials have S3 write permissions
-2. Check S3 bucket name is correct and accessible
-3. Ensure AWS region settings match your bucket location
-4. Review AWS CloudTrail logs for permission issues
-
-#### Participant Count Not Updating
-**Symptoms**: Meeting participant counts remain at 0
-
-**Solutions**:
-1. Verify webhook events are being received at `/v1/whereby`
-2. Check webhook signature validation is passing
-3. Ensure meeting IDs match between Whereby and Reflector database
-
-### Debug Commands
-
-```bash
-# Test Whereby API connectivity
-curl -H "Authorization: Bearer $WHEREBY_API_KEY" \
-  https://api.whereby.dev/v1/meetings
-
-# Check webhook endpoint health
-curl https://your-reflector-domain.com/v1/whereby/health
-
-# Verify S3 bucket access
-aws s3 ls s3://your-bucket-name --profile whereby-user
-```
-
-## Security Considerations
-
-### API Key Security
-- Store API keys securely using environment variables
-- Rotate API keys regularly
-- Never commit API keys to version control
-- Use separate keys for development and production
-
-### Webhook Security
-- Always validate webhook signatures using HMAC-SHA256
-- Use HTTPS for all webhook endpoints
-- Implement rate limiting on webhook endpoints
-- Monitor webhook events for suspicious activity
-
-### Recording Privacy
-- Ensure S3 bucket access is restricted to authorized users
-- Consider encryption at rest for sensitive recordings
-- Implement retention policies for recorded content
-- Comply with data protection regulations (GDPR, etc.)
-
-## Performance Optimization
-
-### Meeting Scaling
-- Monitor concurrent meeting limits on your Whereby plan
-- Implement meeting cleanup for expired sessions
-- Use appropriate room modes for different use cases
-
-### Recording Processing
-- Configure SQS for asynchronous recording processing
-- Monitor S3 storage usage and costs
-- Implement automatic cleanup of processed recordings
-
-### Webhook Reliability
-- Implement webhook retry mechanisms
-- Monitor webhook delivery success rates
-- Log webhook events for debugging and auditing
-
-## Migration from Other Platforms
-
-If migrating from another video platform:
-
-1. **Update Room Configuration**: Change existing rooms to use `"platform": "whereby"`
-2. **Configure Webhooks**: Set up Whereby webhook endpoints
-3. **Test Integration**: Verify meeting creation and event handling
-4. **Monitor Performance**: Watch for any issues during transition
-5. **Update Documentation**: Inform users of any workflow changes
-
-## Support
-
-For Whereby-specific issues:
-- **Whereby Support**: [whereby.com/support](https://whereby.com/support)
-- **API Documentation**: [whereby.dev](https://whereby.dev)
-- **Status Page**: [status.whereby.com](https://status.whereby.com)
-
-For Reflector integration issues:
-- Check application logs for error details
-- Verify environment variable configuration
-- Test webhook connectivity and authentication
-- Review AWS permissions and S3 access

docs/video_platforms.md

@@ -1,474 +0,0 @@
-# Video Platforms Architecture (PR #529 Analysis)
-
-This document analyzes the video platforms refactoring implemented in PR #529 for daily.co integration, providing a blueprint for extending support to Jitsi and other video conferencing platforms.
-
-## Overview
-
-The video platforms refactoring introduces a clean abstraction layer that allows Reflector to support multiple video conferencing providers (Whereby, Daily.co, etc.) without changing core application logic. This architecture enables:
-
-- Seamless switching between video platforms
-- Platform-specific feature support
-- Isolated platform code organization
-- Consistent API surface across platforms
-- Feature flags for gradual migration
-
-## Architecture Components
-
-### 1. **Directory Structure**
-
-```
-server/reflector/video_platforms/
-├── __init__.py              # Public API exports
-├── base.py                  # Abstract base classes
-├── factory.py               # Platform client factory
-├── registry.py              # Platform registration system
-├── whereby.py               # Whereby implementation
-├── daily.py                 # Daily.co implementation
-└── mock.py                  # Testing implementation
-```
-
-### 2. **Core Abstract Classes**
-
-#### `VideoPlatformClient` (base.py)
-Abstract base class defining the interface all platforms must implement:
-
-```python
-class VideoPlatformClient(ABC):
-    PLATFORM_NAME: str = ""
-
-    @abstractmethod
-    async def create_meeting(self, room_name_prefix: str, end_date: datetime, room: Room) -> MeetingData
-
-    @abstractmethod
-    async def get_room_sessions(self, room_name: str) -> Dict[str, Any]
-
-    @abstractmethod
-    async def delete_room(self, room_name: str) -> bool
-
-    @abstractmethod
-    async def upload_logo(self, room_name: str, logo_path: str) -> bool
-
-    @abstractmethod
-    def verify_webhook_signature(self, body: bytes, signature: str, timestamp: Optional[str] = None) -> bool
-```
-
-#### `MeetingData` (base.py)
-Standardized meeting data structure returned by all platforms:
-
-```python
-class MeetingData(BaseModel):
-    meeting_id: str
-    room_name: str
-    room_url: str
-    host_room_url: str
-    platform: str
-    extra_data: Dict[str, Any] = {}  # Platform-specific data
-```
-
-#### `VideoPlatformConfig` (base.py)
-Unified configuration structure for all platforms:
-
-```python
-class VideoPlatformConfig(BaseModel):
-    api_key: str
-    webhook_secret: str
-    api_url: Optional[str] = None
-    subdomain: Optional[str] = None
-    s3_bucket: Optional[str] = None
-    s3_region: Optional[str] = None
-    aws_role_arn: Optional[str] = None
-    aws_access_key_id: Optional[str] = None
-    aws_access_key_secret: Optional[str] = None
-```
-
-### 3. **Platform Registration System**
-
-#### Registry Pattern (registry.py)
-- Automatic registration of built-in platforms
-- Runtime platform discovery
-- Type-safe client instantiation
-
-```python
-# Auto-registration of platforms
-_PLATFORMS: Dict[str, Type[VideoPlatformClient]] = {}
-
-def register_platform(name: str, client_class: Type[VideoPlatformClient])
-def get_platform_client(platform: str, config: VideoPlatformConfig) -> VideoPlatformClient
-```
-
-#### Factory System (factory.py)
-- Configuration management per platform
-- Platform selection logic
-- Feature flag integration
-
-```python
-def get_platform_for_room(room_id: Optional[str] = None) -> str:
-    """Determine which platform to use based on feature flags."""
-    if not settings.DAILY_MIGRATION_ENABLED:
-        return "whereby"
-
-    if room_id and room_id in settings.DAILY_MIGRATION_ROOM_IDS:
-        return "daily"
-
-    return settings.DEFAULT_VIDEO_PLATFORM
-```
-
-### 4. **Database Schema Changes**
-
-#### Room Model Updates
-Added `platform` field to track which video platform each room uses:
-
-```python
-# Database Schema
-platform_column = sqlalchemy.Column(
-    "platform",
-    sqlalchemy.String,
-    nullable=False,
-    server_default="whereby"
-)
-
-# Pydantic Model
-class Room(BaseModel):
-    platform: Literal["whereby", "daily"] = "whereby"
-```
-
-#### Meeting Model Updates
-Added `platform` field to meetings for tracking and debugging:
-
-```python
-# Database Schema
-platform_column = sqlalchemy.Column(
-    "platform",
-    sqlalchemy.String,
-    nullable=False,
-    server_default="whereby"
-)
-
-# Pydantic Model
-class Meeting(BaseModel):
-    platform: Literal["whereby", "daily"] = "whereby"
-```
-
-**Key Decision**: No platform-specific fields were added to models. Instead, the `extra_data` field in `MeetingData` handles platform-specific information, following the user's rule of using generic `provider_data` as JSON if needed.
-
-### 5. **Settings Configuration**
-
-#### Feature Flags
-```python
-# Migration control
-DAILY_MIGRATION_ENABLED: bool = True
-DAILY_MIGRATION_ROOM_IDS: list[str] = []
-DEFAULT_VIDEO_PLATFORM: str = "daily"
-
-# Daily.co specific settings
-DAILY_API_KEY: str | None = None
-DAILY_WEBHOOK_SECRET: str | None = None
-DAILY_SUBDOMAIN: str | None = None
-AWS_DAILY_S3_BUCKET: str | None = None
-AWS_DAILY_S3_REGION: str = "us-west-2"
-AWS_DAILY_ROLE_ARN: str | None = None
-```
-
-#### Configuration Pattern
-Each platform gets its own configuration namespace while sharing common patterns:
-
-```python
-def get_platform_config(platform: str) -> VideoPlatformConfig:
-    if platform == "whereby":
-        return VideoPlatformConfig(
-            api_key=settings.WHEREBY_API_KEY or "",
-            webhook_secret=settings.WHEREBY_WEBHOOK_SECRET or "",
-            # ... whereby-specific config
-        )
-    elif platform == "daily":
-        return VideoPlatformConfig(
-            api_key=settings.DAILY_API_KEY or "",
-            webhook_secret=settings.DAILY_WEBHOOK_SECRET or "",
-            # ... daily-specific config
-        )
-```
-
-### 6. **API Integration Updates**
-
-#### Room Creation (views/rooms.py)
-Updated to use platform factory instead of direct Whereby calls:
-
-```python
-@router.post("/rooms/{room_name}/meeting")
-async def rooms_create_meeting(room_name: str, user: UserInfo):
-    # OLD: Direct Whereby integration
-    # whereby_meeting = await create_meeting("", end_date=end_date, room=room)
-
-    # NEW: Platform abstraction
-    platform = get_platform_for_room(room.id)
-    client = create_platform_client(platform)
-
-    meeting_data = await client.create_meeting(
-        room_name_prefix=room.name, end_date=end_date, room=room
-    )
-
-    await client.upload_logo(meeting_data.room_name, "./images/logo.png")
-```
-
-### 7. **Webhook Handling**
-
-#### Separate Webhook Endpoints
-Each platform gets its own webhook endpoint with platform-specific signature verification:
-
-```python
-# views/daily.py
-@router.post("/daily_webhook")
-async def daily_webhook(event: DailyWebhookEvent, request: Request):
-    # Verify Daily.co signature
-    body = await request.body()
-    signature = request.headers.get("X-Daily-Signature", "")
-
-    if not verify_daily_webhook_signature(body, signature):
-        raise HTTPException(status_code=401)
-
-    # Handle platform-specific events
-    if event.type == "participant.joined":
-        await _handle_participant_joined(event)
-```
-
-#### Consistent Event Handling
-Despite different event formats, the core business logic remains the same:
-
-```python
-async def _handle_participant_joined(event):
-    room_name = event.data.get("room", {}).get("name")  # Daily.co format
-    meeting = await meetings_controller.get_by_room_name(room_name)
-    if meeting:
-        current_count = getattr(meeting, "num_clients", 0)
-        await meetings_controller.update_meeting(
-            meeting.id, num_clients=current_count + 1
-        )
-```
-
-### 8. **Worker Task Integration**
-
-#### New Task for Daily.co Recording Processing
-Added platform-specific recording processing while maintaining the same pipeline:
-
-```python
-@shared_task
-@asynctask
-async def process_recording_from_url(recording_url: str, meeting_id: str, recording_id: str):
-    """Process recording from Direct URL (Daily.co webhook)."""
-    logger.info("Processing recording from URL for meeting: %s", meeting_id)
-    # Uses same processing pipeline as Whereby S3 recordings
-```
-
-**Key Decision**: Worker tasks remain in main worker module but could be moved to platform-specific folders as suggested by the user.
-
-### 9. **Testing Infrastructure**
-
-#### Comprehensive Test Suite
-- Unit tests for each platform client
-- Integration tests for platform switching
-- Mock platform for testing without external dependencies
-- Webhook signature verification tests
-
-```python
-class TestPlatformIntegration:
-    """Integration tests for platform switching."""
-
-    async def test_platform_switching_preserves_interface(self):
-        """Test that different platforms provide consistent interface."""
-        # Test both Mock and Daily platforms return MeetingData objects
-        # with consistent fields
-```
-
-## Implementation Patterns for Jitsi Integration
-
-Based on the daily.co implementation, here's how Jitsi should be integrated:
-
-### 1. **Jitsi Client Implementation**
-
-```python
-# video_platforms/jitsi.py
-class JitsiClient(VideoPlatformClient):
-    PLATFORM_NAME = "jitsi"
-
-    async def create_meeting(self, room_name_prefix: str, end_date: datetime, room: Room) -> MeetingData:
-        # Generate unique room name
-        jitsi_room = f"reflector-{room.name}-{int(time.time())}"
-
-        # Generate JWT tokens
-        user_jwt = self._generate_jwt(room=jitsi_room, moderator=False, exp=end_date)
-        host_jwt = self._generate_jwt(room=jitsi_room, moderator=True, exp=end_date)
-
-        return MeetingData(
-            meeting_id=generate_uuid4(),
-            room_name=jitsi_room,
-            room_url=f"https://jitsi.domain/{jitsi_room}?jwt={user_jwt}",
-            host_room_url=f"https://jitsi.domain/{jitsi_room}?jwt={host_jwt}",
-            platform=self.PLATFORM_NAME,
-            extra_data={"user_jwt": user_jwt, "host_jwt": host_jwt}
-        )
-```
-
-### 2. **Settings Integration**
-
-```python
-# settings.py
-JITSI_DOMAIN: str = "meet.jit.si"
-JITSI_JWT_SECRET: str | None = None
-JITSI_WEBHOOK_SECRET: str | None = None
-JITSI_API_URL: str | None = None  # If using Jitsi API
-```
-
-### 3. **Factory Registration**
-
-```python
-# registry.py
-def _register_builtin_platforms():
-    from .jitsi import JitsiClient
-    register_platform("jitsi", JitsiClient)
-
-# factory.py
-def get_platform_config(platform: str) -> VideoPlatformConfig:
-    elif platform == "jitsi":
-        return VideoPlatformConfig(
-            api_key="",  # Jitsi may not need API key
-            webhook_secret=settings.JITSI_WEBHOOK_SECRET or "",
-            api_url=settings.JITSI_API_URL,
-        )
-```
-
-### 4. **Webhook Integration**
-
-```python
-# views/jitsi.py
-@router.post("/jitsi/events")
-async def jitsi_events_webhook(event_data: dict):
-    # Handle Prosody event-sync webhook format
-    event_type = event_data.get("event")
-    room_name = event_data.get("room", "").split("@")[0]
-
-    if event_type == "muc-occupant-joined":
-        # Same participant handling logic as other platforms
-```
-
-## Key Benefits of This Architecture
-
-### 1. **Isolation and Organization**
-- Platform-specific code contained in separate modules
-- No platform logic leaking into core application
-- Easy to add/remove platforms without affecting others
-
-### 2. **Consistent Interface**
-- All platforms implement the same abstract methods
-- Standardized `MeetingData` structure
-- Uniform error handling and logging
-
-### 3. **Gradual Migration Support**
-- Feature flags for controlled rollouts
-- Room-specific platform selection
-- Fallback mechanisms for platform failures
-
-### 4. **Configuration Management**
-- Centralized settings per platform
-- Consistent naming patterns
-- Environment-based configuration
-
-### 5. **Testing and Quality**
-- Mock platform for testing
-- Comprehensive test coverage
-- Platform-specific test utilities
-
-## Migration Strategy Applied
-
-The daily.co implementation demonstrates a careful migration approach:
-
-### 1. **Backward Compatibility**
-- Default platform remains "whereby"
-- Existing rooms continue using Whereby unless explicitly migrated
-- Same API endpoints and response formats
-
-### 2. **Feature Flag Control**
-```python
-# Gradual rollout control
-DAILY_MIGRATION_ENABLED: bool = True
-DAILY_MIGRATION_ROOM_IDS: list[str] = []  # Specific rooms to migrate
-DEFAULT_VIDEO_PLATFORM: str = "daily"     # New rooms default
-```
-
-### 3. **Data Integrity**
-- Platform field tracks which service each room/meeting uses
-- No data loss during migration
-- Platform-specific data preserved in `extra_data`
-
-### 4. **Monitoring and Rollback**
-- Comprehensive logging of platform selection
-- Easy rollback by changing feature flags
-- Platform-specific error tracking
-
-## Recommendations for Jitsi Integration
-
-Based on this analysis and the user's requirements:
-
-### 1. **Follow the Pattern**
-- Create `video_platforms/jitsi/` directory with:
-  - `client.py` - Main JitsiClient implementation
-  - `tasks.py` - Jitsi-specific worker tasks
-  - `__init__.py` - Module exports
-
-### 2. **Settings Organization**
-- Use `JITSI_*` prefix for all Jitsi settings
-- Follow the same configuration pattern as Daily.co
-- Support both environment variables and config files
-
-### 3. **Generic Database Fields**
-- Avoid platform-specific columns in database
-- Use `provider_data` JSON field if platform-specific data needed
-- Keep `platform` field as simple string identifier
-
-### 4. **Worker Task Migration**
-According to user requirements, migrate platform-specific tasks:
-```
-video_platforms/
-├── whereby/
-│   ├── client.py  (moved from whereby.py)
-│   └── tasks.py   (moved from worker/whereby_tasks.py)
-├── daily/
-│   ├── client.py  (moved from daily.py)
-│   └── tasks.py   (moved from worker/daily_tasks.py)
-└── jitsi/
-    ├── client.py  (new JitsiClient)
-    └── tasks.py   (new Jitsi recording tasks)
-```
-
-### 5. **Webhook Architecture**
-- Create `views/jitsi.py` for Jitsi-specific webhooks
-- Follow the same signature verification pattern
-- Reuse existing participant tracking logic
-
-## Implementation Checklist for Jitsi
-
-- [ ] Create `video_platforms/jitsi/` directory structure
-- [ ] Implement `JitsiClient` following the abstract interface
-- [ ] Add Jitsi settings to configuration
-- [ ] Register Jitsi platform in factory/registry
-- [ ] Create Jitsi webhook endpoint
-- [ ] Implement JWT token generation for room access
-- [ ] Add Jitsi recording processing tasks
-- [ ] Create comprehensive test suite
-- [ ] Update database migrations for platform field
-- [ ] Document Jitsi-specific configuration
-
-## Conclusion
-
-The video platforms refactoring in PR #529 provides an excellent foundation for adding Jitsi support. The architecture is well-designed with clear separation of concerns, consistent interfaces, and excellent extensibility. The daily.co implementation demonstrates how to add a new platform while maintaining backward compatibility and providing gradual migration capabilities.
-
-The pattern should be directly applicable to Jitsi integration, with the main differences being:
-- JWT-based authentication instead of API keys
-- Different webhook event formats
-- Jibri recording pipeline integration
-- Self-hosted deployment considerations
-
-This architecture successfully achieves the user's goals of:
-1. Settings-based configuration
-2. Generic database fields (no provider-specific columns)
-3. Platform isolation in separate directories
-4. Worker task organization within platform folders

gpu/modal_deployments/.gitignore

@@ -0,0 +1,33 @@
+# OS / Editor
+.DS_Store
+.vscode/
+.idea/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Logs
+*.log
+
+# Env and secrets
+.env
+.env.*
+*.env
+*.secret
+
+# Build / dist
+build/
+dist/
+.eggs/
+*.egg-info/
+
+# Coverage / test
+.pytest_cache/
+.coverage*
+htmlcov/
+
+# Modal local state (if any)
+modal_mounts/
+.modal_cache/

gpu/self_hosted/.env.example

@@ -0,0 +1,2 @@
+REFLECTOR_GPU_APIKEY=
+HF_TOKEN=

gpu/self_hosted/.gitignore

@@ -0,0 +1,38 @@
+cache/
+
+# OS / Editor
+.DS_Store
+.vscode/
+.idea/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Env and secrets
+.env
+*.env
+*.secret
+HF_TOKEN
+REFLECTOR_GPU_APIKEY
+
+# Virtual env / uv
+.venv/
+venv/
+ENV/
+uv/
+
+# Build / dist
+build/
+dist/
+.eggs/
+*.egg-info/
+
+# Coverage / test
+.pytest_cache/
+.coverage*
+htmlcov/
+
+# Logs
+*.log

gpu/self_hosted/Dockerfile

@@ -0,0 +1,46 @@
+FROM python:3.12-slim
+
+ENV PYTHONUNBUFFERED=1 \
+    UV_LINK_MODE=copy \
+    UV_NO_CACHE=1
+
+WORKDIR /tmp
+RUN apt-get update \
+ && apt-get install -y \
+    ffmpeg \
+    curl \
+    ca-certificates \
+    gnupg \
+    wget \
+ && apt-get clean
+# Add NVIDIA CUDA repo for Debian 12 (bookworm) and install cuDNN 9 for CUDA 12
+ADD https://developer.download.nvidia.com/compute/cuda/repos/debian12/x86_64/cuda-keyring_1.1-1_all.deb /cuda-keyring.deb
+RUN dpkg -i /cuda-keyring.deb \
+ && rm /cuda-keyring.deb \
+ && apt-get update \
+ && apt-get install -y --no-install-recommends \
+    cuda-cudart-12-6 \
+    libcublas-12-6 \
+    libcudnn9-cuda-12 \
+    libcudnn9-dev-cuda-12 \
+ && apt-get clean \
+ && rm -rf /var/lib/apt/lists/*
+ADD https://astral.sh/uv/install.sh /uv-installer.sh
+RUN sh /uv-installer.sh && rm /uv-installer.sh
+ENV PATH="/root/.local/bin/:$PATH"
+ENV LD_LIBRARY_PATH="/usr/local/cuda/lib64:/usr/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH"
+
+RUN mkdir -p /app
+WORKDIR /app
+COPY pyproject.toml uv.lock /app/
+
+
+COPY ./app /app/app
+COPY ./main.py /app/
+COPY ./runserver.sh /app/
+
+EXPOSE 8000
+
+CMD ["sh", "/app/runserver.sh"]
+
+

gpu/self_hosted/README.md

@@ -0,0 +1,73 @@
+# Self-hosted Model API
+
+Run transcription, translation, and diarization services compatible with Reflector's GPU Model API. Works on CPU or GPU.
+
+Environment variables
+
+- REFLECTOR_GPU_APIKEY: Optional Bearer token. If unset, auth is disabled.
+- HF_TOKEN: Optional. Required for diarization to download pyannote pipelines
+
+Requirements
+
+- FFmpeg must be installed and on PATH (used for URL-based and segmented transcription)
+- Python 3.12+
+- NVIDIA GPU optional. If available, it will be used automatically
+
+Local run
+Set env vars in self_hosted/.env file
+uv sync
+
+uv run uvicorn main:app --host 0.0.0.0 --port 8000
+
+Authentication
+
+- If REFLECTOR_GPU_APIKEY is set, include header: Authorization: Bearer <key>
+
+Endpoints
+
+- POST /v1/audio/transcriptions
+
+  - multipart/form-data
+  - fields: file (single file) OR files[] (multiple files), language, batch (true/false)
+  - response: single { text, words, filename } or { results: [ ... ] }
+
+- POST /v1/audio/transcriptions-from-url
+
+  - application/json
+  - body: { audio_file_url, language, timestamp_offset }
+  - response: { text, words }
+
+- POST /translate
+
+  - text: query parameter
+  - body (application/json): { source_language, target_language }
+  - response: { text: { <src>: original, <tgt>: translated } }
+
+- POST /diarize
+  - query parameters: audio_file_url, timestamp (optional)
+  - requires HF_TOKEN to be set (for pyannote)
+  - response: { diarization: [ { start, end, speaker } ] }
+
+OpenAPI docs
+
+- Visit /docs when the server is running
+
+Docker
+
+- Not yet provided in this directory. A Dockerfile will be added later. For now, use Local run above
+
+Conformance tests
+
+# From this directory
+
+TRANSCRIPT_URL=http://localhost:8000 \
+TRANSCRIPT_API_KEY=dev-key \
+uv run -m pytest -m model_api --no-cov ../../server/tests/test_model_api_transcript.py
+
+TRANSLATION_URL=http://localhost:8000 \
+TRANSLATION_API_KEY=dev-key \
+uv run -m pytest -m model_api --no-cov ../../server/tests/test_model_api_translation.py
+
+DIARIZATION_URL=http://localhost:8000 \
+DIARIZATION_API_KEY=dev-key \
+uv run -m pytest -m model_api --no-cov ../../server/tests/test_model_api_diarization.py

gpu/self_hosted/app/auth.py

@@ -0,0 +1,19 @@
+import os
+
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+
+def apikey_auth(apikey: str = Depends(oauth2_scheme)):
+    required_key = os.environ.get("REFLECTOR_GPU_APIKEY")
+    if not required_key:
+        return
+    if apikey == required_key:
+        return
+    raise HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Invalid API key",
+        headers={"WWW-Authenticate": "Bearer"},
+    )

gpu/self_hosted/app/config.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+
+SUPPORTED_FILE_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
+SAMPLE_RATE = 16000
+VAD_CONFIG = {
+    "batch_max_duration": 30.0,
+    "silence_padding": 0.5,
+    "window_size": 512,
+}
+
+# App-level paths
+UPLOADS_PATH = Path("/tmp/whisper-uploads")

gpu/self_hosted/app/factory.py

@@ -0,0 +1,30 @@
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+from .routers.diarization import router as diarization_router
+from .routers.transcription import router as transcription_router
+from .routers.translation import router as translation_router
+from .services.transcriber import WhisperService
+from .services.diarizer import PyannoteDiarizationService
+from .utils import ensure_dirs
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    ensure_dirs()
+    whisper_service = WhisperService()
+    whisper_service.load()
+    app.state.whisper = whisper_service
+    diarization_service = PyannoteDiarizationService()
+    diarization_service.load()
+    app.state.diarizer = diarization_service
+    yield
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(lifespan=lifespan)
+    app.include_router(transcription_router)
+    app.include_router(translation_router)
+    app.include_router(diarization_router)
+    return app

gpu/self_hosted/app/routers/diarization.py

@@ -0,0 +1,30 @@
+from typing import List
+
+from fastapi import APIRouter, Depends, Request
+from pydantic import BaseModel
+
+from ..auth import apikey_auth
+from ..services.diarizer import PyannoteDiarizationService
+from ..utils import download_audio_file
+
+router = APIRouter(tags=["diarization"])
+
+
+class DiarizationSegment(BaseModel):
+    start: float
+    end: float
+    speaker: int
+
+
+class DiarizationResponse(BaseModel):
+    diarization: List[DiarizationSegment]
+
+
+@router.post(
+    "/diarize", dependencies=[Depends(apikey_auth)], response_model=DiarizationResponse
+)
+def diarize(request: Request, audio_file_url: str, timestamp: float = 0.0):
+    with download_audio_file(audio_file_url) as (file_path, _ext):
+        file_path = str(file_path)
+        diarizer: PyannoteDiarizationService = request.app.state.diarizer
+        return diarizer.diarize_file(file_path, timestamp=timestamp)

gpu/self_hosted/app/routers/transcription.py

@@ -0,0 +1,109 @@
+import uuid
+from typing import Optional, Union
+
+from fastapi import APIRouter, Body, Depends, Form, HTTPException, Request, UploadFile
+from pydantic import BaseModel
+from pathlib import Path
+from ..auth import apikey_auth
+from ..config import SUPPORTED_FILE_EXTENSIONS, UPLOADS_PATH
+from ..services.transcriber import MODEL_NAME
+from ..utils import cleanup_uploaded_files, download_audio_file
+
+router = APIRouter(prefix="/v1/audio", tags=["transcription"])
+
+
+class WordTiming(BaseModel):
+    word: str
+    start: float
+    end: float
+
+
+class TranscriptResult(BaseModel):
+    text: str
+    words: list[WordTiming]
+    filename: Optional[str] = None
+
+
+class TranscriptBatchResponse(BaseModel):
+    results: list[TranscriptResult]
+
+
+@router.post(
+    "/transcriptions",
+    dependencies=[Depends(apikey_auth)],
+    response_model=Union[TranscriptResult, TranscriptBatchResponse],
+)
+def transcribe(
+    request: Request,
+    file: UploadFile = None,
+    files: list[UploadFile] | None = None,
+    model: str = Form(MODEL_NAME),
+    language: str = Form("en"),
+    batch: bool = Form(False),
+):
+    service = request.app.state.whisper
+    if not file and not files:
+        raise HTTPException(
+            status_code=400, detail="Either 'file' or 'files' parameter is required"
+        )
+    if batch and not files:
+        raise HTTPException(
+            status_code=400, detail="Batch transcription requires 'files'"
+        )
+
+    upload_files = [file] if file else files
+
+    uploaded_paths: list[Path] = []
+    with cleanup_uploaded_files(uploaded_paths):
+        for upload_file in upload_files:
+            audio_suffix = upload_file.filename.split(".")[-1].lower()
+            if audio_suffix not in SUPPORTED_FILE_EXTENSIONS:
+                raise HTTPException(
+                    status_code=400,
+                    detail=(
+                        f"Unsupported audio format. Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
+                    ),
+                )
+            unique_filename = f"{uuid.uuid4()}.{audio_suffix}"
+            file_path = UPLOADS_PATH / unique_filename
+            with open(file_path, "wb") as f:
+                content = upload_file.file.read()
+                f.write(content)
+            uploaded_paths.append(file_path)
+
+        if batch and len(upload_files) > 1:
+            results = []
+            for path in uploaded_paths:
+                result = service.transcribe_file(str(path), language=language)
+                result["filename"] = path.name
+                results.append(result)
+            return {"results": results}
+
+        results = []
+        for path in uploaded_paths:
+            result = service.transcribe_file(str(path), language=language)
+            result["filename"] = path.name
+            results.append(result)
+
+        return {"results": results} if len(results) > 1 else results[0]
+
+
+@router.post(
+    "/transcriptions-from-url",
+    dependencies=[Depends(apikey_auth)],
+    response_model=TranscriptResult,
+)
+def transcribe_from_url(
+    request: Request,
+    audio_file_url: str = Body(..., description="URL of the audio file to transcribe"),
+    model: str = Body(MODEL_NAME),
+    language: str = Body("en"),
+    timestamp_offset: float = Body(0.0),
+):
+    service = request.app.state.whisper
+    with download_audio_file(audio_file_url) as (file_path, _ext):
+        file_path = str(file_path)
+        result = service.transcribe_vad_url_segment(
+            file_path=file_path, timestamp_offset=timestamp_offset, language=language
+        )
+        return result

gpu/self_hosted/app/routers/translation.py

@@ -0,0 +1,28 @@
+from typing import Dict
+
+from fastapi import APIRouter, Body, Depends
+from pydantic import BaseModel
+
+from ..auth import apikey_auth
+from ..services.translator import TextTranslatorService
+
+router = APIRouter(tags=["translation"])
+
+translator = TextTranslatorService()
+
+
+class TranslationResponse(BaseModel):
+    text: Dict[str, str]
+
+
+@router.post(
+    "/translate",
+    dependencies=[Depends(apikey_auth)],
+    response_model=TranslationResponse,
+)
+def translate(
+    text: str,
+    source_language: str = Body("en"),
+    target_language: str = Body("fr"),
+):
+    return translator.translate(text, source_language, target_language)

gpu/self_hosted/app/services/diarizer.py

@@ -0,0 +1,42 @@
+import os
+import threading
+
+import torch
+import torchaudio
+from pyannote.audio import Pipeline
+
+
+class PyannoteDiarizationService:
+    def __init__(self):
+        self._pipeline = None
+        self._device = "cpu"
+        self._lock = threading.Lock()
+
+    def load(self):
+        self._device = "cuda" if torch.cuda.is_available() else "cpu"
+        self._pipeline = Pipeline.from_pretrained(
+            "pyannote/speaker-diarization-3.1",
+            use_auth_token=os.environ.get("HF_TOKEN"),
+        )
+        self._pipeline.to(torch.device(self._device))
+
+    def diarize_file(self, file_path: str, timestamp: float = 0.0) -> dict:
+        if self._pipeline is None:
+            self.load()
+        waveform, sample_rate = torchaudio.load(file_path)
+        with self._lock:
+            diarization = self._pipeline(
+                {"waveform": waveform, "sample_rate": sample_rate}
+            )
+        words = []
+        for diarization_segment, _, speaker in diarization.itertracks(yield_label=True):
+            words.append(
+                {
+                    "start": round(timestamp + diarization_segment.start, 3),
+                    "end": round(timestamp + diarization_segment.end, 3),
+                    "speaker": int(speaker[-2:])
+                    if speaker and speaker[-2:].isdigit()
+                    else 0,
+                }
+            )
+        return {"diarization": words}

gpu/self_hosted/app/services/transcriber.py

@@ -0,0 +1,208 @@
+import os
+import shutil
+import subprocess
+import threading
+from typing import Generator
+
+import faster_whisper
+import librosa
+import numpy as np
+import torch
+from fastapi import HTTPException
+from silero_vad import VADIterator, load_silero_vad
+
+from ..config import SAMPLE_RATE, VAD_CONFIG
+
+# Whisper configuration (service-local defaults)
+MODEL_NAME = "large-v2"
+# None delegates compute type to runtime: float16 on CUDA, int8 on CPU
+MODEL_COMPUTE_TYPE = None
+MODEL_NUM_WORKERS = 1
+CACHE_PATH = os.path.join(os.path.expanduser("~"), ".cache", "reflector-whisper")
+from ..utils import NoStdStreams
+
+
+class WhisperService:
+    def __init__(self):
+        self.model = None
+        self.device = "cpu"
+        self.lock = threading.Lock()
+
+    def load(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        compute_type = MODEL_COMPUTE_TYPE or (
+            "float16" if self.device == "cuda" else "int8"
+        )
+        self.model = faster_whisper.WhisperModel(
+            MODEL_NAME,
+            device=self.device,
+            compute_type=compute_type,
+            num_workers=MODEL_NUM_WORKERS,
+            download_root=CACHE_PATH,
+        )
+
+    def pad_audio(self, audio_array, sample_rate: int = SAMPLE_RATE):
+        audio_duration = len(audio_array) / sample_rate
+        if audio_duration < VAD_CONFIG["silence_padding"]:
+            silence_samples = int(sample_rate * VAD_CONFIG["silence_padding"])
+            silence = np.zeros(silence_samples, dtype=np.float32)
+            return np.concatenate([audio_array, silence])
+        return audio_array
+
+    def enforce_word_timing_constraints(self, words: list[dict]) -> list[dict]:
+        if len(words) <= 1:
+            return words
+        enforced: list[dict] = []
+        for i, word in enumerate(words):
+            current = dict(word)
+            if i < len(words) - 1:
+                next_start = words[i + 1]["start"]
+                if current["end"] > next_start:
+                    current["end"] = next_start
+            enforced.append(current)
+        return enforced
+
+    def transcribe_file(self, file_path: str, language: str = "en") -> dict:
+        input_for_model: str | "object" = file_path
+        try:
+            audio_array, _sample_rate = librosa.load(
+                file_path, sr=SAMPLE_RATE, mono=True
+            )
+            if len(audio_array) / float(SAMPLE_RATE) < VAD_CONFIG["silence_padding"]:
+                input_for_model = self.pad_audio(audio_array, SAMPLE_RATE)
+        except Exception:
+            pass
+
+        with self.lock:
+            with NoStdStreams():
+                segments, _ = self.model.transcribe(
+                    input_for_model,
+                    language=language,
+                    beam_size=5,
+                    word_timestamps=True,
+                    vad_filter=True,
+                    vad_parameters={"min_silence_duration_ms": 500},
+                )
+
+        segments = list(segments)
+        text = "".join(segment.text for segment in segments).strip()
+        words = [
+            {
+                "word": word.word,
+                "start": round(float(word.start), 2),
+                "end": round(float(word.end), 2),
+            }
+            for segment in segments
+            for word in segment.words
+        ]
+        words = self.enforce_word_timing_constraints(words)
+        return {"text": text, "words": words}
+
+    def transcribe_vad_url_segment(
+        self, file_path: str, timestamp_offset: float = 0.0, language: str = "en"
+    ) -> dict:
+        def load_audio_via_ffmpeg(input_path: str, sample_rate: int) -> np.ndarray:
+            ffmpeg_bin = shutil.which("ffmpeg") or "ffmpeg"
+            cmd = [
+                ffmpeg_bin,
+                "-nostdin",
+                "-threads",
+                "1",
+                "-i",
+                input_path,
+                "-f",
+                "f32le",
+                "-acodec",
+                "pcm_f32le",
+                "-ac",
+                "1",
+                "-ar",
+                str(sample_rate),
+                "pipe:1",
+            ]
+            try:
+                proc = subprocess.run(
+                    cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True
+                )
+            except Exception as e:
+                raise HTTPException(status_code=400, detail=f"ffmpeg failed: {e}")
+            audio = np.frombuffer(proc.stdout, dtype=np.float32)
+            return audio
+
+        def vad_segments(
+            audio_array,
+            sample_rate: int = SAMPLE_RATE,
+            window_size: int = VAD_CONFIG["window_size"],
+        ) -> Generator[tuple[float, float], None, None]:
+            vad_model = load_silero_vad(onnx=False)
+            iterator = VADIterator(vad_model, sampling_rate=sample_rate)
+            start = None
+            for i in range(0, len(audio_array), window_size):
+                chunk = audio_array[i : i + window_size]
+                if len(chunk) < window_size:
+                    chunk = np.pad(
+                        chunk, (0, window_size - len(chunk)), mode="constant"
+                    )
+                speech = iterator(chunk)
+                if not speech:
+                    continue
+                if "start" in speech:
+                    start = speech["start"]
+                    continue
+                if "end" in speech and start is not None:
+                    end = speech["end"]
+                    yield (start / float(SAMPLE_RATE), end / float(SAMPLE_RATE))
+                    start = None
+            iterator.reset_states()
+
+        audio_array = load_audio_via_ffmpeg(file_path, SAMPLE_RATE)
+
+        merged_batches: list[tuple[float, float]] = []
+        batch_start = None
+        batch_end = None
+        max_duration = VAD_CONFIG["batch_max_duration"]
+        for seg_start, seg_end in vad_segments(audio_array):
+            if batch_start is None:
+                batch_start, batch_end = seg_start, seg_end
+                continue
+            if seg_end - batch_start <= max_duration:
+                batch_end = seg_end
+            else:
+                merged_batches.append((batch_start, batch_end))
+                batch_start, batch_end = seg_start, seg_end
+        if batch_start is not None and batch_end is not None:
+            merged_batches.append((batch_start, batch_end))
+
+        all_text = []
+        all_words = []
+        for start_time, end_time in merged_batches:
+            s_idx = int(start_time * SAMPLE_RATE)
+            e_idx = int(end_time * SAMPLE_RATE)
+            segment = audio_array[s_idx:e_idx]
+            segment = self.pad_audio(segment, SAMPLE_RATE)
+            with self.lock:
+                segments, _ = self.model.transcribe(
+                    segment,
+                    language=language,
+                    beam_size=5,
+                    word_timestamps=True,
+                    vad_filter=True,
+                    vad_parameters={"min_silence_duration_ms": 500},
+                )
+            segments = list(segments)
+            text = "".join(seg.text for seg in segments).strip()
+            words = [
+                {
+                    "word": w.word,
+                    "start": round(float(w.start) + start_time + timestamp_offset, 2),
+                    "end": round(float(w.end) + start_time + timestamp_offset, 2),
+                }
+                for seg in segments
+                for w in seg.words
+            ]
+            if text:
+                all_text.append(text)
+            all_words.extend(words)
+
+        all_words = self.enforce_word_timing_constraints(all_words)
+        return {"text": " ".join(all_text), "words": all_words}

gpu/self_hosted/app/services/translator.py

@@ -0,0 +1,44 @@
+import threading
+
+from transformers import MarianMTModel, MarianTokenizer, pipeline
+
+
+class TextTranslatorService:
+    """Simple text-to-text translator using HuggingFace MarianMT models.
+
+    This mirrors the modal translator API shape but uses text translation only.
+    """
+
+    def __init__(self):
+        self._pipeline = None
+        self._lock = threading.Lock()
+
+    def load(self, source_language: str = "en", target_language: str = "fr"):
+        # Pick a default MarianMT model pair if available; fall back to Helsinki-NLP en->fr
+        model_name = self._resolve_model_name(source_language, target_language)
+        tokenizer = MarianTokenizer.from_pretrained(model_name)
+        model = MarianMTModel.from_pretrained(model_name)
+        self._pipeline = pipeline("translation", model=model, tokenizer=tokenizer)
+
+    def _resolve_model_name(self, src: str, tgt: str) -> str:
+        # Minimal mapping; extend as needed
+        pair = (src.lower(), tgt.lower())
+        mapping = {
+            ("en", "fr"): "Helsinki-NLP/opus-mt-en-fr",
+            ("fr", "en"): "Helsinki-NLP/opus-mt-fr-en",
+            ("en", "es"): "Helsinki-NLP/opus-mt-en-es",
+            ("es", "en"): "Helsinki-NLP/opus-mt-es-en",
+            ("en", "de"): "Helsinki-NLP/opus-mt-en-de",
+            ("de", "en"): "Helsinki-NLP/opus-mt-de-en",
+        }
+        return mapping.get(pair, "Helsinki-NLP/opus-mt-en-fr")
+
+    def translate(self, text: str, source_language: str, target_language: str) -> dict:
+        if self._pipeline is None:
+            self.load(source_language, target_language)
+        with self._lock:
+            results = self._pipeline(
+                text, src_lang=source_language, tgt_lang=target_language
+            )
+        translated = results[0]["translation_text"] if results else ""
+        return {"text": {source_language: text, target_language: translated}}

gpu/self_hosted/app/utils.py

@@ -0,0 +1,107 @@
+import logging
+import os
+import sys
+import uuid
+from contextlib import contextmanager
+from typing import Mapping
+from urllib.parse import urlparse
+from pathlib import Path
+
+import requests
+from fastapi import HTTPException
+
+from .config import SUPPORTED_FILE_EXTENSIONS, UPLOADS_PATH
+
+logger = logging.getLogger(__name__)
+
+
+class NoStdStreams:
+    def __init__(self):
+        self.devnull = open(os.devnull, "w")
+
+    def __enter__(self):
+        self._stdout, self._stderr = sys.stdout, sys.stderr
+        self._stdout.flush()
+        self._stderr.flush()
+        sys.stdout, sys.stderr = self.devnull, self.devnull
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        sys.stdout, sys.stderr = self._stdout, self._stderr
+        self.devnull.close()
+
+
+def ensure_dirs():
+    UPLOADS_PATH.mkdir(parents=True, exist_ok=True)
+
+
+def detect_audio_format(url: str, headers: Mapping[str, str]) -> str:
+    url_path = urlparse(url).path
+    for ext in SUPPORTED_FILE_EXTENSIONS:
+        if url_path.lower().endswith(f".{ext}"):
+            return ext
+
+    content_type = headers.get("content-type", "").lower()
+    if "audio/mpeg" in content_type or "audio/mp3" in content_type:
+        return "mp3"
+    if "audio/wav" in content_type:
+        return "wav"
+    if "audio/mp4" in content_type:
+        return "mp4"
+
+    raise HTTPException(
+        status_code=400,
+        detail=(
+            f"Unsupported audio format for URL. Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
+        ),
+    )
+
+
+def download_audio_to_uploads(audio_file_url: str) -> tuple[Path, str]:
+    response = requests.head(audio_file_url, allow_redirects=True)
+    if response.status_code == 404:
+        raise HTTPException(status_code=404, detail="Audio file not found")
+
+    response = requests.get(audio_file_url, allow_redirects=True)
+    response.raise_for_status()
+
+    audio_suffix = detect_audio_format(audio_file_url, response.headers)
+    unique_filename = f"{uuid.uuid4()}.{audio_suffix}"
+    file_path: Path = UPLOADS_PATH / unique_filename
+
+    with open(file_path, "wb") as f:
+        f.write(response.content)
+
+    return file_path, audio_suffix
+
+
+@contextmanager
+def download_audio_file(audio_file_url: str):
+    """Download an audio file to UPLOADS_PATH and remove it after use.
+
+    Yields (file_path: Path, audio_suffix: str).
+    """
+    file_path, audio_suffix = download_audio_to_uploads(audio_file_url)
+    try:
+        yield file_path, audio_suffix
+    finally:
+        try:
+            file_path.unlink(missing_ok=True)
+        except Exception as e:
+            logger.error("Error deleting temporary file %s: %s", file_path, e)
+
+
+@contextmanager
+def cleanup_uploaded_files(file_paths: list[Path]):
+    """Ensure provided file paths are removed after use.
+
+    The provided list can be populated inside the context; all present entries
+    at exit will be deleted.
+    """
+    try:
+        yield file_paths
+    finally:
+        for path in list(file_paths):
+            try:
+                path.unlink(missing_ok=True)
+            except Exception as e:
+                logger.error("Error deleting temporary file %s: %s", path, e)

gpu/self_hosted/compose.yml

@@ -0,0 +1,10 @@
+services:
+  reflector_gpu:
+    build:
+      context: .
+    ports:
+      - "8000:8000"
+    env_file:
+      - .env
+    volumes:
+      - ./cache:/root/.cache

gpu/self_hosted/main.py

@@ -0,0 +1,3 @@
+from app.factory import create_app
+
+app = create_app()

gpu/self_hosted/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "reflector-gpu"
+version = "0.1.0"
+description = "Self-hosted GPU service for speech transcription, diarization, and translation via FastAPI."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fastapi[standard]>=0.116.1",
+    "uvicorn[standard]>=0.30.0",
+    "torch>=2.3.0",
+    "faster-whisper>=1.1.0",
+    "librosa==0.10.1",
+    "numpy<2",
+    "silero-vad==5.1.0",
+    "transformers>=4.35.0",
+    "sentencepiece",
+    "pyannote.audio==3.1.0",
+    "torchaudio>=2.3.0",
+]

gpu/self_hosted/runserver.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+set -e
+
+export PATH="/root/.local/bin:$PATH"
+cd /app
+
+# Install Python dependencies at runtime (first run or when FORCE_SYNC=1)
+if [ ! -d "/app/.venv" ] || [ "$FORCE_SYNC" = "1" ]; then
+  echo "[startup] Installing Python dependencies with uv..."
+  uv sync --compile-bytecode --locked
+else
+  echo "[startup] Using existing virtual environment at /app/.venv"
+fi
+
+exec uv run uvicorn main:app --host 0.0.0.0 --port 8000
+
+

server/contrib/jitsi/README.md

@@ -1,212 +0,0 @@
-# Event Logger for Docker-Jitsi-Meet
-
-A Prosody module that logs Jitsi meeting events to JSONL files alongside recordings, enabling complete participant tracking and speaker statistics.
-
-## Prerequisites
-
-- Running docker-jitsi-meet installation
-- Jibri configured for recording
-
-## Installation
-
-### Step 1: Copy the Module
-
-Copy the Prosody module to your custom plugins directory:
-
-```bash
-# Create the directory if it doesn't exist
-mkdir -p ~/.jitsi-meet-cfg/prosody/prosody-plugins-custom
-
-# Copy the module
-cp mod_event_logger.lua ~/.jitsi-meet-cfg/prosody/prosody-plugins-custom/
-```
-
-### Step 2: Update Your .env File
-
-Add or modify these variables in your `.env` file:
-
-```bash
-# If XMPP_MUC_MODULES already exists, append event_logger
-# Example: XMPP_MUC_MODULES=existing_module,event_logger
-XMPP_MUC_MODULES=event_logger
-
-# Optional: Configure the module (these are defaults)
-JIBRI_RECORDINGS_PATH=/config/recordings
-JIBRI_LOG_SPEAKER_STATS=true
-JIBRI_SPEAKER_STATS_INTERVAL=10
-```
-
-**Important**: If you already have `XMPP_MUC_MODULES` defined, add `event_logger` to the comma-separated list:
-```bash
-# Existing modules + our module
-XMPP_MUC_MODULES=mod_info,mod_alert,event_logger
-```
-
-### Step 3: Modify docker-compose.yml
-
-Add a shared recordings volume so Prosody can write events alongside Jibri recordings:
-
-```yaml
-services:
-  prosody:
-    # ... existing configuration ...
-    volumes:
-      - ${CONFIG}/prosody/config:/config:Z
-      - ${CONFIG}/prosody/prosody-plugins-custom:/prosody-plugins-custom:Z
-      - ${CONFIG}/recordings:/config/recordings:Z  # Add this line
-    environment:
-      # Add if not using .env file
-      - XMPP_MUC_MODULES=${XMPP_MUC_MODULES:-event_logger}
-      - JIBRI_RECORDINGS_PATH=/config/recordings
-
-  jibri:
-    # ... existing configuration ...
-    volumes:
-      - ${CONFIG}/jibri:/config:Z
-      - ${CONFIG}/recordings:/config/recordings:Z  # Add this line
-    environment:
-      # For Reflector webhook integration (optional)
-      - REFLECTOR_WEBHOOK_URL=${REFLECTOR_WEBHOOK_URL:-}
-      - JIBRI_FINALIZE_RECORDING_SCRIPT_PATH=/config/finalize.sh
-```
-
-### Step 4: Add Finalize Script (Optional - For Reflector Integration)
-
-If you want to notify Reflector when recordings complete:
-
-```bash
-# Copy the finalize script
-cp finalize.sh ~/.jitsi-meet-cfg/jibri/finalize.sh
-chmod +x ~/.jitsi-meet-cfg/jibri/finalize.sh
-
-# Add to .env
-REFLECTOR_WEBHOOK_URL=http://your-reflector-api:8000
-```
-
-### Step 5: Restart Services
-
-```bash
-docker-compose down
-docker-compose up -d
-```
-
-## What Gets Created
-
-After a recording, you'll find in `~/.jitsi-meet-cfg/recordings/{session-id}/`:
-- `recording.mp4` - The video recording (created by Jibri)
-- `metadata.json` - Basic metadata (created by Jibri)
-- `events.jsonl` - Complete participant timeline (created by this module)
-
-## Event Format
-
-Each line in `events.jsonl` is a JSON object:
-
-```json
-{"type":"room_created","timestamp":1234567890,"room_name":"TestRoom","room_jid":"testroom@conference.meet.jitsi","meeting_url":"https://meet.jitsi/TestRoom"}
-{"type":"recording_started","timestamp":1234567891,"room_name":"TestRoom","session_id":"20240115120000_TestRoom","jibri_jid":"jibri@recorder.meet.jitsi"}
-{"type":"participant_joined","timestamp":1234567892,"room_name":"TestRoom","participant":{"jid":"user1@meet.jitsi/web","nick":"John Doe","id":"user1@meet.jitsi","is_moderator":false}}
-{"type":"speaker_active","timestamp":1234567895,"room_name":"TestRoom","speaker_jid":"user1@meet.jitsi","speaker_nick":"John Doe","duration":10}
-{"type":"participant_left","timestamp":1234567920,"room_name":"TestRoom","participant":{"jid":"user1@meet.jitsi/web","nick":"John Doe","duration_seconds":28}}
-{"type":"recording_stopped","timestamp":1234567950,"room_name":"TestRoom","session_id":"20240115120000_TestRoom","meeting_url":"https://meet.jitsi/TestRoom"}
-```
-
-## Configuration Options
-
-All configuration can be done via environment variables:
-
-| Environment Variable | Default | Description |
-|---------------------|---------|-------------|
-| `JIBRI_RECORDINGS_PATH` | `/config/recordings` | Path where recordings are stored |
-| `JIBRI_LOG_SPEAKER_STATS` | `true` | Enable speaker statistics logging |
-| `JIBRI_SPEAKER_STATS_INTERVAL` | `10` | Seconds between speaker stats updates |
-
-## Verifying Installation
-
-Check that the module is loaded:
-```bash
-docker-compose logs prosody | grep "Event Logger"
-# Should see: "Event Logger loaded - writing to /config/recordings"
-```
-
-Check for events after a recording:
-```bash
-ls -la ~/.jitsi-meet-cfg/recordings/*/events.jsonl
-cat ~/.jitsi-meet-cfg/recordings/*/events.jsonl | jq .
-```
-
-## Troubleshooting
-
-### No events.jsonl file created
-
-1. **Check module is enabled**:
-   ```bash
-   docker-compose exec prosody grep -r "event_logger" /config
-   ```
-
-2. **Verify volume permissions**:
-   ```bash
-   docker-compose exec prosody ls -la /config/recordings
-   ```
-
-3. **Check Prosody logs for errors**:
-   ```bash
-   docker-compose logs prosody | grep -i error
-   ```
-
-### Module not loading
-
-1. **Verify file exists in container**:
-   ```bash
-   docker-compose exec prosody ls -la /prosody-plugins-custom/
-   ```
-
-2. **Check XMPP_MUC_MODULES format** (must be comma-separated, no spaces):
-   - ✅ Correct: `XMPP_MUC_MODULES=mod1,mod2,event_logger`
-   - ❌ Wrong: `XMPP_MUC_MODULES=mod1, mod2, event_logger`
-
-## Common docker-compose.yml Patterns
-
-### Minimal Addition (if you trust defaults)
-```yaml
-services:
-  prosody:
-    volumes:
-      - ${CONFIG}/recordings:/config/recordings:Z  # Just add this
-```
-
-### Full Configuration
-```yaml
-services:
-  prosody:
-    volumes:
-      - ${CONFIG}/prosody/config:/config:Z
-      - ${CONFIG}/prosody/prosody-plugins-custom:/prosody-plugins-custom:Z
-      - ${CONFIG}/recordings:/config/recordings:Z
-    environment:
-      - XMPP_MUC_MODULES=event_logger
-      - JIBRI_RECORDINGS_PATH=/config/recordings
-      - JIBRI_LOG_SPEAKER_STATS=true
-      - JIBRI_SPEAKER_STATS_INTERVAL=10
-
-  jibri:
-    volumes:
-      - ${CONFIG}/jibri:/config:Z
-      - ${CONFIG}/recordings:/config/recordings:Z
-    environment:
-      - JIBRI_RECORDING_DIR=/config/recordings
-      - JIBRI_FINALIZE_RECORDING_SCRIPT_PATH=/config/finalize.sh
-```
-
-## Integration with Reflector
-
-The finalize.sh script will automatically notify Reflector when a recording completes if `REFLECTOR_WEBHOOK_URL` is set. Reflector will receive:
-
-```json
-{
-  "session_id": "20240115120000_TestRoom",
-  "path": "20240115120000_TestRoom",
-  "meeting_url": "https://meet.jitsi/TestRoom"
-}
-```
-
-Reflector then processes the recording along with the complete participant timeline from `events.jsonl`.

server/contrib/jitsi/finalize.sh

@@ -1,49 +0,0 @@
-#!/bin/bash
-# Jibri finalize script to notify Reflector when recording is complete
-# This script is called by Jibri with the recording directory as argument
-
-RECORDING_PATH="$1"
-SESSION_ID=$(basename "$RECORDING_PATH")
-METADATA_FILE="$RECORDING_PATH/metadata.json"
-
-# Extract meeting URL from Jibri's metadata
-MEETING_URL=""
-if [ -f "$METADATA_FILE" ]; then
-    MEETING_URL=$(jq -r '.meeting_url' "$METADATA_FILE" 2>/dev/null || echo "")
-fi
-
-echo "[$(date)] Recording finalized: $RECORDING_PATH"
-echo "[$(date)] Session ID: $SESSION_ID"
-echo "[$(date)] Meeting URL: $MEETING_URL"
-
-# Check if events.jsonl was created by our Prosody module
-if [ -f "$RECORDING_PATH/events.jsonl" ]; then
-    EVENT_COUNT=$(wc -l < "$RECORDING_PATH/events.jsonl")
-    echo "[$(date)] Found events.jsonl with $EVENT_COUNT events"
-else
-    echo "[$(date)] Warning: No events.jsonl found"
-fi
-
-# Notify Reflector if webhook URL is configured
-if [ -n "$REFLECTOR_WEBHOOK_URL" ]; then
-    echo "[$(date)] Notifying Reflector at: $REFLECTOR_WEBHOOK_URL"
-
-    RESPONSE=$(curl -s -w "\n%{http_code}" -X POST "$REFLECTOR_WEBHOOK_URL/api/v1/jibri/recording-ready" \
-        -H "Content-Type: application/json" \
-        -d "{\"session_id\":\"$SESSION_ID\",\"path\":\"$SESSION_ID\",\"meeting_url\":\"$MEETING_URL\"}")
-
-    HTTP_CODE=$(echo "$RESPONSE" | tail -n1)
-    BODY=$(echo "$RESPONSE" | sed '$d')
-
-    if [ "$HTTP_CODE" = "200" ]; then
-        echo "[$(date)] Reflector notified successfully"
-        echo "[$(date)] Response: $BODY"
-    else
-        echo "[$(date)] Failed to notify Reflector. HTTP code: $HTTP_CODE"
-        echo "[$(date)] Response: $BODY"
-    fi
-else
-    echo "[$(date)] No REFLECTOR_WEBHOOK_URL configured, skipping notification"
-fi
-
-echo "[$(date)] Finalize script completed"

server/contrib/jitsi/mod_event_logger.lua

@@ -1,372 +0,0 @@
-local json = require "util.json"
-local st = require "util.stanza"
-local jid_bare = require "util.jid".bare
-
-local recordings_path = os.getenv("JIBRI_RECORDINGS_PATH") or
-                       module:get_option_string("jibri_recordings_path", "/recordings")
-
--- room_jid -> { session_id, participants = {jid -> info} }
-local active_recordings = {}
--- room_jid -> { participants = {jid -> info}, created_at }
-local room_states = {}
-
-local function get_timestamp()
-    return os.time()
-end
-
-local function write_event(session_id, event)
-    if not session_id then
-        module:log("warn", "No session_id for event: %s", event.type)
-        return
-    end
-
-    local session_dir = string.format("%s/%s", recordings_path, session_id)
-    local event_file = string.format("%s/events.jsonl", session_dir)
-
-    module:log("info", "Writing event %s to %s", event.type, event_file)
-
-    -- Create directory
-    local mkdir_cmd = string.format("mkdir -p '%s' 2>&1", session_dir)
-    local mkdir_result = os.execute(mkdir_cmd)
-    module:log("debug", "mkdir result: %s", tostring(mkdir_result))
-
-    local file, err = io.open(event_file, "a")
-    if file then
-        local json_str = json.encode(event)
-        file:write(json_str .. "\n")
-        file:close()
-        module:log("info", "Successfully wrote event %s", event.type)
-    else
-        module:log("error", "Failed to write event to %s: %s", event_file, err)
-    end
-end
-
-local function extract_participant_info(occupant)
-    local info = {
-        jid = occupant.jid,
-        bare_jid = occupant.bare_jid,
-        nick = occupant.nick,
-        display_name = nil,
-        role = occupant.role
-    }
-
-    local presence = occupant:get_presence()
-    if presence then
-        local nick_element = presence:get_child("nick", "http://jabber.org/protocol/nick")
-        if nick_element then
-            info.display_name = nick_element:get_text()
-        end
-
-        local identity = presence:get_child("identity")
-        if identity then
-            local user = identity:get_child("user")
-            if user then
-                local name = user:get_child("name")
-                if name then
-                    info.display_name = name:get_text()
-                end
-
-                local id_element = user:get_child("id")
-                if id_element then
-                    info.id = id_element:get_text()
-                end
-            end
-        end
-
-        if not info.display_name and occupant.nick then
-            local _, _, resource = occupant.nick:match("([^@]+)@([^/]+)/(.+)")
-            if resource then
-                info.display_name = resource
-            end
-        end
-    end
-
-    return info
-end
-
-local function get_room_participant_count(room)
-    local count = 0
-    for _ in room:each_occupant() do
-        count = count + 1
-    end
-    return count
-end
-
-local function snapshot_room_participants(room)
-    local participants = {}
-    local total = 0
-    local skipped = 0
-
-    module:log("info", "Snapshotting room participants")
-
-    for _, occupant in room:each_occupant() do
-        total = total + 1
-        -- Skip recorders (Jibri)
-        if occupant.bare_jid and (occupant.bare_jid:match("^recorder@") or
-                                  occupant.bare_jid:match("^jibri@")) then
-            skipped = skipped + 1
-        else
-            local info = extract_participant_info(occupant)
-            participants[occupant.jid] = info
-            module:log("debug", "Added participant: %s", info.display_name or info.bare_jid)
-        end
-    end
-
-    module:log("info", "Snapshot: %d total, %d participants", total, total - skipped)
-    return participants
-end
-
--- Import utility functions if available
-local util = module:require "util";
-local get_room_from_jid = util.get_room_from_jid;
-local room_jid_match_rewrite = util.room_jid_match_rewrite;
-
--- Main IQ handler for Jibri stanzas
-module:hook("pre-iq/full", function(event)
-    local stanza = event.stanza
-    if stanza.name ~= "iq" then
-        return
-    end
-
-    local jibri = stanza:get_child('jibri', 'http://jitsi.org/protocol/jibri')
-    if not jibri then
-        return
-    end
-
-    module:log("info", "=== Jibri IQ intercepted ===")
-
-    local action = jibri.attr.action
-    local session_id = jibri.attr.session_id
-    local room_jid = jibri.attr.room
-    local recording_mode = jibri.attr.recording_mode
-    local app_data = jibri.attr.app_data
-
-    module:log("info", "Jibri %s - session: %s, room: %s, mode: %s",
-               action or "?", session_id or "?", room_jid or "?", recording_mode or "?")
-
-    if not room_jid or not session_id then
-        module:log("warn", "Missing room_jid or session_id")
-        return
-    end
-
-    -- Get the room using util function
-    local room = get_room_from_jid(room_jid_match_rewrite(jid_bare(stanza.attr.to)))
-    if not room then
-        -- Try with the room_jid directly
-        room = get_room_from_jid(room_jid)
-    end
-
-    if not room then
-        module:log("error", "Room not found for jid: %s", room_jid)
-        return
-    end
-
-    module:log("info", "Room found: %s", room:get_name() or room_jid)
-
-    if action == "start" then
-        module:log("info", "Recording START for session %s", session_id)
-
-        -- Count and snapshot participants
-        local participant_count = 0
-        for _ in room:each_occupant() do
-            participant_count = participant_count + 1
-        end
-
-        local participants = snapshot_room_participants(room)
-        local participant_list = {}
-        for jid, info in pairs(participants) do
-            table.insert(participant_list, info)
-        end
-
-        active_recordings[room_jid] = {
-            session_id = session_id,
-            participants = participants,
-            started_at = get_timestamp()
-        }
-
-        write_event(session_id, {
-            type = "recording_started",
-            timestamp = get_timestamp(),
-            room_jid = room_jid,
-            room_name = room:get_name(),
-            session_id = session_id,
-            recording_mode = recording_mode,
-            app_data = app_data,
-            participant_count = participant_count,
-            participants_at_start = participant_list
-        })
-
-    elseif action == "stop" then
-        module:log("info", "Recording STOP for session %s", session_id)
-
-        local recording = active_recordings[room_jid]
-        if recording and recording.session_id == session_id then
-            write_event(session_id, {
-                type = "recording_stopped",
-                timestamp = get_timestamp(),
-                room_jid = room_jid,
-                room_name = room:get_name(),
-                session_id = session_id,
-                duration = get_timestamp() - recording.started_at,
-                participant_count = get_room_participant_count(room)
-            })
-
-            active_recordings[room_jid] = nil
-        else
-            module:log("warn", "No active recording found for room %s", room_jid)
-        end
-    end
-end);
-
--- Room and participant event hooks
-local function setup_room_hooks(host_module)
-    module:log("info", "Setting up room hooks on %s", host_module.host or "unknown")
-
-    -- Room created
-    host_module:hook("muc-room-created", function(event)
-        local room = event.room
-        local room_jid = room.jid
-
-        room_states[room_jid] = {
-            participants = {},
-            created_at = get_timestamp()
-        }
-
-        module:log("info", "Room created: %s", room_jid)
-    end)
-
-    -- Room destroyed
-    host_module:hook("muc-room-destroyed", function(event)
-        local room = event.room
-        local room_jid = room.jid
-
-        room_states[room_jid] = nil
-        active_recordings[room_jid] = nil
-
-        module:log("info", "Room destroyed: %s", room_jid)
-    end)
-
-    -- Occupant joined
-    host_module:hook("muc-occupant-joined", function(event)
-        local room = event.room
-        local occupant = event.occupant
-        local room_jid = room.jid
-
-        -- Skip recorders
-        if occupant.bare_jid and (occupant.bare_jid:match("^recorder@") or
-                                   occupant.bare_jid:match("^jibri@")) then
-            return
-        end
-
-        local participant_info = extract_participant_info(occupant)
-
-        -- Update room state
-        if room_states[room_jid] then
-            room_states[room_jid].participants[occupant.jid] = participant_info
-        end
-
-        -- Log to active recording if exists
-        local recording = active_recordings[room_jid]
-        if recording then
-            recording.participants[occupant.jid] = participant_info
-
-            write_event(recording.session_id, {
-                type = "participant_joined",
-                timestamp = get_timestamp(),
-                room_jid = room_jid,
-                room_name = room:get_name(),
-                participant = participant_info,
-                participant_count = get_room_participant_count(room)
-            })
-        end
-
-        module:log("info", "Participant joined %s: %s (%d total)",
-                   room:get_name() or room_jid,
-                   participant_info.display_name or participant_info.bare_jid,
-                   get_room_participant_count(room))
-    end)
-
-    -- Occupant left
-    host_module:hook("muc-occupant-left", function(event)
-        local room = event.room
-        local occupant = event.occupant
-        local room_jid = room.jid
-
-        -- Skip recorders
-        if occupant.bare_jid and (occupant.bare_jid:match("^recorder@") or
-                                   occupant.bare_jid:match("^jibri@")) then
-            return
-        end
-
-        local participant_info = extract_participant_info(occupant)
-
-        -- Update room state
-        if room_states[room_jid] then
-            room_states[room_jid].participants[occupant.jid] = nil
-        end
-
-        -- Log to active recording if exists
-        local recording = active_recordings[room_jid]
-        if recording then
-            if recording.participants[occupant.jid] then
-                recording.participants[occupant.jid] = nil
-            end
-
-            write_event(recording.session_id, {
-                type = "participant_left",
-                timestamp = get_timestamp(),
-                room_jid = room_jid,
-                room_name = room:get_name(),
-                participant = participant_info,
-                participant_count = get_room_participant_count(room)
-            })
-        end
-
-        module:log("info", "Participant left %s: %s (%d remaining)",
-                   room:get_name() or room_jid,
-                   participant_info.display_name or participant_info.bare_jid,
-                   get_room_participant_count(room))
-    end)
-end
-
--- Module initialization
-local current_host = module:get_host()
-local host_type = module:get_host_type()
-
-module:log("info", "Event Logger loading on %s (type: %s)", current_host, host_type or "unknown")
-module:log("info", "Recording path: %s", recordings_path)
-
--- Setup room hooks based on host type
-if host_type == "component" and current_host:match("^[^.]+%.") then
-    setup_room_hooks(module)
-else
-    -- Try to find and hook to MUC component
-    local process_host_module = util.process_host_module
-    local muc_component_host = module:get_option_string("muc_component") or
-                              module:get_option_string("main_muc")
-
-    if not muc_component_host then
-        local possible_hosts = {
-            "muc." .. current_host,
-            "conference." .. current_host,
-            "rooms." .. current_host
-        }
-
-        for _, host in ipairs(possible_hosts) do
-            if prosody.hosts[host] then
-                muc_component_host = host
-                module:log("info", "Auto-detected MUC component: %s", muc_component_host)
-                break
-            end
-        end
-    end
-
-    if muc_component_host then
-        process_host_module(muc_component_host, function(host_module, host)
-            module:log("info", "Hooking to MUC events on %s", host)
-            setup_room_hooks(host_module)
-        end)
-    else
-        module:log("error", "Could not find MUC component")
-    end
-end

server/docs/gpu/api-transcription.md

@@ -190,5 +190,5 @@ Use the pytest-based conformance tests to validate any new implementation (inclu
 ```
 TRANSCRIPT_URL=https://<your-deployment-base> \
 TRANSCRIPT_MODAL_API_KEY=your-api-key \
-uv run -m pytest -m gpu_modal --no-cov server/tests/test_gpu_modal_transcript.py
+uv run -m pytest -m model_api --no-cov server/tests/test_model_api_transcript.py
 ```

server/docs/platform-jitsi.md

@@ -1,493 +0,0 @@
-# Jitsi Integration Configuration Guide
-
-This guide provides step-by-step instructions for configuring Reflector to work with a self-hosted Jitsi Meet installation for video meetings and recording.
-
-## Prerequisites
-
-Before configuring Jitsi integration, ensure you have:
-
-- **Self-hosted Jitsi Meet installation** (version 2.0.8922 or later recommended)
-- **Jibri recording service** configured and running
-- **Prosody XMPP server** with mod_event_sync module installed
-- **Docker or system deployment** of Reflector with access to environment variables
-- **SSL certificates** for secure communication between services
-
-## Environment Configuration
-
-Add the following environment variables to your Reflector deployment:
-
-### Required Settings
-
-```bash
-# Jitsi Meet domain (without https://)
-JITSI_DOMAIN=meet.example.com
-
-# JWT secret for room authentication (generate with: openssl rand -hex 32)
-JITSI_JWT_SECRET=your-64-character-hex-secret-here
-
-# Webhook secret for secure event handling (generate with: openssl rand -hex 16)
-JITSI_WEBHOOK_SECRET=your-32-character-hex-secret-here
-
-# Application identifier (should match Jitsi configuration)
-JITSI_APP_ID=reflector
-
-# JWT issuer and audience (should match Jitsi configuration)
-JITSI_JWT_ISSUER=reflector
-JITSI_JWT_AUDIENCE=jitsi
-```
-
-### Example .env Configuration
-
-```bash
-# Add to your server/.env file
-JITSI_DOMAIN=meet.mycompany.com
-JITSI_JWT_SECRET=$(openssl rand -hex 32)
-JITSI_WEBHOOK_SECRET=$(openssl rand -hex 16)
-JITSI_APP_ID=reflector
-JITSI_JWT_ISSUER=reflector
-JITSI_JWT_AUDIENCE=jitsi
-```
-
-## Jitsi Meet Server Configuration
-
-### 1. JWT Authentication Setup
-
-Edit `/etc/prosody/conf.d/[YOUR_DOMAIN].cfg.lua`:
-
-```lua
-VirtualHost "meet.example.com"
-    authentication = "token"
-    app_id = "reflector"
-    app_secret = "your-jwt-secret-here"
-
-    -- Allow anonymous access for non-authenticated users
-    c2s_require_encryption = false
-    admins = { "focusUser@auth.meet.example.com" }
-
-    modules_enabled = {
-        "bosh";
-        "pubsub";
-        "ping";
-        "roster";
-        "saslauth";
-        "tls";
-        "dialback";
-        "disco";
-        "carbons";
-        "pep";
-        "private";
-        "blocklist";
-        "vcard";
-        "version";
-        "uptime";
-        "time";
-        "ping";
-        "register";
-        "admin_adhoc";
-        "token_verification";
-        "event_sync";  -- Required for webhook events
-    }
-```
-
-### 2. Room Access Control
-
-Edit `/etc/jitsi/meet/meet.example.com-config.js`:
-
-```javascript
-var config = {
-    hosts: {
-        domain: 'meet.example.com',
-        muc: 'conference.meet.example.com'
-    },
-
-    // Enable JWT authentication
-    enableUserRolesBasedOnToken: true,
-
-    // Recording configuration
-    fileRecordingsEnabled: true,
-    liveStreamingEnabled: false,
-
-    // Reflector-specific settings
-    prejoinPageEnabled: true,
-    requireDisplayName: true,
-};
-```
-
-### 3. Interface Configuration
-
-Edit `/usr/share/jitsi-meet/interface_config.js`:
-
-```javascript
-var interfaceConfig = {
-    // Customize for Reflector branding
-    APP_NAME: 'Reflector Meeting',
-    DEFAULT_WELCOME_PAGE_LOGO_URL: 'https://your-domain.com/logo.png',
-
-    // Hide unnecessary buttons
-    TOOLBAR_BUTTONS: [
-        'microphone', 'camera', 'closedcaptions', 'desktop',
-        'fullscreen', 'fodeviceselection', 'hangup',
-        'chat', 'recording', 'livestreaming', 'etherpad',
-        'sharedvideo', 'settings', 'raisehand', 'videoquality',
-        'filmstrip', 'invite', 'feedback', 'stats', 'shortcuts',
-        'tileview', 'videobackgroundblur', 'download', 'help',
-        'mute-everyone'
-    ]
-};
-```
-
-## Jibri Configuration
-
-### 1. Recording Service Setup
-
-Edit `/etc/jitsi/jibri/jibri.conf`:
-
-```hocon
-jibri {
-    recording {
-        recordings-directory = "/var/recordings"
-        finalize-script = "/opt/jitsi/jibri/finalize.sh"
-    }
-
-    api {
-        xmpp {
-            environments = [{
-                name = "prod environment"
-                xmpp-server-hosts = ["meet.example.com"]
-                xmpp-domain = "meet.example.com"
-
-                control-muc {
-                    domain = "internal.auth.meet.example.com"
-                    room-name = "JibriBrewery"
-                    nickname = "jibri-nickname"
-                }
-
-                control-login {
-                    domain = "auth.meet.example.com"
-                    username = "jibri"
-                    password = "jibri-password"
-                }
-            }]
-        }
-    }
-}
-```
-
-### 2. Finalize Script Setup
-
-Create `/opt/jitsi/jibri/finalize.sh`:
-
-```bash
-#!/bin/bash
-# Jibri finalize script for Reflector integration
-
-RECORDING_FILE="$1"
-ROOM_NAME="$2"
-REFLECTOR_API_URL="${REFLECTOR_API_URL:-http://localhost:1250}"
-WEBHOOK_SECRET="${JITSI_WEBHOOK_SECRET}"
-
-# Generate webhook signature
-generate_signature() {
-    local payload="$1"
-    echo -n "$payload" | openssl dgst -sha256 -hmac "$WEBHOOK_SECRET" | cut -d' ' -f2
-}
-
-# Prepare webhook payload
-TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)
-PAYLOAD=$(cat <<EOF
-{
-    "room_name": "$ROOM_NAME",
-    "recording_file": "$RECORDING_FILE",
-    "recording_status": "completed",
-    "timestamp": "$TIMESTAMP"
-}
-EOF
-)
-
-# Generate signature
-SIGNATURE=$(generate_signature "$PAYLOAD")
-
-# Send webhook to Reflector
-curl -X POST "$REFLECTOR_API_URL/v1/jibri/recording-complete" \
-    -H "Content-Type: application/json" \
-    -H "X-Jitsi-Signature: $SIGNATURE" \
-    -d "$PAYLOAD" \
-    --max-time 30
-
-echo "Recording finalization webhook sent for room: $ROOM_NAME"
-```
-
-Make the script executable:
-
-```bash
-chmod +x /opt/jitsi/jibri/finalize.sh
-```
-
-## Prosody Event Configuration
-
-### 1. Event-Sync Module Installation
-
-Install the mod_event_sync module:
-
-```bash
-# Download the module
-cd /usr/share/jitsi-meet/prosody-plugins/
-wget https://raw.githubusercontent.com/jitsi-contrib/prosody-plugins/main/mod_event_sync.lua
-
-# Or if using git
-git clone https://github.com/jitsi-contrib/prosody-plugins.git
-cp prosody-plugins/mod_event_sync.lua /usr/share/jitsi-meet/prosody-plugins/
-```
-
-### 2. Webhook Configuration
-
-Add to `/etc/prosody/conf.d/[YOUR_DOMAIN].cfg.lua`:
-
-```lua
-Component "conference.meet.example.com" "muc"
-    storage = "memory"
-    modules_enabled = {
-        "muc_meeting_id";
-        "muc_domain_mapper";
-        "polls";
-        "event_sync";  -- Enable event sync
-    }
-
-    -- Event sync webhook configuration
-    event_sync_url = "https://your-reflector-domain.com/v1/jitsi/events"
-    event_sync_secret = "your-webhook-secret-here"
-
-    -- Events to track
-    event_sync_events = {
-        "muc-occupant-joined",
-        "muc-occupant-left",
-        "jibri-recording-on",
-        "jibri-recording-off"
-    }
-```
-
-### 3. Restart Services
-
-After configuration changes, restart all services:
-
-```bash
-systemctl restart prosody
-systemctl restart jicofo
-systemctl restart jitsi-videobridge2
-systemctl restart jibri
-systemctl restart nginx
-```
-
-## Reflector Room Configuration
-
-### 1. Create Jitsi Room
-
-When creating rooms in Reflector, set the platform field:
-
-```bash
-curl -X POST "https://your-reflector-domain.com/v1/rooms" \
-    -H "Authorization: Bearer $AUTH_TOKEN" \
-    -H "Content-Type: application/json" \
-    -d '{
-        "name": "my-jitsi-room",
-        "platform": "jitsi",
-        "recording_type": "cloud",
-        "recording_trigger": "automatic-2nd-participant",
-        "is_locked": false,
-        "room_mode": "normal"
-    }'
-```
-
-### 2. Meeting Creation
-
-Meetings will automatically use Jitsi when the room platform is set to "jitsi":
-
-```bash
-curl -X POST "https://your-reflector-domain.com/v1/rooms/my-jitsi-room/meeting" \
-    -H "Authorization: Bearer $AUTH_TOKEN"
-```
-
-## Testing the Integration
-
-### 1. Health Check
-
-Verify Jitsi webhook configuration:
-
-```bash
-curl "https://your-reflector-domain.com/v1/jitsi/health"
-```
-
-Expected response:
-```json
-{
-    "status": "ok",
-    "service": "jitsi-webhooks",
-    "timestamp": "2025-01-15T10:30:00.000Z",
-    "webhook_secret_configured": true
-}
-```
-
-### 2. Room Creation Test
-
-1. Create a Jitsi room via Reflector API
-2. Start a meeting - should generate Jitsi Meet URL with JWT token
-3. Join with multiple participants - should trigger participant events
-4. Start recording - should trigger Jibri recording workflow
-
-### 3. Webhook Event Test
-
-Monitor Reflector logs for incoming webhook events:
-
-```bash
-# Check for participant events
-curl -X POST "https://your-reflector-domain.com/v1/jitsi/events" \
-    -H "Content-Type: application/json" \
-    -H "X-Jitsi-Signature: test-signature" \
-    -d '{
-        "event": "muc-occupant-joined",
-        "room": "test-room-name",
-        "timestamp": "2025-01-15T10:30:00.000Z",
-        "data": {}
-    }'
-```
-
-## Troubleshooting
-
-### Common Issues
-
-#### JWT Authentication Failures
-
-**Symptoms:** Users can't join rooms, "Authentication failed" errors
-
-**Solutions:**
-1. Verify JWT secret matches between Jitsi and Reflector
-2. Check JWT token expiration (default 8 hours)
-3. Ensure system clocks are synchronized
-4. Validate JWT issuer/audience configuration
-
-```bash
-# Debug JWT tokens
-echo "JWT_TOKEN_HERE" | cut -d'.' -f2 | base64 -d | jq
-```
-
-#### Webhook Events Not Received
-
-**Symptoms:** Participant counts not updating, recording events missing
-
-**Solutions:**
-1. Verify event_sync module is loaded in Prosody
-2. Check webhook URL accessibility from Jitsi server
-3. Validate webhook signature generation
-4. Review Prosody and Reflector logs
-
-```bash
-# Test webhook connectivity
-curl -v "https://your-reflector-domain.com/v1/jitsi/health"
-
-# Check Prosody logs
-tail -f /var/log/prosody/prosody.log
-
-# Check Reflector logs
-docker logs your-reflector-container
-```
-
-#### Recording Issues
-
-**Symptoms:** Recordings not starting, finalize script errors
-
-**Solutions:**
-1. Verify Jibri service status and configuration
-2. Check recording directory permissions
-3. Validate finalize script execution permissions
-4. Monitor Jibri logs for errors
-
-```bash
-# Check Jibri status
-systemctl status jibri
-
-# Test finalize script
-sudo -u jibri /opt/jitsi/jibri/finalize.sh "/test/recording.mp4" "test-room"
-
-# Check Jibri logs
-journalctl -u jibri -f
-```
-
-### Debug Commands
-
-```bash
-# Verify Jitsi configuration
-prosodyctl check config
-
-# Test JWT generation
-curl -X POST "https://your-reflector-domain.com/v1/rooms/test/meeting" \
-    -H "Authorization: Bearer $TOKEN" -v
-
-# Monitor webhook events
-tail -f /var/log/reflector/app.log | grep jitsi
-
-# Check room participant counts
-curl "https://your-reflector-domain.com/v1/rooms" \
-    -H "Authorization: Bearer $TOKEN" | jq '.data[].num_clients'
-```
-
-### Performance Optimization
-
-#### For High-Concurrent Usage
-
-1. **Jitsi Videobridge Tuning:**
-```bash
-# /etc/jitsi/videobridge/sip-communicator.properties
-org.jitsi.videobridge.STATISTICS_INTERVAL=5000
-org.jitsi.videobridge.load.INITIAL_STREAM_LIMIT=50
-```
-
-2. **Database Connection Pooling:**
-```python
-# In your Reflector settings
-DATABASE_POOL_SIZE=20
-DATABASE_MAX_OVERFLOW=30
-```
-
-3. **Redis Configuration:**
-```bash
-# For webhook event caching
-REDIS_URL=redis://localhost:6379/1
-WEBHOOK_EVENT_TTL=3600
-```
-
-## Security Considerations
-
-### Network Security
-- Use HTTPS/WSS for all communications
-- Implement proper firewall rules
-- Consider VPN for server-to-server communication
-
-### Authentication Security
-- Rotate JWT secrets regularly
-- Use strong webhook secrets (32+ characters)
-- Implement rate limiting on webhook endpoints
-
-### Recording Security
-- Encrypt recordings at rest
-- Implement access controls for recording files
-- Regular security audits of file permissions
-
-## Support
-
-For additional support:
-
-1. **Reflector Issues:** Check GitHub issues or create new ones
-2. **Jitsi Community:** [Community Forum](https://community.jitsi.org/)
-3. **Documentation:** [Jitsi Developer Guide](https://jitsi.github.io/handbook/)
-
-## Migration from Whereby
-
-If migrating from Whereby integration:
-
-1. Update existing rooms to use "jitsi" platform
-2. Verify webhook configurations are updated
-3. Test recording workflows thoroughly
-4. Monitor participant event accuracy
-5. Update any custom integrations using meeting APIs
-
-The platform abstraction layer ensures smooth migration with minimal API changes.

server/migrations/versions/2890b5104577_add_events_column_to_meetings_table.py

@@ -1,38 +0,0 @@
-"""Add events column to meetings table
-
-Revision ID: 2890b5104577
-Revises: 6e6ea8e607c5
-Create Date: 2025-09-02 17:51:41.620777
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "2890b5104577"
-down_revision: Union[str, None] = "6e6ea8e607c5"
-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.add_column(
-            sa.Column(
-                "events", sa.JSON(), server_default=sa.text("'[]'"), nullable=False
-            )
-        )
-
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.drop_column("events")
-
-    # ### end Alembic commands ###

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: 2ae3db106d4e
+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] = "2ae3db106d4e"
+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/6dec9fb5b46c_make_meeting_room_id_required_and_add_.py

@@ -8,7 +8,6 @@ Create Date: 2025-09-10 10:47:06.006819
 
 from typing import Sequence, Union
 
-import sqlalchemy as sa
 from alembic import op
 
 # revision identifiers, used by Alembic.
@@ -21,7 +20,6 @@ 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("room_id", existing_type=sa.VARCHAR(), nullable=False)
         batch_op.create_foreign_key(
             None, "room", ["room_id"], ["id"], ondelete="CASCADE"
         )
@@ -33,6 +31,5 @@ def downgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
     with op.batch_alter_table("meeting", schema=None) as batch_op:
         batch_op.drop_constraint("meeting_room_id_fkey", type_="foreignkey")
-        batch_op.alter_column("room_id", existing_type=sa.VARCHAR(), nullable=True)
 
     # ### end Alembic commands ###

server/migrations/versions/6e6ea8e607c5_add_videoplatform_enum_for_rooms_and_.py

@@ -1,44 +0,0 @@
-"""Add VideoPlatform enum for rooms and meetings
-
-Revision ID: 6e6ea8e607c5
-Revises: 61882a919591
-Create Date: 2025-09-02 17:33:21.022214
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "6e6ea8e607c5"
-down_revision: Union[str, None] = "61882a919591"
-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.add_column(
-            sa.Column("platform", sa.String(), server_default="whereby", nullable=False)
-        )
-
-    with op.batch_alter_table("room", schema=None) as batch_op:
-        batch_op.add_column(
-            sa.Column("platform", sa.String(), server_default="whereby", nullable=False)
-        )
-
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("room", schema=None) as batch_op:
-        batch_op.drop_column("platform")
-
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.drop_column("platform")
-
-    # ### 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/migrations/versions/d8e204bbf615_add_calendar.py

@@ -0,0 +1,129 @@
+"""add calendar
+
+Revision ID: d8e204bbf615
+Revises: d4a1c446458c
+Create Date: 2025-09-10 19:56:22.295756
+
+"""
+
+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 = "d8e204bbf615"
+down_revision: Union[str, None] = "d4a1c446458c"
+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! ###
+    op.create_table(
+        "calendar_event",
+        sa.Column("id", sa.String(), nullable=False),
+        sa.Column("room_id", sa.String(), nullable=False),
+        sa.Column("ics_uid", sa.Text(), nullable=False),
+        sa.Column("title", sa.Text(), nullable=True),
+        sa.Column("description", sa.Text(), nullable=True),
+        sa.Column("start_time", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("end_time", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("attendees", postgresql.JSONB(astext_type=sa.Text()), nullable=True),
+        sa.Column("location", sa.Text(), nullable=True),
+        sa.Column("ics_raw_data", sa.Text(), nullable=True),
+        sa.Column("last_synced", sa.DateTime(timezone=True), nullable=False),
+        sa.Column(
+            "is_deleted", sa.Boolean(), server_default=sa.text("false"), nullable=False
+        ),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["room_id"],
+            ["room.id"],
+            name="fk_calendar_event_room_id",
+            ondelete="CASCADE",
+        ),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("room_id", "ics_uid", name="uq_room_calendar_event"),
+    )
+    with op.batch_alter_table("calendar_event", schema=None) as batch_op:
+        batch_op.create_index(
+            "idx_calendar_event_deleted",
+            ["is_deleted"],
+            unique=False,
+            postgresql_where=sa.text("NOT is_deleted"),
+        )
+        batch_op.create_index(
+            "idx_calendar_event_room_start", ["room_id", "start_time"], unique=False
+        )
+
+    with op.batch_alter_table("meeting", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("calendar_event_id", sa.String(), nullable=True))
+        batch_op.add_column(
+            sa.Column(
+                "calendar_metadata",
+                postgresql.JSONB(astext_type=sa.Text()),
+                nullable=True,
+            )
+        )
+        batch_op.create_index(
+            "idx_meeting_calendar_event", ["calendar_event_id"], unique=False
+        )
+        batch_op.create_foreign_key(
+            "fk_meeting_calendar_event_id",
+            "calendar_event",
+            ["calendar_event_id"],
+            ["id"],
+            ondelete="SET NULL",
+        )
+
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("ics_url", sa.Text(), nullable=True))
+        batch_op.add_column(
+            sa.Column(
+                "ics_fetch_interval", sa.Integer(), server_default="300", nullable=True
+            )
+        )
+        batch_op.add_column(
+            sa.Column(
+                "ics_enabled",
+                sa.Boolean(),
+                server_default=sa.text("false"),
+                nullable=False,
+            )
+        )
+        batch_op.add_column(
+            sa.Column("ics_last_sync", sa.DateTime(timezone=True), nullable=True)
+        )
+        batch_op.add_column(sa.Column("ics_last_etag", sa.Text(), nullable=True))
+        batch_op.create_index("idx_room_ics_enabled", ["ics_enabled"], unique=False)
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.drop_index("idx_room_ics_enabled")
+        batch_op.drop_column("ics_last_etag")
+        batch_op.drop_column("ics_last_sync")
+        batch_op.drop_column("ics_enabled")
+        batch_op.drop_column("ics_fetch_interval")
+        batch_op.drop_column("ics_url")
+
+    with op.batch_alter_table("meeting", schema=None) as batch_op:
+        batch_op.drop_constraint("fk_meeting_calendar_event_id", type_="foreignkey")
+        batch_op.drop_index("idx_meeting_calendar_event")
+        batch_op.drop_column("calendar_metadata")
+        batch_op.drop_column("calendar_event_id")
+
+    with op.batch_alter_table("calendar_event", schema=None) as batch_op:
+        batch_op.drop_index("idx_calendar_event_room_start")
+        batch_op.drop_index(
+            "idx_calendar_event_deleted", postgresql_where=sa.text("NOT is_deleted")
+        )
+
+    op.drop_table("calendar_event")
+    # ### end Alembic commands ###

server/migrations/versions/dc035ff72fd5_remove_grace_period_fields.py

@@ -0,0 +1,43 @@
+"""remove_grace_period_fields
+
+Revision ID: dc035ff72fd5
+Revises: d8e204bbf615
+Create Date: 2025-09-11 10:36:45.197588
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "dc035ff72fd5"
+down_revision: Union[str, None] = "d8e204bbf615"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Remove grace period columns from meeting table
+    op.drop_column("meeting", "last_participant_left_at")
+    op.drop_column("meeting", "grace_period_minutes")
+
+
+def downgrade() -> None:
+    # Add back grace period columns to meeting table
+    op.add_column(
+        "meeting",
+        sa.Column(
+            "last_participant_left_at", sa.DateTime(timezone=True), nullable=True
+        ),
+    )
+    op.add_column(
+        "meeting",
+        sa.Column(
+            "grace_period_minutes",
+            sa.Integer(),
+            server_default=sa.text("15"),
+            nullable=True,
+        ),
+    )

server/pyproject.toml

@@ -12,7 +12,6 @@ dependencies = [
     "requests>=2.31.0",
     "aiortc>=1.5.0",
     "sortedcontainers>=2.4.0",
-    "loguru>=0.7.0",
     "pydantic-settings>=2.0.2",
     "structlog>=23.1.0",
     "uvicorn[standard]>=0.23.1",
@@ -27,7 +26,6 @@ dependencies = [
     "prometheus-fastapi-instrumentator>=6.1.0",
     "sentencepiece>=0.1.99",
     "protobuf>=4.24.3",
-    "profanityfilter>=2.0.6",
     "celery>=5.3.4",
     "redis>=5.0.1",
     "python-jose[cryptography]>=3.3.0",
@@ -40,7 +38,7 @@ dependencies = [
     "llama-index-llms-openai-like>=0.4.0",
     "pytest-env>=1.1.5",
     "webvtt-py>=0.5.0",
-    "PyJWT>=2.8.0",
+    "icalendar>=6.0.0",
 ]
 
 [dependency-groups]
@@ -120,7 +118,7 @@ addopts = "-ra -q --disable-pytest-warnings --cov --cov-report html -v"
 testpaths = ["tests"]
 asyncio_mode = "auto"
 markers = [
-    "gpu_modal: mark test to run only with GPU Modal endpoints (deselect with '-m \"not gpu_modal\"')",
+    "model_api: tests for the unified model-serving HTTP API (backend- and hardware-agnostic)",
 ]
 
 [tool.ruff.lint]
@@ -132,7 +130,7 @@ select = [
 
 [tool.ruff.lint.per-file-ignores]
 "reflector/processors/summary/summary_builder.py" = ["E501"]
-"gpu/**.py" = ["PLC0415"]
+"gpu/modal_deployments/**.py" = ["PLC0415"]
 "reflector/tools/**.py" = ["PLC0415"]
 "migrations/versions/**.py" = ["PLC0415"]
 "tests/**.py" = ["PLC0415"]

server/reflector/app.py

@@ -12,9 +12,6 @@ from reflector.events import subscribers_shutdown, subscribers_startup
 from reflector.logger import logger
 from reflector.metrics import metrics_init
 from reflector.settings import settings
-from reflector.video_platforms.jitsi import router as jitsi_router
-from reflector.video_platforms.whereby import router as whereby_router
-from reflector.views.jibri_webhook import router as jibri_webhook_router
 from reflector.views.meetings import router as meetings_router
 from reflector.views.rooms import router as rooms_router
 from reflector.views.rtc_offer import router as rtc_offer_router
@@ -29,6 +26,7 @@ from reflector.views.transcripts_upload import router as transcripts_upload_rout
 from reflector.views.transcripts_webrtc import router as transcripts_webrtc_router
 from reflector.views.transcripts_websocket import router as transcripts_websocket_router
 from reflector.views.user import router as user_router
+from reflector.views.whereby import router as whereby_router
 from reflector.views.zulip import router as zulip_router
 
 try:
@@ -88,8 +86,6 @@ app.include_router(transcripts_process_router, prefix="/v1")
 app.include_router(user_router, prefix="/v1")
 app.include_router(zulip_router, prefix="/v1")
 app.include_router(whereby_router, prefix="/v1")
-app.include_router(jitsi_router, prefix="/v1")
-app.include_router(jibri_webhook_router)  # No /v1 prefix, uses /api/v1/jibri
 add_pagination(app)
 
 # prepare celery

server/reflector/auth/auth_jwt.py

@@ -67,7 +67,8 @@ def current_user(
     try:
         payload = jwtauth.verify_token(token)
         sub = payload["sub"]
-        return UserInfo(sub=sub)
+        email = payload["email"]
+        return UserInfo(sub=sub, email=email)
     except JWTError as e:
         logger.error(f"JWT error: {e}")
         raise HTTPException(status_code=401, detail="Invalid authentication")

server/reflector/db/__init__.py

@@ -24,6 +24,7 @@ def get_database() -> databases.Database:
 
 
 # import models
+import reflector.db.calendar_events  # noqa
 import reflector.db.meetings  # noqa
 import reflector.db.recordings  # noqa
 import reflector.db.rooms  # noqa

server/reflector/db/calendar_events.py

@@ -0,0 +1,182 @@
+from datetime import datetime, timedelta, 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", name="fk_calendar_event_room_id"),
+        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]:
+        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 = 120
+    ) -> list[CalendarEvent]:
+        """Get upcoming events for a room within the specified minutes, including currently happening events."""
+        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 <= future_time,
+                    calendar_events.c.end_time >= now,
+                )
+            )
+            .order_by(calendar_events.c.start_time.asc())
+        )
+
+        results = await get_database().fetch_all(query)
+        return [CalendarEvent(**result) for result in results]
+
+    async def get_by_ics_uid(self, room_id: str, ics_uid: str) -> CalendarEvent | None:
+        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:
+        existing = await self.get_by_ics_uid(event.room_id, event.ics_uid)
+
+        if existing:
+            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:
+            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)
+
+        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:
+            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:
+        query = calendar_events.delete().where(calendar_events.c.room_id == room_id)
+        result = await get_database().execute(query)
+        return result.rowcount
+
+
+calendar_events_controller = CalendarEventController()

server/reflector/db/meetings.py

@@ -1,11 +1,12 @@
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Literal
+from datetime import datetime
+from typing import Any, Literal
 
 import sqlalchemy as sa
 from pydantic import BaseModel, Field
+from sqlalchemy.dialects.postgresql import JSONB
 
 from reflector.db import get_database, metadata
-from reflector.db.rooms import Room, VideoPlatform
+from reflector.db.rooms import Room
 from reflector.utils import generate_uuid4
 
 meetings = sa.Table(
@@ -44,15 +45,18 @@ meetings = sa.Table(
         nullable=False,
         server_default=sa.true(),
     ),
-    sa.Column("platform", sa.String, nullable=False, server_default="whereby"),
-    sa.Column("events", sa.JSON, nullable=False, server_default=sa.text("'[]'")),
-    sa.Index("idx_meeting_room_id", "room_id"),
-    sa.Index(
-        "idx_one_active_meeting_per_room",
-        "room_id",
-        unique=True,
-        postgresql_where=sa.text("is_active = true"),
+    sa.Column(
+        "calendar_event_id",
+        sa.String,
+        sa.ForeignKey(
+            "calendar_event.id",
+            ondelete="SET NULL",
+            name="fk_meeting_calendar_event_id",
         ),
+    ),
+    sa.Column("calendar_metadata", JSONB),
+    sa.Index("idx_meeting_room_id", "room_id"),
+    sa.Index("idx_meeting_calendar_event", "calendar_event_id"),
 )
 
 meeting_consent = sa.Table(
@@ -94,8 +98,9 @@ class Meeting(BaseModel):
         "none", "prompt", "automatic", "automatic-2nd-participant"
     ] = "automatic-2nd-participant"
     num_clients: int = 0
-    platform: VideoPlatform = VideoPlatform.WHEREBY
-    events: List[Dict[str, Any]] = Field(default_factory=list)
+    is_active: bool = True
+    calendar_event_id: str | None = None
+    calendar_metadata: dict[str, Any] | None = None
 
 
 class MeetingController:
@@ -108,6 +113,8 @@ class MeetingController:
         start_date: datetime,
         end_date: datetime,
         room: Room,
+        calendar_event_id: str | None = None,
+        calendar_metadata: dict[str, Any] | None = None,
     ):
         meeting = Meeting(
             id=id,
@@ -121,7 +128,8 @@ class MeetingController:
             room_mode=room.room_mode,
             recording_type=room.recording_type,
             recording_trigger=room.recording_trigger,
-            platform=room.platform,
+            calendar_event_id=calendar_event_id,
+            calendar_metadata=calendar_metadata,
         )
         query = meetings.insert().values(**meeting.model_dump())
         await get_database().execute(query)
@@ -135,7 +143,16 @@ class MeetingController:
         self,
         room_name: str,
     ) -> Meeting | None:
-        query = meetings.select().where(meetings.c.room_name == room_name)
+        """
+        Get a meeting by room name.
+        For backward compatibility, returns the most recent meeting.
+        """
+        end_date = getattr(meetings.c, "end_date")
+        query = (
+            meetings.select()
+            .where(meetings.c.room_name == room_name)
+            .order_by(end_date.desc())
+        )
         result = await get_database().fetch_one(query)
         if not result:
             return None
@@ -143,6 +160,10 @@ class MeetingController:
         return Meeting(**result)
 
     async def get_active(self, room: Room, current_time: datetime) -> Meeting | None:
+        """
+        Get latest active meeting for a room.
+        For backward compatibility, returns the most recent active meeting.
+        """
         end_date = getattr(meetings.c, "end_date")
         query = (
             meetings.select()
@@ -161,6 +182,43 @@ class MeetingController:
 
         return Meeting(**result)
 
+    async def get_all_active_for_room(
+        self, room: Room, current_time: datetime
+    ) -> list[Meeting]:
+        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:
         query = meetings.select().where(meetings.c.id == meeting_id)
         result = await get_database().fetch_one(query)
@@ -168,72 +226,19 @@ class MeetingController:
             return None
         return Meeting(**result)
 
+    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 get_database().execute(query)
 
-    async def add_event(
-        self, meeting_id: str, event_type: str, event_data: Dict[str, Any] = None
-    ):
-        """Add an event to a meeting's events list."""
-        if event_data is None:
-            event_data = {}
-
-        event = {
-            "type": event_type,
-            "timestamp": datetime.now(tz=timezone.utc).isoformat(),
-            "data": event_data,
-        }
-
-        # Get current events
-        query = meetings.select().where(meetings.c.id == meeting_id)
-        result = await get_database().fetch_one(query)
-        if not result:
-            return
-
-        current_events = result["events"] or []
-        current_events.append(event)
-
-        # Update with new events list
-        update_query = (
-            meetings.update()
-            .where(meetings.c.id == meeting_id)
-            .values(events=current_events)
-        )
-        await get_database().execute(update_query)
-
-    async def participant_joined(
-        self, meeting_id: str, participant_data: Dict[str, Any] = None
-    ):
-        """Record a participant joined event."""
-        await self.add_event(meeting_id, "participant_joined", participant_data)
-
-    async def participant_left(
-        self, meeting_id: str, participant_data: Dict[str, Any] = None
-    ):
-        """Record a participant left event."""
-        await self.add_event(meeting_id, "participant_left", participant_data)
-
-    async def recording_started(
-        self, meeting_id: str, recording_data: Dict[str, Any] = None
-    ):
-        """Record a recording started event."""
-        await self.add_event(meeting_id, "recording_started", recording_data)
-
-    async def recording_stopped(
-        self, meeting_id: str, recording_data: Dict[str, Any] = None
-    ):
-        """Record a recording stopped event."""
-        await self.add_event(meeting_id, "recording_stopped", recording_data)
-
-    async def get_events(self, meeting_id: str) -> List[Dict[str, Any]]:
-        """Get all events for a meeting."""
-        query = meetings.select().where(meetings.c.id == meeting_id)
-        result = await get_database().fetch_one(query)
-        if not result:
-            return []
-        return result["events"] or []
-
 
 class MeetingConsentController:
     async def get_by_meeting_id(self, meeting_id: str) -> list[MeetingConsent]:
@@ -257,7 +262,6 @@ class MeetingConsentController:
         return MeetingConsent(**result)
 
     async def upsert(self, consent: MeetingConsent) -> MeetingConsent:
-        """Create new consent or update existing one for authenticated users"""
         if consent.user_id:
             # For authenticated users, check if consent already exists
             # not transactional but we're ok with that; the consents ain't deleted anyways

server/reflector/db/rooms.py

@@ -1,6 +1,5 @@
 import secrets
 from datetime import datetime, timezone
-from enum import StrEnum
 from sqlite3 import IntegrityError
 from typing import Literal
 
@@ -12,12 +11,6 @@ from sqlalchemy.sql import false, or_
 from reflector.db import get_database, metadata
 from reflector.utils import generate_uuid4
 
-
-class VideoPlatform(StrEnum):
-    WHEREBY = "whereby"
-    JITSI = "jitsi"
-
-
 rooms = sqlalchemy.Table(
     "room",
     metadata,
@@ -50,10 +43,15 @@ rooms = sqlalchemy.Table(
     ),
     sqlalchemy.Column("webhook_url", sqlalchemy.String, nullable=True),
     sqlalchemy.Column("webhook_secret", sqlalchemy.String, nullable=True),
+    sqlalchemy.Column("ics_url", sqlalchemy.Text),
+    sqlalchemy.Column("ics_fetch_interval", sqlalchemy.Integer, server_default="300"),
     sqlalchemy.Column(
-        "platform", sqlalchemy.String, nullable=False, server_default="whereby"
+        "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"),
 )
 
 
@@ -74,7 +72,11 @@ class Room(BaseModel):
     is_shared: bool = False
     webhook_url: str | None = None
     webhook_secret: str | None = None
-    platform: VideoPlatform = VideoPlatform.WHEREBY
+    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:
@@ -125,7 +127,9 @@ class RoomController:
         is_shared: bool,
         webhook_url: str = "",
         webhook_secret: str = "",
-        platform: str = "whereby",
+        ics_url: str | None = None,
+        ics_fetch_interval: int = 300,
+        ics_enabled: bool = False,
     ):
         """
         Add a new room
@@ -146,7 +150,9 @@ class RoomController:
             is_shared=is_shared,
             webhook_url=webhook_url,
             webhook_secret=webhook_secret,
-            platform=platform,
+            ics_url=ics_url,
+            ics_fetch_interval=ics_fetch_interval,
+            ics_enabled=ics_enabled,
         )
         query = rooms.insert().values(**room.model_dump())
         try:
@@ -211,6 +217,13 @@ class RoomController:
 
         return room
 
+    async def get_ics_enabled(self) -> list[Room]:
+        query = rooms.select().where(
+            rooms.c.ics_enabled == True, rooms.c.ics_url != None
+        )
+        results = await get_database().fetch_all(query)
+        return [Room(**result) for result in results]
+
     async def remove_by_id(
         self,
         room_id: str,

server/reflector/jibri_events.py

@@ -1,227 +0,0 @@
-import json
-from pathlib import Path
-from typing import Any, Dict, List, Literal, Optional, Union
-
-from pydantic import BaseModel
-from typing_extensions import TypedDict
-
-
-class ParticipantInfo(BaseModel):
-    jid: str
-    nick: str
-    id: str
-    is_moderator: bool = False
-
-
-class ParticipantLeftInfo(BaseModel):
-    jid: str
-    nick: Optional[str] = None
-    duration_seconds: Optional[int] = None
-
-
-class RoomCreatedEvent(BaseModel):
-    type: Literal["room_created"]
-    timestamp: int
-    room_name: str
-    room_jid: str
-    meeting_url: str
-
-
-class RecordingStartedEvent(BaseModel):
-    type: Literal["recording_started"]
-    timestamp: int
-    room_name: str
-    session_id: str
-    jibri_jid: str
-
-
-class RecordingStoppedEvent(BaseModel):
-    type: Literal["recording_stopped"]
-    timestamp: int
-    room_name: str
-    session_id: str
-    meeting_url: str
-
-
-class ParticipantJoinedEvent(BaseModel):
-    type: Literal["participant_joined"]
-    timestamp: int
-    room_name: str
-    participant: ParticipantInfo
-
-
-class ParticipantLeftEvent(BaseModel):
-    type: Literal["participant_left"]
-    timestamp: int
-    room_name: str
-    participant: ParticipantLeftInfo
-
-
-class SpeakerActiveEvent(BaseModel):
-    type: Literal["speaker_active"]
-    timestamp: int
-    room_name: str
-    speaker_jid: str
-    speaker_nick: str
-    duration: int
-
-
-class DominantSpeakerChangedEvent(BaseModel):
-    type: Literal["dominant_speaker_changed"]
-    timestamp: int
-    room_name: str
-    previous: str
-    current: str
-
-
-JitsiEvent = Union[
-    RoomCreatedEvent,
-    RecordingStartedEvent,
-    RecordingStoppedEvent,
-    ParticipantJoinedEvent,
-    ParticipantLeftEvent,
-    SpeakerActiveEvent,
-    DominantSpeakerChangedEvent,
-]
-
-
-class RoomInfo(TypedDict):
-    name: str
-    jid: str
-    created_at: int
-    meeting_url: str
-    recording_stopped_at: Optional[int]
-
-
-class ParticipantData(TypedDict):
-    jid: str
-    nick: str
-    id: str
-    is_moderator: bool
-    joined_at: int
-    left_at: Optional[int]
-    duration: Optional[int]
-    events: List[str]
-
-
-class SpeakerStats(TypedDict):
-    total_time: int
-    nick: str
-
-
-class ParsedMetadata(TypedDict):
-    room: RoomInfo
-    participants: List[ParticipantData]
-    speaker_stats: Dict[str, SpeakerStats]
-    event_count: int
-
-
-class JitsiEventParser:
-    def parse_event(self, event_data: Dict[str, Any]) -> Optional[JitsiEvent]:
-        event_type = event_data.get("type")
-
-        try:
-            if event_type == "room_created":
-                return RoomCreatedEvent(**event_data)
-            elif event_type == "recording_started":
-                return RecordingStartedEvent(**event_data)
-            elif event_type == "recording_stopped":
-                return RecordingStoppedEvent(**event_data)
-            elif event_type == "participant_joined":
-                return ParticipantJoinedEvent(**event_data)
-            elif event_type == "participant_left":
-                return ParticipantLeftEvent(**event_data)
-            elif event_type == "speaker_active":
-                return SpeakerActiveEvent(**event_data)
-            elif event_type == "dominant_speaker_changed":
-                return DominantSpeakerChangedEvent(**event_data)
-            else:
-                return None
-        except Exception:
-            return None
-
-    def parse_events_file(self, recording_path: str) -> ParsedMetadata:
-        events_file = Path(recording_path) / "events.jsonl"
-
-        room_info: RoomInfo = {
-            "name": "",
-            "jid": "",
-            "created_at": 0,
-            "meeting_url": "",
-            "recording_stopped_at": None,
-        }
-
-        if not events_file.exists():
-            return ParsedMetadata(
-                room=room_info, participants=[], speaker_stats={}, event_count=0
-            )
-
-        events: List[JitsiEvent] = []
-        participants: Dict[str, ParticipantData] = {}
-        speaker_stats: Dict[str, SpeakerStats] = {}
-
-        with open(events_file, "r") as f:
-            for line in f:
-                if not line.strip():
-                    continue
-
-                try:
-                    event_data = json.loads(line)
-                    event = self.parse_event(event_data)
-
-                    if event is None:
-                        continue
-
-                    events.append(event)
-
-                    if isinstance(event, RoomCreatedEvent):
-                        room_info = {
-                            "name": event.room_name,
-                            "jid": event.room_jid,
-                            "created_at": event.timestamp,
-                            "meeting_url": event.meeting_url,
-                            "recording_stopped_at": None,
-                        }
-
-                    elif isinstance(event, ParticipantJoinedEvent):
-                        participants[event.participant.id] = {
-                            "jid": event.participant.jid,
-                            "nick": event.participant.nick,
-                            "id": event.participant.id,
-                            "is_moderator": event.participant.is_moderator,
-                            "joined_at": event.timestamp,
-                            "left_at": None,
-                            "duration": None,
-                            "events": ["joined"],
-                        }
-
-                    elif isinstance(event, ParticipantLeftEvent):
-                        participant_id = event.participant.jid.split("/")[0]
-                        if participant_id in participants:
-                            participants[participant_id]["left_at"] = event.timestamp
-                            participants[participant_id]["duration"] = (
-                                event.participant.duration_seconds
-                            )
-                            participants[participant_id]["events"].append("left")
-
-                    elif isinstance(event, SpeakerActiveEvent):
-                        if event.speaker_jid not in speaker_stats:
-                            speaker_stats[event.speaker_jid] = {
-                                "total_time": 0,
-                                "nick": event.speaker_nick,
-                            }
-                        speaker_stats[event.speaker_jid]["total_time"] += event.duration
-
-                    elif isinstance(event, RecordingStoppedEvent):
-                        room_info["recording_stopped_at"] = event.timestamp
-                        room_info["meeting_url"] = event.meeting_url
-
-                except (json.JSONDecodeError, Exception):
-                    continue
-
-        return ParsedMetadata(
-            room=room_info,
-            participants=list(participants.values()),
-            speaker_stats=speaker_stats,
-            event_count=len(events),
-        )

server/reflector/processors/types.py

@@ -4,11 +4,8 @@ import tempfile
 from pathlib import Path
 from typing import Annotated, TypedDict
 
-from profanityfilter import ProfanityFilter
 from pydantic import BaseModel, Field, PrivateAttr
 
-from reflector.redis_cache import redis_cache
-
 
 class DiarizationSegment(TypedDict):
     """Type definition for diarization segment containing speaker information"""
@@ -20,9 +17,6 @@ class DiarizationSegment(TypedDict):
 
 PUNC_RE = re.compile(r"[.;:?!…]")
 
-profanity_filter = ProfanityFilter()
-profanity_filter.set_censor("*")
-
 
 class AudioFile(BaseModel):
     name: str
@@ -124,21 +118,11 @@ def words_to_segments(words: list[Word]) -> list[TranscriptSegment]:
 
 class Transcript(BaseModel):
     translation: str | None = None
-    words: list[Word] = None
-
-    @property
-    def raw_text(self):
-        # Uncensored text
-        return "".join([word.text for word in self.words])
-
-    @redis_cache(prefix="profanity", duration=3600 * 24 * 7)
-    def _get_censored_text(self, text: str):
-        return profanity_filter.censor(text).strip()
+    words: list[Word] = []
 
     @property
     def text(self):
-        # Censored text
-        return self._get_censored_text(self.raw_text)
+        return "".join([word.text for word in self.words])
 
     @property
     def human_timestamp(self):
@@ -170,12 +154,6 @@ class Transcript(BaseModel):
             word.start += offset
             word.end += offset
 
-    def clone(self):
-        words = [
-            Word(text=word.text, start=word.start, end=word.end) for word in self.words
-        ]
-        return Transcript(text=self.text, translation=self.translation, words=words)
-
     def as_segments(self) -> list[TranscriptSegment]:
         return words_to_segments(self.words)
 

server/reflector/redis_cache.py

@@ -1,10 +1,17 @@
+import asyncio
 import functools
 import json
+from typing import Optional
 
 import redis
+import redis.asyncio as redis_async
+import structlog
+from redis.exceptions import LockError
 
 from reflector.settings import settings
 
+logger = structlog.get_logger(__name__)
+
 redis_clients = {}
 
 
@@ -21,6 +28,12 @@ def get_redis_client(db=0):
     return redis_clients[db]
 
 
+async def get_async_redis_client(db: int = 0):
+    return await redis_async.from_url(
+        f"redis://{settings.REDIS_HOST}:{settings.REDIS_PORT}/{db}"
+    )
+
+
 def redis_cache(prefix="cache", duration=3600, db=settings.REDIS_CACHE_DB, argidx=1):
     """
     Cache the result of a function in Redis.
@@ -49,3 +62,87 @@ def redis_cache(prefix="cache", duration=3600, db=settings.REDIS_CACHE_DB, argid
         return wrapper
 
     return decorator
+
+
+class RedisAsyncLock:
+    def __init__(
+        self,
+        key: str,
+        timeout: int = 120,
+        extend_interval: int = 30,
+        skip_if_locked: bool = False,
+        blocking: bool = True,
+        blocking_timeout: Optional[float] = None,
+    ):
+        self.key = f"async_lock:{key}"
+        self.timeout = timeout
+        self.extend_interval = extend_interval
+        self.skip_if_locked = skip_if_locked
+        self.blocking = blocking
+        self.blocking_timeout = blocking_timeout
+        self._lock = None
+        self._redis = None
+        self._extend_task = None
+        self._acquired = False
+
+    async def _extend_lock_periodically(self):
+        while True:
+            try:
+                await asyncio.sleep(self.extend_interval)
+                if self._lock:
+                    await self._lock.extend(self.timeout, replace_ttl=True)
+                    logger.debug("Extended lock", key=self.key)
+            except LockError:
+                logger.warning("Failed to extend lock", key=self.key)
+                break
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error("Error extending lock", key=self.key, error=str(e))
+                break
+
+    async def __aenter__(self):
+        self._redis = await get_async_redis_client()
+        self._lock = self._redis.lock(
+            self.key,
+            timeout=self.timeout,
+            blocking=self.blocking,
+            blocking_timeout=self.blocking_timeout,
+        )
+
+        self._acquired = await self._lock.acquire()
+
+        if not self._acquired:
+            if self.skip_if_locked:
+                logger.warning(
+                    "Lock already acquired by another process, skipping", key=self.key
+                )
+                return self
+            else:
+                raise LockError(f"Failed to acquire lock: {self.key}")
+
+        self._extend_task = asyncio.create_task(self._extend_lock_periodically())
+        logger.info("Acquired lock", key=self.key)
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self._extend_task:
+            self._extend_task.cancel()
+            try:
+                await self._extend_task
+            except asyncio.CancelledError:
+                pass
+
+        if self._acquired and self._lock:
+            try:
+                await self._lock.release()
+                logger.info("Released lock", key=self.key)
+            except LockError:
+                logger.debug("Lock already released or expired", key=self.key)
+
+        if self._redis:
+            await self._redis.aclose()
+
+    @property
+    def acquired(self) -> bool:
+        return self._acquired

server/reflector/services/ics_sync.py

@@ -0,0 +1,408 @@
+"""
+ICS Calendar Synchronization Service
+
+This module provides services for fetching, parsing, and synchronizing ICS (iCalendar)
+calendar feeds with room booking data in the database.
+
+Key Components:
+- ICSFetchService: Handles HTTP fetching and parsing of ICS calendar data
+- ICSSyncService: Manages the synchronization process between ICS feeds and database
+
+Example Usage:
+    # Sync a room's calendar
+    room = Room(id="room1", name="conference-room", ics_url="https://cal.example.com/room.ics")
+    result = await ics_sync_service.sync_room_calendar(room)
+
+    # Result structure:
+    {
+        "status": "success",  # success|unchanged|error|skipped
+        "hash": "abc123...",  # MD5 hash of ICS content
+        "events_found": 5,    # Events matching this room
+        "total_events": 12,   # Total events in calendar within time window
+        "events_created": 2,  # New events added to database
+        "events_updated": 3,  # Existing events modified
+        "events_deleted": 1   # Events soft-deleted (no longer in calendar)
+    }
+
+Event Matching:
+    Events are matched to rooms by checking if the room's full URL appears in the
+    event's LOCATION or DESCRIPTION fields. Only events within a 25-hour window
+    (1 hour ago to 24 hours from now) are processed.
+
+Input: ICS calendar URL (e.g., "https://calendar.google.com/calendar/ical/...")
+Output: EventData objects with structured calendar information:
+    {
+        "ics_uid": "event123@google.com",
+        "title": "Team Meeting",
+        "description": "Weekly sync meeting",
+        "location": "https://meet.company.com/conference-room",
+        "start_time": datetime(2024, 1, 15, 14, 0, tzinfo=UTC),
+        "end_time": datetime(2024, 1, 15, 15, 0, tzinfo=UTC),
+        "attendees": [
+            {"email": "user@company.com", "name": "John Doe", "role": "ORGANIZER"},
+            {"email": "attendee@company.com", "name": "Jane Smith", "status": "ACCEPTED"}
+        ],
+        "ics_raw_data": "BEGIN:VEVENT\nUID:event123@google.com\n..."
+    }
+"""
+
+import hashlib
+from datetime import date, datetime, timedelta, timezone
+from enum import Enum
+from typing import TypedDict
+
+import httpx
+import pytz
+import structlog
+from icalendar import Calendar, Event
+
+from reflector.db.calendar_events import CalendarEvent, calendar_events_controller
+from reflector.db.rooms import Room, rooms_controller
+from reflector.redis_cache import RedisAsyncLock
+from reflector.settings import settings
+
+logger = structlog.get_logger()
+
+EVENT_WINDOW_DELTA_START = timedelta(hours=-1)
+EVENT_WINDOW_DELTA_END = timedelta(hours=24)
+
+
+class SyncStatus(str, Enum):
+    SUCCESS = "success"
+    UNCHANGED = "unchanged"
+    ERROR = "error"
+    SKIPPED = "skipped"
+
+
+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 SyncResultBase(TypedDict):
+    status: SyncStatus
+
+
+class SyncResult(SyncResultBase, total=False):
+    hash: str | None
+    events_found: int
+    total_events: int
+    events_created: int
+    events_updated: int
+    events_deleted: int
+    error: str | None
+    reason: str | None
+
+
+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
+    ) -> tuple[list[EventData], int]:
+        events = []
+        total_events = 0
+        now = datetime.now(timezone.utc)
+        window_start = now + EVENT_WINDOW_DELTA_START
+        window_end = now + EVENT_WINDOW_DELTA_END
+
+        for component in calendar.walk():
+            if component.name != "VEVENT":
+                continue
+
+            status = component.get("STATUS", "").upper()
+            if status == "CANCELLED":
+                continue
+
+            # Count total non-cancelled events in the time window
+            event_data = self._parse_event(component)
+            if event_data and window_start <= event_data["start_time"] <= window_end:
+                total_events += 1
+
+                # Check if event matches this room
+                if self._event_matches_room(component, room_name, room_url):
+                    events.append(event_data)
+
+        return events, total_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
+        # XXX leaved here as a patterns, to later be extended with tinyurl or such too
+        patterns = [
+            room_url,
+        ]
+
+        # 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:
+        uid = str(event.get("UID", ""))
+        summary = str(event.get("SUMMARY", ""))
+        description = str(event.get("DESCRIPTION", ""))
+        location = str(event.get("LOCATION", ""))
+        dtstart = event.get("DTSTART")
+        dtend = event.get("DTEND")
+
+        if not dtstart:
+            return None
+
+        # Convert fields
+        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)
+        )
+        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:
+        # Ensure datetime is with timezone, if not, assume UTC
+        if isinstance(dt, date) and not isinstance(dt, datetime):
+            dt = datetime.combine(dt, datetime.min.time())
+            dt = pytz.UTC.localize(dt)
+        elif isinstance(dt, datetime):
+            if dt.tzinfo is None:
+                dt = pytz.UTC.localize(dt)
+            else:
+                dt = dt.astimezone(pytz.UTC)
+
+        return dt
+
+    def _parse_attendees(self, event: Event) -> list[AttendeeData]:
+        # Extracts attendee information from both ATTENDEE and ORGANIZER properties.
+        # Handles malformed comma-separated email addresses in single ATTENDEE fields
+        # by splitting them into separate attendee entries. Returns a list of attendee
+        # data including email, name, status, and role information.
+        final_attendees = []
+
+        attendees = event.get("ATTENDEE", [])
+        if not isinstance(attendees, list):
+            attendees = [attendees]
+        for att in attendees:
+            email_str = str(att).replace("mailto:", "") if att else None
+
+            # Handle malformed comma-separated email addresses in a single ATTENDEE field
+            if email_str and "," in email_str:
+                # Split comma-separated emails and create separate attendee entries
+                email_parts = [email.strip() for email in email_str.split(",")]
+                for email in email_parts:
+                    if email and "@" in email:
+                        clean_email = email.replace("MAILTO:", "").replace(
+                            "mailto:", ""
+                        )
+                        att_data: AttendeeData = {
+                            "email": clean_email,
+                            "name": att.params.get("CN")
+                            if hasattr(att, "params") and email == email_parts[0]
+                            else None,
+                            "status": att.params.get("PARTSTAT")
+                            if hasattr(att, "params") and email == email_parts[0]
+                            else None,
+                            "role": att.params.get("ROLE")
+                            if hasattr(att, "params") and email == email_parts[0]
+                            else None,
+                        }
+                        final_attendees.append(att_data)
+            else:
+                # Normal single attendee
+                att_data: AttendeeData = {
+                    "email": email_str,
+                    "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,
+                }
+                final_attendees.append(att_data)
+
+        # Add organizer
+        organizer = event.get("ORGANIZER")
+        if organizer:
+            org_email = (
+                str(organizer).replace("mailto:", "").replace("MAILTO:", "")
+                if organizer
+                else None
+            )
+            org_data: AttendeeData = {
+                "email": org_email,
+                "name": organizer.params.get("CN")
+                if hasattr(organizer, "params")
+                else None,
+                "role": "ORGANIZER",
+            }
+            final_attendees.append(org_data)
+
+        return final_attendees
+
+
+class ICSSyncService:
+    def __init__(self):
+        self.fetch_service = ICSFetchService()
+
+    async def sync_room_calendar(self, room: Room) -> SyncResult:
+        async with RedisAsyncLock(
+            f"ics_sync_room:{room.id}", skip_if_locked=True
+        ) as lock:
+            if not lock.acquired:
+                logger.warning("ICS sync already in progress for room", room_id=room.id)
+                return {
+                    "status": SyncStatus.SKIPPED,
+                    "reason": "Sync already in progress",
+                }
+
+            return await self._sync_room_calendar(room)
+
+    async def _sync_room_calendar(self, room: Room) -> SyncResult:
+        if not room.ics_enabled or not room.ics_url:
+            return {"status": SyncStatus.SKIPPED, "reason": "ICS not configured"}
+
+        try:
+            if not self._should_sync(room):
+                return {"status": SyncStatus.SKIPPED, "reason": "Not time to sync yet"}
+
+            ics_content = await self.fetch_service.fetch_ics(room.ics_url)
+            calendar = self.fetch_service.parse_ics(ics_content)
+
+            content_hash = hashlib.md5(ics_content.encode()).hexdigest()
+            if room.ics_last_etag == content_hash:
+                logger.info("No changes in ICS for room", room_id=room.id)
+                room_url = f"{settings.UI_BASE_URL}/{room.name}"
+                events, total_events = self.fetch_service.extract_room_events(
+                    calendar, room.name, room_url
+                )
+                return {
+                    "status": SyncStatus.UNCHANGED,
+                    "hash": content_hash,
+                    "events_found": len(events),
+                    "total_events": total_events,
+                    "events_created": 0,
+                    "events_updated": 0,
+                    "events_deleted": 0,
+                }
+
+            # Extract matching events
+            room_url = f"{settings.UI_BASE_URL}/{room.name}"
+            events, total_events = self.fetch_service.extract_room_events(
+                calendar, room.name, room_url
+            )
+            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": SyncStatus.SUCCESS,
+                "hash": content_hash,
+                "events_found": len(events),
+                "total_events": total_events,
+                **sync_result,
+            }
+
+        except Exception as e:
+            logger.error("Failed to sync ICS for room", room_id=room.id, error=str(e))
+            return {"status": SyncStatus.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
+
+        current_ics_uids = []
+
+        for event_data in events:
+            calendar_event = CalendarEvent(room_id=room_id, **event_data)
+            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,
+        }
+
+
+ics_sync_service = ICSSyncService()

server/reflector/settings.py

@@ -123,23 +123,12 @@ class Settings(BaseSettings):
     # Whereby integration
     WHEREBY_API_URL: str = "https://api.whereby.dev/v1"
     WHEREBY_API_KEY: NonEmptyString | None = None
-
-    # Jibri integration
-    JIBRI_RECORDINGS_PATH: str = "/recordings"
     WHEREBY_WEBHOOK_SECRET: 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
     SQS_POLLING_TIMEOUT_SECONDS: int = 60
 
-    # Jitsi Meet
-    JITSI_DOMAIN: str = "meet.jit.si"
-    JITSI_JWT_SECRET: str | None = None
-    JITSI_WEBHOOK_SECRET: str | None = None
-    JITSI_APP_ID: str = "reflector"
-    JITSI_JWT_ISSUER: str = "reflector"
-    JITSI_JWT_AUDIENCE: str = "jitsi"
-
     # Zulip integration
     ZULIP_REALM: str | None = None
     ZULIP_API_KEY: str | None = None

server/reflector/video_platforms/__init__.py

@@ -1,17 +0,0 @@
-# Video Platform Abstraction Layer
-"""
-This module provides an abstraction layer for different video conferencing platforms.
-It allows seamless switching between providers (Whereby, Daily.co, etc.) without
-changing the core application logic.
-"""
-
-from .base import MeetingData, VideoPlatformClient, VideoPlatformConfig
-from .registry import get_platform_client, register_platform
-
-__all__ = [
-    "VideoPlatformClient",
-    "VideoPlatformConfig",
-    "MeetingData",
-    "get_platform_client",
-    "register_platform",
-]

server/reflector/video_platforms/base.py

@@ -1,82 +0,0 @@
-from abc import ABC, abstractmethod
-from datetime import datetime
-from typing import Any, Dict, Optional
-
-from pydantic import BaseModel
-
-from reflector.db.rooms import Room
-
-
-class MeetingData(BaseModel):
-    """Standardized meeting data returned by all platforms."""
-
-    meeting_id: str
-    room_name: str
-    room_url: str
-    host_room_url: str
-    platform: str
-    extra_data: Dict[str, Any] = {}  # Platform-specific data
-
-
-class VideoPlatformConfig(BaseModel):
-    """Configuration for a video platform."""
-
-    api_key: str
-    webhook_secret: str
-    api_url: Optional[str] = None
-    subdomain: Optional[str] = None
-    s3_bucket: Optional[str] = None
-    s3_region: Optional[str] = None
-    aws_role_arn: Optional[str] = None
-    aws_access_key_id: Optional[str] = None
-    aws_access_key_secret: Optional[str] = None
-
-
-class VideoPlatformClient(ABC):
-    """Abstract base class for video platform integrations."""
-
-    PLATFORM_NAME: str = ""
-
-    def __init__(self, config: VideoPlatformConfig):
-        self.config = config
-
-    @abstractmethod
-    async def create_meeting(
-        self, room_name_prefix: str, end_date: datetime, room: Room
-    ) -> MeetingData:
-        """Create a new meeting room."""
-        pass
-
-    @abstractmethod
-    async def get_room_sessions(self, room_name: str) -> Dict[str, Any]:
-        """Get session information for a room."""
-        pass
-
-    @abstractmethod
-    async def delete_room(self, room_name: str) -> bool:
-        """Delete a room. Returns True if successful."""
-        pass
-
-    @abstractmethod
-    async def upload_logo(self, room_name: str, logo_path: str) -> bool:
-        """Upload a logo to the room. Returns True if successful."""
-        pass
-
-    @abstractmethod
-    def verify_webhook_signature(
-        self, body: bytes, signature: str, timestamp: Optional[str] = None
-    ) -> bool:
-        """Verify webhook signature for security."""
-        pass
-
-    def format_recording_config(self, room: Room) -> Dict[str, Any]:
-        """Format recording configuration for the platform.
-        Can be overridden by specific implementations."""
-        if room.recording_type == "cloud" and self.config.s3_bucket:
-            return {
-                "type": room.recording_type,
-                "bucket": self.config.s3_bucket,
-                "region": self.config.s3_region,
-                "trigger": room.recording_trigger,
-            }
-        return {"type": room.recording_type}

server/reflector/video_platforms/factory.py

@@ -1,54 +0,0 @@
-"""Factory for creating video platform clients based on configuration."""
-
-from typing import TYPE_CHECKING, Literal, Optional, overload
-
-from reflector.db.rooms import VideoPlatform
-from reflector.settings import settings
-
-from .base import VideoPlatformClient, VideoPlatformConfig
-from .registry import get_platform_client
-
-if TYPE_CHECKING:
-    from .jitsi import JitsiClient
-    from .whereby import WherebyClient
-
-
-def get_platform_config(platform: str) -> VideoPlatformConfig:
-    """Get configuration for a specific platform."""
-    if platform == VideoPlatform.WHEREBY:
-        return VideoPlatformConfig(
-            api_key=settings.WHEREBY_API_KEY or "",
-            webhook_secret=settings.WHEREBY_WEBHOOK_SECRET or "",
-            api_url=settings.WHEREBY_API_URL,
-            s3_bucket=settings.RECORDING_STORAGE_AWS_BUCKET_NAME,
-            aws_access_key_id=settings.AWS_WHEREBY_ACCESS_KEY_ID,
-            aws_access_key_secret=settings.AWS_WHEREBY_ACCESS_KEY_SECRET,
-        )
-    elif platform == VideoPlatform.JITSI:
-        return VideoPlatformConfig(
-            api_key="",  # Jitsi uses JWT, no API key
-            webhook_secret=settings.JITSI_WEBHOOK_SECRET or "",
-            api_url=f"https://{settings.JITSI_DOMAIN}",
-        )
-    else:
-        raise ValueError(f"Unknown platform: {platform}")
-
-
-@overload
-def create_platform_client(platform: Literal["jitsi"]) -> "JitsiClient": ...
-
-
-@overload
-def create_platform_client(platform: Literal["whereby"]) -> "WherebyClient": ...
-
-
-def create_platform_client(platform: str) -> VideoPlatformClient:
-    """Create a video platform client instance."""
-    config = get_platform_config(platform)
-    return get_platform_client(platform, config)
-
-
-def get_platform_for_room(room_id: Optional[str] = None) -> str:
-    """Determine which platform to use for a room based on feature flags."""
-    # For now, default to whereby since we don't have feature flags yet
-    return VideoPlatform.WHEREBY

server/reflector/video_platforms/jitsi/__init__.py

@@ -1,4 +0,0 @@
-from .client import JitsiClient, JitsiMeetingData
-from .router import router
-
-__all__ = ["JitsiClient", "JitsiMeetingData", "router"]

server/reflector/video_platforms/jitsi/client.py

@@ -1,111 +0,0 @@
-import hmac
-from datetime import datetime, timezone
-from hashlib import sha256
-from typing import Any, Dict, Optional
-
-import jwt
-
-from reflector.db.rooms import Room, VideoPlatform
-from reflector.settings import settings
-from reflector.utils import generate_uuid4
-
-from ..base import MeetingData, VideoPlatformClient
-
-
-class JitsiMeetingData(MeetingData):
-    @property
-    def user_jwt(self) -> str:
-        return self.extra_data.get("user_jwt", "")
-
-    @property
-    def host_jwt(self) -> str:
-        return self.extra_data.get("host_jwt", "")
-
-    @property
-    def domain(self) -> str:
-        return self.extra_data.get("domain", "")
-
-
-class JitsiClient(VideoPlatformClient):
-    PLATFORM_NAME = VideoPlatform.JITSI
-
-    def _generate_jwt(self, room: str, moderator: bool, exp: datetime) -> str:
-        if not settings.JITSI_JWT_SECRET:
-            raise ValueError("JITSI_JWT_SECRET is required for JWT generation")
-
-        payload = {
-            "aud": settings.JITSI_JWT_AUDIENCE,
-            "iss": settings.JITSI_JWT_ISSUER,
-            "sub": settings.JITSI_DOMAIN,
-            "room": room,
-            "exp": int(exp.timestamp()),
-            "context": {
-                "user": {
-                    "name": "Reflector User",
-                    "moderator": moderator,
-                },
-                "features": {
-                    "recording": True,
-                    "livestreaming": False,
-                },
-            },
-        }
-
-        return jwt.encode(payload, settings.JITSI_JWT_SECRET, algorithm="HS256")
-
-    async def create_meeting(
-        self, room_name_prefix: str, end_date: datetime, room: Room
-    ) -> JitsiMeetingData:
-        jitsi_room = f"reflector-{room.name}-{generate_uuid4()}"
-
-        user_jwt = self._generate_jwt(room=jitsi_room, moderator=False, exp=end_date)
-        host_jwt = self._generate_jwt(room=jitsi_room, moderator=True, exp=end_date)
-
-        room_url = f"https://{settings.JITSI_DOMAIN}/{jitsi_room}?jwt={user_jwt}"
-        host_room_url = f"https://{settings.JITSI_DOMAIN}/{jitsi_room}?jwt={host_jwt}"
-
-        return JitsiMeetingData(
-            meeting_id=generate_uuid4(),
-            room_name=jitsi_room,
-            room_url=room_url,
-            host_room_url=host_room_url,
-            platform=self.PLATFORM_NAME,
-            extra_data={
-                "user_jwt": user_jwt,
-                "host_jwt": host_jwt,
-                "domain": settings.JITSI_DOMAIN,
-            },
-        )
-
-    async def get_room_sessions(self, room_name: str) -> Dict[str, Any]:
-        return {
-            "roomName": room_name,
-            "sessions": [
-                {
-                    "sessionId": generate_uuid4(),
-                    "startTime": datetime.now(tz=timezone.utc).isoformat(),
-                    "participants": [],
-                    "isActive": True,
-                }
-            ],
-        }
-
-    async def delete_room(self, room_name: str) -> bool:
-        return True
-
-    async def upload_logo(self, room_name: str, logo_path: str) -> bool:
-        return True
-
-    def verify_webhook_signature(
-        self, body: bytes, signature: str, timestamp: Optional[str] = None
-    ) -> bool:
-        if not signature or not self.config.webhook_secret:
-            return False
-
-        try:
-            expected = hmac.new(
-                self.config.webhook_secret.encode(), body, sha256
-            ).hexdigest()
-            return hmac.compare_digest(expected, signature)
-        except Exception:
-            return False

server/reflector/video_platforms/jitsi/router.py

@@ -1,165 +0,0 @@
-import hmac
-from datetime import datetime
-from hashlib import sha256
-from typing import Any, Dict
-
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel
-
-from reflector.db.meetings import meetings_controller
-from reflector.settings import settings
-
-try:
-    from reflector.video_platforms import create_platform_client
-except ImportError:
-    # PyJWT not yet installed, will be added in final task
-    def create_platform_client(platform: str):
-        return None
-
-
-router = APIRouter()
-
-
-class JitsiWebhookEvent(BaseModel):
-    event: str
-    room: str
-    timestamp: datetime
-    data: Dict[str, Any] = {}
-
-
-class JibriRecordingEvent(BaseModel):
-    room_name: str
-    recording_file: str
-    recording_status: str
-    timestamp: datetime
-
-
-def verify_jitsi_webhook_signature(body: bytes, signature: str) -> bool:
-    """Verify Jitsi webhook signature using HMAC-SHA256."""
-    if not signature or not settings.JITSI_WEBHOOK_SECRET:
-        return False
-
-    try:
-        client = create_platform_client("jitsi")
-        if client is None:
-            # Fallback verification when platform client not available
-            expected = hmac.new(
-                settings.JITSI_WEBHOOK_SECRET.encode(), body, sha256
-            ).hexdigest()
-            return hmac.compare_digest(expected, signature)
-        return client.verify_webhook_signature(body, signature)
-    except Exception:
-        return False
-
-
-@router.post("/jitsi/events")
-async def jitsi_events_webhook(event: JitsiWebhookEvent, request: Request):
-    """
-    Handle Prosody event-sync webhooks from Jitsi Meet.
-
-    Expected event types:
-    - muc-occupant-joined: participant joined the room
-    - muc-occupant-left: participant left the room
-    - jibri-recording-on: recording started
-    - jibri-recording-off: recording stopped
-    """
-    # Verify webhook signature
-    body = await request.body()
-    signature = request.headers.get("x-jitsi-signature", "")
-
-    if not verify_jitsi_webhook_signature(body, signature):
-        raise HTTPException(status_code=401, detail="Invalid webhook signature")
-
-    # Find meeting by room name
-    meeting = await meetings_controller.get_by_room_name(event.room)
-    if not meeting:
-        raise HTTPException(status_code=404, detail="Meeting not found")
-
-    # Handle participant events
-    if event.event == "muc-occupant-joined":
-        # Store event and update participant count
-        await meetings_controller.participant_joined(
-            meeting.id, {"timestamp": event.timestamp, "data": event.data}
-        )
-        current_count = getattr(meeting, "num_clients", 0)
-        await meetings_controller.update_meeting(
-            meeting.id, num_clients=current_count + 1
-        )
-    elif event.event == "muc-occupant-left":
-        # Store event and update participant count
-        await meetings_controller.participant_left(
-            meeting.id, {"timestamp": event.timestamp, "data": event.data}
-        )
-        current_count = getattr(meeting, "num_clients", 0)
-        await meetings_controller.update_meeting(
-            meeting.id, num_clients=max(0, current_count - 1)
-        )
-    elif event.event == "jibri-recording-on":
-        # Store recording started event
-        await meetings_controller.recording_started(
-            meeting.id, {"timestamp": event.timestamp, "data": event.data}
-        )
-    elif event.event == "jibri-recording-off":
-        # Store recording stopped event
-        await meetings_controller.recording_stopped(
-            meeting.id, {"timestamp": event.timestamp, "data": event.data}
-        )
-
-    return {"status": "ok", "event": event.event, "room": event.room}
-
-
-@router.post("/jibri/recording-complete")
-async def jibri_recording_complete(event: JibriRecordingEvent, request: Request):
-    """
-    Handle Jibri recording completion webhook.
-
-    This endpoint is called by the Jibri finalize script when a recording
-    is completed and uploaded to storage.
-    """
-    # Verify webhook signature
-    body = await request.body()
-    signature = request.headers.get("x-jitsi-signature", "")
-
-    if not verify_jitsi_webhook_signature(body, signature):
-        raise HTTPException(status_code=401, detail="Invalid webhook signature")
-
-    # Find meeting by room name
-    meeting = await meetings_controller.get_by_room_name(event.room_name)
-    if not meeting:
-        raise HTTPException(status_code=404, detail="Meeting not found")
-
-    # Store recording completion event
-    await meetings_controller.add_event(
-        meeting.id,
-        "recording_completed",
-        {
-            "recording_file": event.recording_file,
-            "recording_status": event.recording_status,
-            "timestamp": event.timestamp,
-        },
-    )
-
-    # TODO: Trigger recording processing pipeline
-    # This is where we would:
-    # 1. Download the recording file from Jibri storage
-    # 2. Create a transcript record in the database
-    # 3. Queue the audio processing tasks (chunking, transcription, etc.)
-    # 4. Update meeting status to indicate recording is being processed
-
-    return {
-        "status": "ok",
-        "room_name": event.room_name,
-        "recording_file": event.recording_file,
-        "message": "Recording processing queued",
-    }
-
-
-@router.get("/jitsi/health")
-async def jitsi_health_check():
-    """Simple health check endpoint for Jitsi webhook configuration."""
-    return {
-        "status": "ok",
-        "service": "jitsi-webhooks",
-        "timestamp": datetime.now(tz=timezone.utc).isoformat(),
-        "webhook_secret_configured": bool(settings.JITSI_WEBHOOK_SECRET),
-    }

server/reflector/video_platforms/jitsi/tasks.py

@@ -1,3 +0,0 @@
-"""Jitsi-specific worker tasks."""
-
-# Placeholder for Jitsi recording tasks

server/reflector/video_platforms/registry.py

@@ -1,56 +0,0 @@
-from typing import TYPE_CHECKING, Dict, Literal, Type, overload
-
-from .base import VideoPlatformClient, VideoPlatformConfig
-
-if TYPE_CHECKING:
-    from .jitsi import JitsiClient
-    from .whereby import WherebyClient
-
-# Registry of available video platforms
-_PLATFORMS: Dict[str, Type[VideoPlatformClient]] = {}
-
-
-def register_platform(name: str, client_class: Type[VideoPlatformClient]):
-    """Register a video platform implementation."""
-    _PLATFORMS[name.lower()] = client_class
-
-
-@overload
-def get_platform_client(
-    platform: Literal["jitsi"], config: VideoPlatformConfig
-) -> "JitsiClient": ...
-
-
-@overload
-def get_platform_client(
-    platform: Literal["whereby"], config: VideoPlatformConfig
-) -> "WherebyClient": ...
-
-
-def get_platform_client(
-    platform: str, config: VideoPlatformConfig
-) -> VideoPlatformClient:
-    """Get a video platform client instance."""
-    platform_lower = platform.lower()
-    if platform_lower not in _PLATFORMS:
-        raise ValueError(f"Unknown video platform: {platform}")
-
-    client_class = _PLATFORMS[platform_lower]
-    return client_class(config)
-
-
-def get_available_platforms() -> list[str]:
-    """Get list of available platform names."""
-    return list(_PLATFORMS.keys())
-
-
-# Auto-register built-in platforms
-def _register_builtin_platforms():
-    from .jitsi import JitsiClient
-    from .whereby import WherebyClient
-
-    register_platform("jitsi", JitsiClient)
-    register_platform("whereby", WherebyClient)
-
-
-_register_builtin_platforms()

server/reflector/video_platforms/whereby/__init__.py

@@ -1,6 +0,0 @@
-"""Whereby video platform integration."""
-
-from .client import WherebyClient
-from .router import router
-
-__all__ = ["WherebyClient", "router"]

server/reflector/video_platforms/whereby/client.py

@@ -1,113 +0,0 @@
-import hmac
-from datetime import datetime
-from hashlib import sha256
-from typing import Any, Dict, Optional
-
-import httpx
-
-from reflector.db.rooms import Room, VideoPlatform
-from reflector.settings import settings
-
-from ..base import MeetingData, VideoPlatformClient
-
-
-class WherebyClient(VideoPlatformClient):
-    PLATFORM_NAME = VideoPlatform.WHEREBY
-
-    def __init__(self, config):
-        super().__init__(config)
-        self.headers = {
-            "Content-Type": "application/json; charset=utf-8",
-            "Authorization": f"Bearer {self.config.api_key}",
-        }
-        self.timeout = 10
-
-    async def create_meeting(
-        self, room_name_prefix: str, end_date: datetime, room: Room
-    ) -> MeetingData:
-        data = {
-            "isLocked": room.is_locked,
-            "roomNamePrefix": room_name_prefix,
-            "roomNamePattern": "uuid",
-            "roomMode": room.room_mode,
-            "endDate": end_date.isoformat(),
-            "recording": {
-                "type": room.recording_type,
-                "destination": {
-                    "provider": "s3",
-                    "bucket": settings.RECORDING_STORAGE_AWS_BUCKET_NAME,
-                    "accessKeyId": self.config.aws_access_key_id,
-                    "accessKeySecret": self.config.aws_access_key_secret,
-                    "fileFormat": "mp4",
-                },
-                "startTrigger": room.recording_trigger,
-            },
-            "fields": ["hostRoomUrl"],
-        }
-
-        async with httpx.AsyncClient() as client:
-            response = await client.post(
-                f"{self.config.api_url}/meetings",
-                headers=self.headers,
-                json=data,
-                timeout=self.timeout,
-            )
-            response.raise_for_status()
-            meeting_data = response.json()
-
-        return MeetingData(
-            meeting_id=meeting_data["meetingId"],
-            room_name=meeting_data["roomName"],
-            room_url=meeting_data["roomUrl"],
-            host_room_url=meeting_data["hostRoomUrl"],
-            platform=self.PLATFORM_NAME,
-            extra_data={
-                "startDate": meeting_data["startDate"],
-                "endDate": meeting_data["endDate"],
-                "recording": meeting_data.get("recording", {}),
-            },
-        )
-
-    async def get_room_sessions(self, room_name: str) -> Dict[str, Any]:
-        async with httpx.AsyncClient() as client:
-            response = await client.get(
-                f"{self.config.api_url}/insights/room-sessions?roomName={room_name}",
-                headers=self.headers,
-                timeout=self.timeout,
-            )
-            response.raise_for_status()
-            return response.json()
-
-    async def delete_room(self, room_name: str) -> bool:
-        return True
-
-    async def upload_logo(self, room_name: str, logo_path: str) -> bool:
-        try:
-            async with httpx.AsyncClient() as client:
-                with open(logo_path, "rb") as f:
-                    response = await client.put(
-                        f"{self.config.api_url}/rooms{room_name}/theme/logo",
-                        headers={
-                            "Authorization": f"Bearer {self.config.api_key}",
-                        },
-                        timeout=self.timeout,
-                        files={"image": f},
-                    )
-                    response.raise_for_status()
-            return True
-        except Exception:
-            return False
-
-    def verify_webhook_signature(
-        self, body: bytes, signature: str, timestamp: Optional[str] = None
-    ) -> bool:
-        if not signature or not self.config.webhook_secret:
-            return False
-
-        try:
-            expected = hmac.new(
-                self.config.webhook_secret.encode(), body, sha256
-            ).hexdigest()
-            return hmac.compare_digest(expected, signature)
-        except Exception:
-            return False

server/reflector/video_platforms/whereby/tasks.py

@@ -1,4 +0,0 @@
-"""Whereby-specific worker tasks."""
-
-# Placeholder for Whereby-specific background tasks
-# This can be extended with Whereby-specific processing tasks in the future

server/reflector/views/jibri_webhook.py

@@ -1,126 +0,0 @@
-from pathlib import Path
-from typing import Annotated, Any, Dict, Optional
-
-import structlog
-from fastapi import APIRouter, Depends, HTTPException
-from pydantic import BaseModel
-
-import reflector.auth as auth
-from reflector.db.transcripts import SourceKind, transcripts_controller
-from reflector.jibri_events import JitsiEventParser
-from reflector.pipelines.main_file_pipeline import task_pipeline_file_process
-from reflector.settings import settings
-
-logger = structlog.get_logger(__name__)
-
-router = APIRouter(prefix="/api/v1/jibri", tags=["jibri"])
-
-
-class RecordingReadyRequest(BaseModel):
-    session_id: str
-    path: str  # Relative path from recordings directory
-    meeting_url: str
-
-
-@router.post("/recording-ready")
-async def handle_recording_ready(
-    request: RecordingReadyRequest,
-    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
-) -> Dict[str, Any]:
-    user_id = user["sub"] if user else None
-
-    recordings_base = Path(settings.JIBRI_RECORDINGS_PATH or "/recordings")
-    recording_path = recordings_base / request.path
-
-    if not recording_path.exists():
-        raise HTTPException(
-            status_code=404, detail=f"Recording path not found: {request.path}"
-        )
-
-    recording_file = recording_path / "recording.mp4"
-    events_file = recording_path / "events.jsonl"
-
-    if not recording_file.exists():
-        raise HTTPException(status_code=404, detail="Recording file not found")
-
-    # Parse events if available
-    metadata = {}
-    participant_count = 0
-
-    if events_file.exists():
-        parser = JitsiEventParser()
-        metadata = parser.parse_events_file(str(recording_path))
-        participant_count = len(metadata.get("participants", []))
-        logger.info(
-            "Parsed Jibri events",
-            session_id=request.session_id,
-            event_count=metadata.get("event_count", 0),
-            participant_count=participant_count,
-        )
-    else:
-        logger.warning("No events file found", session_id=request.session_id)
-        metadata = {
-            "room": {"meeting_url": request.meeting_url, "name": request.session_id},
-            "participants": [],
-            "speaker_stats": {},
-            "event_count": 0,
-        }
-
-    # Create transcript using controller
-    title = f"Meeting: {metadata.get('room', {}).get('name', request.session_id)}"
-    transcript = await transcripts_controller.add(
-        name=title,
-        source_kind=SourceKind.FILE,
-        source_language="en",
-        target_language="en",
-        user_id=user_id,
-    )
-
-    # Store Jitsi data in appropriate fields
-    update_data = {}
-
-    # Store participants if available
-    if metadata.get("participants"):
-        update_data["participants"] = metadata["participants"]
-
-    # Store events data (room info, speaker stats, etc.)
-    update_data["events"] = {
-        "jitsi_metadata": metadata,
-        "session_id": request.session_id,
-        "recording_path": str(recording_path),
-        "meeting_url": request.meeting_url,
-    }
-
-    if update_data:
-        await transcripts_controller.update(transcript, update_data)
-
-    # Copy recording file to transcript data path
-    # The pipeline expects the file to be in the transcript's data path
-    upload_file = transcript.data_path / "upload.mp4"
-    upload_file.parent.mkdir(parents=True, exist_ok=True)
-
-    # Create symlink or copy the file
-    import shutil
-
-    shutil.copy2(recording_file, upload_file)
-
-    # Update status to uploaded
-    await transcripts_controller.update(transcript, {"status": "uploaded"})
-
-    # Trigger processing pipeline
-    task_pipeline_file_process.delay(transcript_id=transcript.id)
-
-    logger.info(
-        "Jibri recording ready for processing",
-        transcript_id=transcript.id,
-        session_id=request.session_id,
-        participant_count=participant_count,
-    )
-
-    return {
-        "status": "accepted",
-        "transcript_id": transcript.id,
-        "session_id": request.session_id,
-        "events_found": events_file.exists(),
-        "participant_count": participant_count,
-    }

server/reflector/views/meetings.py

@@ -10,6 +10,7 @@ from reflector.db.meetings import (
     meeting_consent_controller,
     meetings_controller,
 )
+from reflector.db.rooms import rooms_controller
 
 router = APIRouter()
 
@@ -41,3 +42,34 @@ async def meeting_audio_consent(
     updated_consent = await meeting_consent_controller.upsert(consent)
 
     return {"status": "success", "consent_id": updated_consent.id}
+
+
+@router.patch("/meetings/{meeting_id}/deactivate")
+async def meeting_deactivate(
+    meeting_id: str,
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user)],
+):
+    user_id = user["sub"] if user else None
+    if not user_id:
+        raise HTTPException(status_code=401, detail="Authentication required")
+
+    meeting = await meetings_controller.get_by_id(meeting_id)
+    if not meeting:
+        raise HTTPException(status_code=404, detail="Meeting not found")
+
+    if not meeting.is_active:
+        return {"status": "success", "meeting_id": meeting_id}
+
+    # Only room owner or meeting creator can deactivate
+    room = await rooms_controller.get_by_id(meeting.room_id)
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    if user_id != room.user_id and user_id != meeting.user_id:
+        raise HTTPException(
+            status_code=403, detail="Only the room owner can deactivate meetings"
+        )
+
+    await meetings_controller.update_meeting(meeting_id, is_active=False)
+
+    return {"status": "success", "meeting_id": meeting_id}

server/reflector/views/rooms.py

@@ -1,35 +1,27 @@
 import logging
-import sqlite3
 from datetime import datetime, timedelta, timezone
-from typing import Annotated, Literal, Optional
+from enum import Enum
+from typing import Annotated, Any, Literal, Optional
 
-import asyncpg.exceptions
 from fastapi import APIRouter, Depends, HTTPException
 from fastapi_pagination import Page
 from fastapi_pagination.ext.databases import apaginate
 from pydantic import BaseModel
+from redis.exceptions import LockError
 
 import reflector.auth as auth
 from reflector.db import get_database
+from reflector.db.calendar_events import calendar_events_controller
 from reflector.db.meetings import meetings_controller
-from reflector.db.rooms import VideoPlatform, rooms_controller
+from reflector.db.rooms import rooms_controller
+from reflector.redis_cache import RedisAsyncLock
+from reflector.services.ics_sync import ics_sync_service
 from reflector.settings import settings
-from reflector.video_platforms.factory import (
-    create_platform_client,
-)
+from reflector.whereby import create_meeting, upload_logo
 from reflector.worker.webhook import test_webhook
 
 logger = logging.getLogger(__name__)
 
-router = APIRouter()
-
-
-def parse_datetime_with_timezone(iso_string: str) -> datetime:
-    dt = datetime.fromisoformat(iso_string)
-    if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=timezone.utc)
-    return dt
-
 
 class Room(BaseModel):
     id: str
@@ -44,7 +36,11 @@ class Room(BaseModel):
     recording_type: str
     recording_trigger: str
     is_shared: bool
-    platform: VideoPlatform = VideoPlatform.WHEREBY
+    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 RoomDetails(Room):
@@ -56,10 +52,22 @@ class Meeting(BaseModel):
     id: str
     room_name: str
     room_url: str
+    # TODO it's not always present, | None
     host_room_url: str
     start_date: datetime
     end_date: datetime
+    user_id: str | None = None
+    room_id: str | None = None
+    is_locked: bool = False
+    room_mode: Literal["normal", "group"] = "normal"
     recording_type: Literal["none", "local", "cloud"] = "cloud"
+    recording_trigger: Literal[
+        "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
 
 
 class CreateRoom(BaseModel):
@@ -74,22 +82,30 @@ class CreateRoom(BaseModel):
     is_shared: bool
     webhook_url: str
     webhook_secret: str
-    platform: VideoPlatform
+    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
-    webhook_url: str
-    webhook_secret: str
-    platform: VideoPlatform
+    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
+    webhook_url: Optional[str] = None
+    webhook_secret: Optional[str] = None
+    ics_url: Optional[str] = None
+    ics_fetch_interval: Optional[int] = None
+    ics_enabled: Optional[bool] = None
+
+
+class CreateRoomMeeting(BaseModel):
+    allow_duplicated: Optional[bool] = False
 
 
 class DeletionStatus(BaseModel):
@@ -104,6 +120,59 @@ class WebhookTestResult(BaseModel):
     response_preview: str | None = None
 
 
+class ICSStatus(BaseModel):
+    status: Literal["enabled", "disabled"]
+    last_sync: Optional[datetime] = None
+    next_sync: Optional[datetime] = None
+    last_etag: Optional[str] = None
+    events_count: int = 0
+
+
+class SyncStatus(str, Enum):
+    success = "success"
+    unchanged = "unchanged"
+    error = "error"
+    skipped = "skipped"
+
+
+class ICSSyncResult(BaseModel):
+    status: SyncStatus
+    hash: Optional[str] = None
+    events_found: int = 0
+    total_events: int = 0
+    events_created: int = 0
+    events_updated: int = 0
+    events_deleted: int = 0
+    error: Optional[str] = None
+    reason: Optional[str] = None
+
+
+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 = 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
+
+
 @router.get("/rooms", response_model=Page[RoomDetails])
 async def rooms_list(
     user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
@@ -133,6 +202,30 @@ async def rooms_get(
     return room
 
 
+@router.get("/rooms/name/{room_name}", response_model=RoomDetails)
+async def rooms_get_by_name(
+    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")
+
+    # Convert to RoomDetails format (add webhook fields if user is owner)
+    room_dict = room.__dict__.copy()
+    if user_id == room.user_id:
+        # User is owner, include webhook details if available
+        room_dict["webhook_url"] = getattr(room, "webhook_url", None)
+        room_dict["webhook_secret"] = getattr(room, "webhook_secret", None)
+    else:
+        # Non-owner, hide webhook details
+        room_dict["webhook_url"] = None
+        room_dict["webhook_secret"] = None
+
+    return RoomDetails(**room_dict)
+
+
 @router.post("/rooms", response_model=Room)
 async def rooms_create(
     room: CreateRoom,
@@ -153,7 +246,9 @@ async def rooms_create(
         is_shared=room.is_shared,
         webhook_url=room.webhook_url,
         webhook_secret=room.webhook_secret,
-        platform=room.platform,
+        ics_url=room.ics_url,
+        ics_fetch_interval=room.ics_fetch_interval,
+        ics_enabled=room.ics_enabled,
     )
 
 
@@ -188,6 +283,7 @@ async def rooms_delete(
 @router.post("/rooms/{room_name}/meeting", response_model=Meeting)
 async def rooms_create_meeting(
     room_name: str,
+    info: CreateRoomMeeting,
     user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ):
     user_id = user["sub"] if user else None
@@ -195,58 +291,43 @@ async def rooms_create_meeting(
     if not room:
         raise HTTPException(status_code=404, detail="Room not found")
 
+    try:
+        async with RedisAsyncLock(
+            f"create_meeting:{room_name}",
+            timeout=30,
+            extend_interval=10,
+            blocking_timeout=5.0,
+        ) as lock:
             current_time = datetime.now(timezone.utc)
-    meeting = await meetings_controller.get_active(room=room, current_time=current_time)
+
+            meeting = None
+            if not info.allow_duplicated:
+                meeting = await meetings_controller.get_active(
+                    room=room, current_time=current_time
+                )
 
             if meeting is None:
                 end_date = current_time + timedelta(hours=8)
 
-        platform = room.platform
-        client = create_platform_client(platform)
+                whereby_meeting = await create_meeting("", end_date=end_date, room=room)
 
-        platform_meeting = await client.create_meeting("", end_date=end_date, room=room)
-        await client.upload_logo(platform_meeting.room_name, "./images/logo.png")
+                await upload_logo(whereby_meeting["roomName"], "./images/logo.png")
 
-        meeting_data = {
-            "meeting_id": platform_meeting.meeting_id,
-            "room_name": platform_meeting.room_name,
-            "room_url": platform_meeting.room_url,
-            "host_room_url": platform_meeting.host_room_url,
-            "start_date": current_time,
-            "end_date": end_date,
-        }
-        try:
                 meeting = await meetings_controller.create(
-                id=meeting_data["meeting_id"],
-                room_name=meeting_data["room_name"],
-                room_url=meeting_data["room_url"],
-                host_room_url=meeting_data["host_room_url"],
-                start_date=meeting_data["start_date"],
-                end_date=meeting_data["end_date"],
-                user_id=user_id,
+                    id=whereby_meeting["meetingId"],
+                    room_name=whereby_meeting["roomName"],
+                    room_url=whereby_meeting["roomUrl"],
+                    host_room_url=whereby_meeting["hostRoomUrl"],
+                    start_date=parse_datetime_with_timezone(
+                        whereby_meeting["startDate"]
+                    ),
+                    end_date=parse_datetime_with_timezone(whereby_meeting["endDate"]),
                     room=room,
                 )
-        except (asyncpg.exceptions.UniqueViolationError, sqlite3.IntegrityError):
-            logger.info(
-                "Race condition detected for room %s - fetching existing meeting",
-                room.name,
-            )
-            logger.warning(
-                "Platform meeting %s was created but not used (resource leak) for room %s",
-                meeting_data["meeting_id"],
-                room.name,
-            )
-            meeting = await meetings_controller.get_active(
-                room=room, current_time=current_time
-            )
-            if meeting is None:
-                logger.error(
-                    "Meeting disappeared after race condition for room %s",
-                    room.name,
-                    exc_info=True,
-                )
+    except LockError:
+        logger.warning("Failed to acquire lock for room %s within timeout", room_name)
         raise HTTPException(
-                    status_code=503, detail="Unable to join meeting - please try again"
+            status_code=503, detail="Meeting creation in progress, please try again"
         )
 
     if user_id != room.user_id:
@@ -260,6 +341,7 @@ async def rooms_test_webhook(
     room_id: str,
     user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ):
+    """Test webhook configuration by sending a sample payload."""
     user_id = user["sub"] if user else None
 
     room = await rooms_controller.get_by_id(room_id)
@@ -273,3 +355,202 @@ async def rooms_test_webhook(
 
     result = await test_webhook(room_id)
     return WebhookTestResult(**result)
+
+
+@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")
+
+    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)
+
+    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),
+    )
+
+
+@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")
+
+    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 = 120,
+):
+    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")
+
+    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)],
+):
+    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.get("/rooms/{room_name}/meetings/{meeting_id}", response_model=Meeting)
+async def rooms_get_meeting(
+    room_name: str,
+    meeting_id: str,
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
+):
+    """Get a single meeting by ID within a specific room."""
+    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 user_id != room.user_id and not room.is_shared:
+        meeting.host_room_url = ""
+
+    return meeting
+
+
+@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)],
+):
+    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/whereby.py

@@ -68,8 +68,7 @@ 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"]}
+        await meetings_controller.update_meeting(meeting.id, **update_data)
 
     return {"status": "ok"}

server/reflector/worker/app.py

@@ -20,7 +20,7 @@ else:
             "reflector.worker.healthcheck",
             "reflector.worker.process",
             "reflector.worker.cleanup",
-            "reflector.worker.jitsi_events",
+            "reflector.worker.ics_sync",
         ]
     )
 
@@ -34,14 +34,18 @@ else:
             "task": "reflector.worker.process.process_meetings",
             "schedule": float(settings.SQS_POLLING_TIMEOUT_SECONDS),
         },
-        "process_jitsi_events": {
-            "task": "reflector.worker.jitsi_events.process_jitsi_events",
-            "schedule": 5.0,  # Process every 5 seconds
-        },
         "reprocess_failed_recordings": {
             "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
+        },
+        "create_upcoming_meetings": {
+            "task": "reflector.worker.ics_sync.create_upcoming_meetings",
+            "schedule": 30.0,  # Run every 30 seconds to create upcoming meetings
+        },
     }
 
     if settings.PUBLIC_MODE:

server/reflector/worker/cleanup.py

@@ -5,7 +5,6 @@ Deletes old anonymous transcripts and their associated meetings/recordings.
 Transcripts are the main entry point - any associated data is also removed.
 """
 
-import asyncio
 from datetime import datetime, timedelta, timezone
 from typing import TypedDict
 
@@ -152,5 +151,5 @@ async def cleanup_old_public_data(
     retry_kwargs={"max_retries": 3, "countdown": 300},
 )
 @asynctask
-def cleanup_old_public_data_task(days: int | None = None):
-    asyncio.run(cleanup_old_public_data(days=days))
+async def cleanup_old_public_data_task(days: int | None = None):
+    await cleanup_old_public_data(days=days)

server/reflector/worker/ics_sync.py

@@ -0,0 +1,175 @@
+from datetime import datetime, timedelta, timezone
+
+import structlog
+from celery import shared_task
+from celery.utils.log import get_task_logger
+
+from reflector.asynctask import asynctask
+from reflector.db.calendar_events import calendar_events_controller
+from reflector.db.meetings import meetings_controller
+from reflector.db.rooms import rooms_controller
+from reflector.redis_cache import RedisAsyncLock
+from reflector.services.ics_sync import SyncStatus, ics_sync_service
+from reflector.whereby import create_meeting, upload_logo
+
+logger = structlog.wrap_logger(get_task_logger(__name__))
+
+
+@shared_task
+@asynctask
+async def sync_room_ics(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"] == SyncStatus.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"] == SyncStatus.UNCHANGED:
+            logger.debug("ICS content unchanged", room_id=room_id)
+        elif result["status"] == SyncStatus.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
+@asynctask
+async def sync_all_ics_calendars():
+    try:
+        logger.info("Starting sync for all ICS-enabled rooms")
+
+        ics_enabled_rooms = await rooms_controller.get_ics_enabled()
+        logger.info(f"Found {len(ics_enabled_rooms)} rooms with ICS enabled")
+
+        for room in ics_enabled_rooms:
+            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
+
+
+MEETING_DEFAULT_DURATION = timedelta(hours=1)
+
+
+async def create_upcoming_meetings_for_event(event, create_window, room_id, room):
+    if event.start_time <= create_window:
+        return
+    existing_meeting = await meetings_controller.get_by_calendar_event(event.id)
+
+    if existing_meeting:
+        return
+
+    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 + MEETING_DEFAULT_DURATION)
+
+        whereby_meeting = await create_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"]),
+            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),
+        )
+
+
+@shared_task
+@asynctask
+async def create_upcoming_meetings():
+    async with RedisAsyncLock("create_upcoming_meetings", skip_if_locked=True) as lock:
+        if not lock.acquired:
+            logger.warning(
+                "Another worker is already creating upcoming meetings, skipping"
+            )
+            return
+
+        try:
+            logger.info("Starting creation of upcoming meetings")
+
+            ics_enabled_rooms = await rooms_controller.get_ics_enabled()
+            now = datetime.now(timezone.utc)
+            create_window = now - timedelta(minutes=6)
+
+            for room in ics_enabled_rooms:
+                events = await calendar_events_controller.get_upcoming(
+                    room.id,
+                    minutes_ahead=7,
+                )
+
+                for event in events:
+                    await create_upcoming_meetings_for_event(
+                        event, create_window, room.id, room
+                    )
+            logger.info("Completed pre-creation check for upcoming meetings")
+
+        except Exception as e:
+            logger.error("Error in create_upcoming_meetings", error=str(e))

server/reflector/worker/jitsi_events.py

@@ -1,281 +0,0 @@
-"""
-Celery tasks for consuming Jitsi events from Redis queues.
-"""
-
-import json
-from datetime import datetime
-from typing import Any, Dict
-
-import redis
-import structlog
-from sqlalchemy.orm import Session
-
-from reflector.database import get_db_sync
-from reflector.models import Meeting, Transcript
-from reflector.settings import settings
-from reflector.worker.app import app
-
-logger = structlog.get_logger(__name__)
-
-
-class JitsiEventProcessor:
-    """Process Jitsi events from Redis queues."""
-
-    def __init__(self):
-        self.redis_client = redis.Redis(
-            host=settings.REDIS_HOST or "redis",
-            port=settings.REDIS_PORT or 6379,
-            decode_responses=True,
-        )
-        self.participants = {}  # room_name -> {jid: participant_info}
-        self.speaker_stats = {}  # room_name -> {jid: stats}
-
-    def process_participant_joined(self, data: Dict[str, Any], db: Session):
-        """Track participant joining a room."""
-        room_name = data["room_name"]
-        participant = {
-            "jid": data["participant_jid"],
-            "nick": data["participant_nick"],
-            "id": data["participant_id"],
-            "is_moderator": data.get("is_moderator", False),
-            "joined_at": datetime.now(),
-        }
-
-        if room_name not in self.participants:
-            self.participants[room_name] = {}
-
-        self.participants[room_name][participant["jid"]] = participant
-
-        logger.info(
-            "Participant joined",
-            room=room_name,
-            participant=participant["nick"],
-            total_participants=len(self.participants[room_name]),
-        )
-
-        # Update meeting in database if exists
-        meeting = (
-            db.query(Meeting)
-            .filter(
-                Meeting.room_name == room_name,
-                Meeting.status.in_(["active", "pending"]),
-            )
-            .first()
-        )
-
-        if meeting:
-            # Store participant info in meeting metadata
-            metadata = meeting.metadata or {}
-            if "participants" not in metadata:
-                metadata["participants"] = []
-
-            metadata["participants"].append(
-                {
-                    "id": participant["id"],
-                    "name": participant["nick"],
-                    "joined_at": participant["joined_at"].isoformat(),
-                    "is_moderator": participant["is_moderator"],
-                }
-            )
-
-            meeting.metadata = metadata
-            db.commit()
-
-    def process_participant_left(self, data: Dict[str, Any], db: Session):
-        """Track participant leaving a room."""
-        room_name = data["room_name"]
-        participant_jid = data["participant_jid"]
-
-        if room_name in self.participants:
-            if participant_jid in self.participants[room_name]:
-                participant = self.participants[room_name][participant_jid]
-                participant["left_at"] = datetime.now()
-
-                logger.info(
-                    "Participant left",
-                    room=room_name,
-                    participant=participant["nick"],
-                    duration=(
-                        participant["left_at"] - participant["joined_at"]
-                    ).total_seconds(),
-                )
-
-                # Update meeting in database
-                meeting = (
-                    db.query(Meeting)
-                    .filter(
-                        Meeting.room_name == room_name,
-                        Meeting.status.in_(["active", "pending"]),
-                    )
-                    .first()
-                )
-
-                if meeting and meeting.metadata and "participants" in meeting.metadata:
-                    for p in meeting.metadata["participants"]:
-                        if p["id"] == participant["id"]:
-                            p["left_at"] = participant["left_at"].isoformat()
-                            break
-                    db.commit()
-
-    def process_speaker_stats(self, data: Dict[str, Any], db: Session):
-        """Update speaker statistics."""
-        room_name = data["room_jid"].split("@")[0]
-        self.speaker_stats[room_name] = data["stats"]
-
-        logger.debug(
-            "Speaker stats updated", room=room_name, speakers=len(data["stats"])
-        )
-
-    def process_recording_completed(self, data: Dict[str, Any], db: Session):
-        """Process completed recording with all metadata."""
-        room_name = data["room_name"]
-        meeting_url = data["meeting_url"]
-        recording_path = data["recording_path"]
-        recording_file = data["recording_file"]
-
-        logger.info(
-            "Recording completed", room=room_name, url=meeting_url, path=recording_path
-        )
-
-        # Get participant data for this room
-        participants = self.participants.get(room_name, {})
-        speaker_stats = self.speaker_stats.get(room_name, {})
-
-        # Create transcript record with full metadata
-        transcript = Transcript(
-            title=f"Recording: {room_name}",
-            source_url=meeting_url,
-            metadata={
-                "jitsi": {
-                    "room_name": room_name,
-                    "meeting_url": meeting_url,
-                    "recording_path": recording_path,
-                    "participants": [
-                        {
-                            "id": p["id"],
-                            "name": p["nick"],
-                            "joined_at": p["joined_at"].isoformat(),
-                            "left_at": p.get("left_at", datetime.now()).isoformat(),
-                            "is_moderator": p["is_moderator"],
-                            "speaking_time": speaker_stats.get(p["jid"], {}).get(
-                                "total_time", 0
-                            ),
-                        }
-                        for p in participants.values()
-                    ],
-                    "speaker_stats": speaker_stats,
-                }
-            },
-            status="pending",
-        )
-        db.add(transcript)
-        db.commit()
-
-        # Trigger processing pipeline
-        from reflector.pipelines.main_transcript_pipeline import TranscriptMainPipeline
-
-        pipeline = TranscriptMainPipeline()
-        pipeline.create(transcript.id, recording_file)
-
-        # Clean up room data
-        self.participants.pop(room_name, None)
-        self.speaker_stats.pop(room_name, None)
-
-        logger.info(
-            "Transcript created",
-            transcript_id=transcript.id,
-            participants=len(participants),
-            has_speaker_stats=bool(speaker_stats),
-        )
-
-
-processor = JitsiEventProcessor()
-
-
-@app.task(name="reflector.worker.jitsi_events.process_jitsi_events")
-def process_jitsi_events():
-    """
-    Process Jitsi events from Redis queue.
-    This should be called periodically by Celery Beat.
-    """
-    db = next(get_db_sync())
-    processed = 0
-
-    try:
-        # Process up to 100 events per run
-        for _ in range(100):
-            # Pop event from queue (blocking with 1 second timeout)
-            event_data = processor.redis_client.brpop(
-                ["jitsi:events:queue", "jitsi:recordings:queue"], timeout=1
-            )
-
-            if not event_data:
-                break
-
-            queue_name, event_json = event_data
-            event = json.loads(event_json)
-
-            event_type = event["type"]
-            data = event["data"]
-
-            logger.debug(f"Processing event: {event_type}")
-
-            # Route to appropriate processor
-            if event_type == "participant_joined":
-                processor.process_participant_joined(data, db)
-            elif event_type == "participant_left":
-                processor.process_participant_left(data, db)
-            elif event_type == "speaker_stats_update":
-                processor.process_speaker_stats(data, db)
-            elif event_type == "recording_completed":
-                processor.process_recording_completed(data, db)
-            else:
-                logger.warning(f"Unknown event type: {event_type}")
-
-            processed += 1
-
-        if processed > 0:
-            logger.info(f"Processed {processed} Jitsi events")
-
-    except Exception as e:
-        logger.error(f"Error processing Jitsi events: {e}")
-        raise
-    finally:
-        db.close()
-
-    return processed
-
-
-@app.task(name="reflector.worker.jitsi_events.consume_jitsi_stream")
-def consume_jitsi_stream():
-    """
-    Alternative: Use Redis Streams for more reliable event processing.
-    Redis Streams provide better guarantees and consumer groups.
-    """
-    db = next(get_db_sync())
-
-    try:
-        # Read from stream with consumer group
-        events = processor.redis_client.xreadgroup(
-            "reflector-consumers",
-            "worker-1",
-            {"jitsi:events": ">"},
-            count=10,
-            block=1000,
-        )
-
-        for stream_name, messages in events:
-            for message_id, data in messages:
-                event = json.loads(data[b"event"])
-                # Process event...
-
-                # Acknowledge message
-                processor.redis_client.xack(
-                    stream_name, "reflector-consumers", message_id
-                )
-
-    except Exception as e:
-        logger.error(f"Error consuming stream: {e}")
-        raise
-    finally:
-        db.close()

server/reflector/worker/process.py

@@ -9,6 +9,7 @@ import structlog
 from celery import shared_task
 from celery.utils.log import get_task_logger
 from pydantic import ValidationError
+from redis.exceptions import LockError
 
 from reflector.db.meetings import meetings_controller
 from reflector.db.recordings import Recording, recordings_controller
@@ -16,8 +17,9 @@ from reflector.db.rooms import rooms_controller
 from reflector.db.transcripts import SourceKind, transcripts_controller
 from reflector.pipelines.main_file_pipeline import task_pipeline_file_process
 from reflector.pipelines.main_live_pipeline import asynctask
+from reflector.redis_cache import get_redis_client
 from reflector.settings import settings
-from reflector.video_platforms.factory import create_platform_client
+from reflector.whereby import get_room_sessions
 
 logger = structlog.wrap_logger(get_task_logger(__name__))
 
@@ -147,31 +149,94 @@ 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.
+
+    Deactivation logic:
+    - Active sessions: Keep meeting active regardless of scheduled time
+    - No active sessions:
+      * Calendar meetings:
+        - If previously used (had sessions): Deactivate immediately
+        - If never used: Keep active until scheduled end time, then deactivate
+      * On-the-fly meetings: Deactivate immediately (created when someone joins,
+        so no sessions means everyone left)
+
+    Uses distributed locking to prevent race conditions when multiple workers
+    process the same meeting simultaneously.
+    """
     logger.info("Processing meetings")
     meetings = await meetings_controller.get_all_active()
+    current_time = datetime.now(timezone.utc)
+    redis_client = get_redis_client()
+    processed_count = 0
+    skipped_count = 0
+
     for meeting in meetings:
-        is_active = False
+        logger_ = logger.bind(meeting_id=meeting.id, room_name=meeting.room_name)
+        lock_key = f"meeting_process_lock:{meeting.id}"
+        lock = redis_client.lock(lock_key, timeout=120)
+
+        try:
+            if not lock.acquire(blocking=False):
+                logger_.debug("Meeting is being processed by another worker, skipping")
+                skipped_count += 1
+                continue
+
+            # Process the meeting
+            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):
-            # Get room sessions using platform client
-            platform = getattr(meeting, "platform", "whereby")
-            client = create_platform_client(platform)
-            if client:
-                response = await client.get_room_sessions(meeting.room_name)
+
+            # This API call could be slow, extend lock if needed
+            response = await get_room_sessions(meeting.room_name)
+
+            try:
+                # Extend lock after slow operation to ensure we still hold it
+                lock.extend(120, replace_ttl=True)
+            except LockError:
+                logger_.warning("Lost lock for meeting, skipping")
+                continue
+
             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
             )
-            else:
-                # Fallback: assume meeting is still active if we can't check
-                is_active = True
-        if not is_active:
-            await meetings_controller.update_meeting(meeting.id, is_active=False)
-            logger.info("Meeting %s is deactivated", meeting.id)
+            has_had_sessions = bool(room_sessions)
 
-    logger.info("Processed meetings")
+            if has_active_sessions:
+                logger_.debug("Meeting still has active sessions, keep it")
+            elif has_had_sessions:
+                should_deactivate = True
+                logger_.info("Meeting ended - all participants left")
+            elif current_time > end_date:
+                should_deactivate = True
+                logger_.info(
+                    "Meeting deactivated - scheduled time ended with no participants",
+                    meeting.id,
+                )
+            else:
+                logger_.debug("Meeting not yet started, keep it")
+
+            if should_deactivate:
+                await meetings_controller.update_meeting(meeting.id, is_active=False)
+                logger_.info("Meeting is deactivated")
+
+            processed_count += 1
+
+        except Exception as e:
+            logger_.error(f"Error processing meeting", exc_info=True)
+        finally:
+            try:
+                lock.release()
+            except LockError:
+                pass  # Lock already released or expired
+
+    logger.info(
+        f"Processed meetings finished",
+        processed_count=processed_count,
+        skipped_count=skipped_count,
+    )
 
 
 @shared_task

server/run_jibri_tests.py

@@ -1,49 +0,0 @@
-#!/usr/bin/env python
-"""Simple test runner for Jibri tests that doesn't require Docker."""
-
-import os
-import sys
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-# Import test functions after path is set
-exec(open("tests/test_jibri_events.py").read(), globals())
-
-
-def run_tests():
-    tests = [
-        ("test_parse_room_created_event", test_parse_room_created_event),
-        ("test_parse_participant_joined_event", test_parse_participant_joined_event),
-        (
-            "test_parse_unknown_event_returns_none",
-            test_parse_unknown_event_returns_none,
-        ),
-        (
-            "test_parse_events_file_with_complete_session",
-            test_parse_events_file_with_complete_session,
-        ),
-        ("test_parse_events_file_missing_file", test_parse_events_file_missing_file),
-    ]
-
-    passed = 0
-    failed = 0
-
-    for name, test_func in tests:
-        try:
-            test_func()
-            print(f"✓ {name}")
-            passed += 1
-        except AssertionError as e:
-            print(f"✗ {name}: {e}")
-            failed += 1
-        except Exception as e:
-            print(f"✗ {name}: Unexpected error: {e}")
-            failed += 1
-
-    print(f"\nResults: {passed} passed, {failed} failed")
-    return failed == 0
-
-
-if __name__ == "__main__":
-    success = run_tests()
-    sys.exit(0 if success else 1)

server/test.ics

@@ -0,0 +1,29 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+CALSCALE:GREGORIAN
+METHOD:PUBLISH
+PRODID:-//Fastmail/2020.5/EN
+X-APPLE-CALENDAR-COLOR:#0F6A0F
+X-WR-CALNAME:Test reflector
+X-WR-TIMEZONE:America/Costa_Rica
+BEGIN:VTIMEZONE
+TZID:America/Costa_Rica
+BEGIN:STANDARD
+DTSTART:19700101T000000
+TZOFFSETFROM:-0600
+TZOFFSETTO:-0600
+END:STANDARD
+END:VTIMEZONE
+BEGIN:VEVENT
+ATTENDEE;CN=Mathieu Virbel;PARTSTAT=ACCEPTED:MAILTO:mathieu@monadical.com
+DTEND;TZID=America/Costa_Rica:20250819T143000
+DTSTAMP:20250819T155951Z
+DTSTART;TZID=America/Costa_Rica:20250819T140000
+LOCATION:http://localhost:1250/mathieu
+ORGANIZER;CN=Mathieu Virbel:MAILTO:mathieu@monadical.com
+SEQUENCE:1
+SUMMARY:Checkin
+TRANSP:OPAQUE
+UID:867df50d-8105-4c58-9280-2b5d26cc9cd3
+END:VEVENT
+END:VCALENDAR

server/tests/test_attendee_parsing_bug.ics

@@ -0,0 +1,18 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+CALSCALE:GREGORIAN
+METHOD:PUBLISH
+PRODID:-//Test/1.0/EN
+X-WR-CALNAME:Test Attendee Bug
+BEGIN:VEVENT
+ATTENDEE:MAILTO:alice@example.com,bob@example.com,charlie@example.com,diana@example.com,eve@example.com,frank@example.com,george@example.com,helen@example.com,ivan@example.com,jane@example.com,kevin@example.com,laura@example.com,mike@example.com,nina@example.com,oscar@example.com,paul@example.com,queen@example.com,robert@example.com,sarah@example.com,tom@example.com,ursula@example.com,victor@example.com,wendy@example.com,xavier@example.com,yvonne@example.com,zack@example.com,amy@example.com,bill@example.com,carol@example.com
+DTEND:20250910T190000Z
+DTSTAMP:20250910T174000Z
+DTSTART:20250910T180000Z
+LOCATION:http://localhost:3000/test-room
+ORGANIZER;CN=Test Organizer:MAILTO:organizer@example.com
+SEQUENCE:1
+SUMMARY:Test Meeting with Many Attendees
+UID:test-attendee-bug-event
+END:VEVENT
+END:VCALENDAR

server/tests/test_attendee_parsing_bug.py

@@ -0,0 +1,192 @@
+import os
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from reflector.db.rooms import rooms_controller
+from reflector.services.ics_sync import ICSSyncService
+
+
+@pytest.mark.asyncio
+async def test_attendee_parsing_bug():
+    """
+    Test that reproduces the attendee parsing bug where a string with comma-separated
+    emails gets parsed as individual characters instead of separate email addresses.
+
+    The bug manifests as getting 29 attendees with emails like "M", "A", "I", etc.
+    instead of properly parsed email addresses.
+    """
+    # Create a test 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,
+        ics_url="http://test.com/test.ics",
+        ics_enabled=True,
+    )
+
+    # Read the test ICS file that reproduces the bug and update it with current time
+    from datetime import datetime, timedelta, timezone
+
+    test_ics_path = os.path.join(
+        os.path.dirname(__file__), "test_attendee_parsing_bug.ics"
+    )
+    with open(test_ics_path, "r") as f:
+        ics_content = f.read()
+
+    # Replace the dates with current time + 1 hour to ensure it's within the 24h window
+    now = datetime.now(timezone.utc)
+    future_time = now + timedelta(hours=1)
+    end_time = future_time + timedelta(hours=1)
+
+    # Format dates for ICS format
+    dtstart = future_time.strftime("%Y%m%dT%H%M%SZ")
+    dtend = end_time.strftime("%Y%m%dT%H%M%SZ")
+    dtstamp = now.strftime("%Y%m%dT%H%M%SZ")
+
+    # Update the ICS content with current dates
+    ics_content = ics_content.replace("20250910T180000Z", dtstart)
+    ics_content = ics_content.replace("20250910T190000Z", dtend)
+    ics_content = ics_content.replace("20250910T174000Z", dtstamp)
+
+    # Create sync service and mock the 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
+
+        # Debug: Parse the ICS content directly to examine attendee parsing
+        calendar = sync_service.fetch_service.parse_ics(ics_content)
+        from reflector.settings import settings
+
+        room_url = f"{settings.UI_BASE_URL}/{room.name}"
+
+        print(f"Room URL being used for matching: {room_url}")
+        print(f"ICS content:\n{ics_content}")
+
+        events, total_events = sync_service.fetch_service.extract_room_events(
+            calendar, room.name, room_url
+        )
+
+        print(f"Total events in calendar: {total_events}")
+        print(f"Events matching room: {len(events)}")
+
+        # Perform the sync
+        result = await sync_service.sync_room_calendar(room)
+
+        # Check that the sync succeeded
+        assert result.get("status") == "success"
+        assert result.get("events_found", 0) >= 0  # Allow for debugging
+
+        # We already have the matching events from the debug code above
+        assert len(events) == 1
+        event = events[0]
+
+        # This is where the bug manifests - check the attendees
+        attendees = event["attendees"]
+
+        # Print attendee info for debugging
+        print(f"Number of attendees found: {len(attendees)}")
+        for i, attendee in enumerate(attendees):
+            print(
+                f"Attendee {i}: email='{attendee.get('email')}', name='{attendee.get('name')}'"
+            )
+
+        # With the fix, we should now get properly parsed email addresses
+        # Check that no single characters are parsed as emails
+        single_char_emails = [
+            att for att in attendees if att.get("email") and len(att["email"]) == 1
+        ]
+
+        if single_char_emails:
+            print(
+                f"BUG DETECTED: Found {len(single_char_emails)} single-character emails:"
+            )
+            for att in single_char_emails:
+                print(f"  - '{att['email']}'")
+
+        # Should have attendees but not single-character emails
+        assert len(attendees) > 0
+        assert (
+            len(single_char_emails) == 0
+        ), f"Found {len(single_char_emails)} single-character emails, parsing is still buggy"
+
+        # Check that all emails are valid (contain @ symbol)
+        valid_emails = [
+            att for att in attendees if att.get("email") and "@" in att["email"]
+        ]
+        assert len(valid_emails) == len(
+            attendees
+        ), "Some attendees don't have valid email addresses"
+
+        # We expect around 29 attendees (28 from the comma-separated list + 1 organizer)
+        assert (
+            len(attendees) >= 25
+        ), f"Expected around 29 attendees, got {len(attendees)}"
+
+
+@pytest.mark.asyncio
+async def test_correct_attendee_parsing():
+    """
+    Test what correct attendee parsing should look like.
+    """
+    from datetime import datetime, timezone
+
+    from icalendar import Event
+
+    from reflector.services.ics_sync import ICSFetchService
+
+    service = ICSFetchService()
+
+    # Create a properly formatted event with multiple attendees
+    event = Event()
+    event.add("uid", "test-correct-attendees")
+    event.add("summary", "Test Meeting")
+    event.add("location", "http://test.com/test")
+    event.add("dtstart", datetime.now(timezone.utc))
+    event.add("dtend", datetime.now(timezone.utc))
+
+    # Add attendees the correct way (separate ATTENDEE lines)
+    event.add("attendee", "mailto:alice@example.com", parameters={"CN": "Alice"})
+    event.add("attendee", "mailto:bob@example.com", parameters={"CN": "Bob"})
+    event.add("attendee", "mailto:charlie@example.com", parameters={"CN": "Charlie"})
+    event.add(
+        "organizer", "mailto:organizer@example.com", parameters={"CN": "Organizer"}
+    )
+
+    # Parse the event
+    result = service._parse_event(event)
+
+    assert result is not None
+    attendees = result["attendees"]
+
+    # Should have 4 attendees (3 attendees + 1 organizer)
+    assert len(attendees) == 4
+
+    # Check that all emails are valid email addresses
+    emails = [att["email"] for att in attendees if att.get("email")]
+    expected_emails = [
+        "alice@example.com",
+        "bob@example.com",
+        "charlie@example.com",
+        "organizer@example.com",
+    ]
+
+    for email in emails:
+        assert "@" in email, f"Invalid email format: {email}"
+        assert len(email) > 5, f"Email too short: {email}"
+
+    # Check that we have the expected emails
+    assert "alice@example.com" in emails
+    assert "bob@example.com" in emails
+    assert "charlie@example.com" in emails
+    assert "organizer@example.com" in emails

server/tests/test_calendar_event.py

@@ -0,0 +1,424 @@
+"""
+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.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)
+
+    # Currently happening event (started 10 minutes ago, ends in 20 minutes)
+    current_event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="current-event",
+        title="Current Meeting",
+        start_time=now - timedelta(minutes=10),
+        end_time=now + timedelta(minutes=20),
+    )
+    await calendar_events_controller.upsert(current_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 120 minutes) - should include current, upcoming, and future
+    upcoming = await calendar_events_controller.get_upcoming(room.id)
+
+    assert len(upcoming) == 3
+    # Events should be sorted by start_time (current event first, then upcoming, then future)
+    assert upcoming[0].ics_uid == "current-event"
+    assert upcoming[1].ics_uid == "upcoming-event"
+    assert upcoming[2].ics_uid == "future-event"
+
+    # Get upcoming with custom window
+    upcoming_extended = await calendar_events_controller.get_upcoming(
+        room.id, minutes_ahead=180
+    )
+
+    assert len(upcoming_extended) == 3
+    # Events should be sorted by start_time
+    assert upcoming_extended[0].ics_uid == "current-event"
+    assert upcoming_extended[1].ics_uid == "upcoming-event"
+    assert upcoming_extended[2].ics_uid == "future-event"
+
+
+@pytest.mark.asyncio
+async def test_calendar_event_get_upcoming_includes_currently_happening():
+    """Test that get_upcoming includes currently happening events but excludes ended events."""
+    # Create room
+    room = await rooms_controller.add(
+        name="current-happening-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)
+
+    # Event that ended in the past (should NOT be included)
+    past_ended_event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="past-ended-event",
+        title="Past Ended Meeting",
+        start_time=now - timedelta(hours=2),
+        end_time=now - timedelta(minutes=30),
+    )
+    await calendar_events_controller.upsert(past_ended_event)
+
+    # Event currently happening (started 10 minutes ago, ends in 20 minutes) - SHOULD be included
+    currently_happening_event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="currently-happening",
+        title="Currently Happening Meeting",
+        start_time=now - timedelta(minutes=10),
+        end_time=now + timedelta(minutes=20),
+    )
+    await calendar_events_controller.upsert(currently_happening_event)
+
+    # Event starting soon (in 5 minutes) - SHOULD be included
+    upcoming_soon_event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="upcoming-soon",
+        title="Upcoming Soon Meeting",
+        start_time=now + timedelta(minutes=5),
+        end_time=now + timedelta(minutes=35),
+    )
+    await calendar_events_controller.upsert(upcoming_soon_event)
+
+    # Get upcoming events
+    upcoming = await calendar_events_controller.get_upcoming(room.id, minutes_ahead=30)
+
+    # Should only include currently happening and upcoming soon events
+    assert len(upcoming) == 2
+    assert upcoming[0].ics_uid == "currently-happening"
+    assert upcoming[1].ics_uid == "upcoming-soon"
+
+
+@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,255 @@
+from datetime import datetime, timedelta, timezone
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from icalendar import Calendar, Event
+
+from reflector.db import get_database
+from reflector.db.calendar_events import calendar_events_controller
+from reflector.db.rooms import rooms, rooms_controller
+from reflector.services.ics_sync import ics_sync_service
+from reflector.worker.ics_sync import (
+    _should_sync,
+    sync_room_ics,
+)
+
+
+@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.UI_BASE_URL}/{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
+
+        # Call the service directly instead of the Celery task to avoid event loop issues
+        await ics_sync_service.sync_room_calendar(room)
+
+        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,
+    )
+
+    # Test that disabled rooms are skipped by the service
+    result = await ics_sync_service.sync_room_calendar(room)
+
+    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:
+        # Directly call the sync_all logic without the Celery wrapper
+        query = rooms.select().where(
+            rooms.c.ics_enabled == True, rooms.c.ics_url != None
+        )
+        all_rooms = await get_database().fetch_all(query)
+
+        for room_data in all_rooms:
+            room_id = room_data["id"]
+            room = await rooms_controller.get_by_id(room_id)
+            if room and _should_sync(room):
+                sync_room_ics.delay(room_id)
+
+        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:
+        # Test the sync logic without the Celery wrapper
+        query = rooms.select().where(
+            rooms.c.ics_enabled == True, rooms.c.ics_url != None
+        )
+        all_rooms = await get_database().fetch_all(query)
+
+        for room_data in all_rooms:
+            room_id = room_data["id"]
+            room = await rooms_controller.get_by_id(room_id)
+            if room and _should_sync(room):
+                sync_room_ics.delay(room_id)
+
+        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")
+
+        # Call the service directly to test error handling
+        result = await ics_sync_service.sync_room_calendar(room)
+        assert result["status"] == "error"
+
+        events = await calendar_events_controller.get_by_room(room.id)
+        assert len(events) == 0

server/tests/test_ics_sync.py

@@ -0,0 +1,290 @@
+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/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/test-room")
+    assert service._event_matches_room(event, room_name, room_url) is True
+
+    # Test non-matching with URL without protocol (exact matching only now)
+    event["location"] = "example.com/test-room"
+    assert service._event_matches_room(event, room_name, room_url) is False
+
+    # 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"] = "/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/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/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/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/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, total_events = service.extract_room_events(cal, room_name, room_url)
+
+    assert len(events) == 2
+    assert total_events == 3  # 3 events in time window (excluding cancelled)
+    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 UI_BASE_URL from settings
+    from reflector.settings import settings
+
+    event.add("location", f"{settings.UI_BASE_URL}/{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_jibri_events.py

@@ -1,122 +0,0 @@
-import json
-import tempfile
-from pathlib import Path
-
-from reflector.jibri_events import (
-    JitsiEventParser,
-    ParticipantJoinedEvent,
-    RoomCreatedEvent,
-)
-
-
-def test_parse_room_created_event():
-    parser = JitsiEventParser()
-    event_data = {
-        "type": "room_created",
-        "timestamp": 1234567890,
-        "room_name": "TestRoom",
-        "room_jid": "testroom@conference.meet.jitsi",
-        "meeting_url": "https://meet.jitsi/TestRoom",
-    }
-
-    event = parser.parse_event(event_data)
-
-    assert isinstance(event, RoomCreatedEvent)
-    assert event.room_name == "TestRoom"
-    assert event.meeting_url == "https://meet.jitsi/TestRoom"
-
-
-def test_parse_participant_joined_event():
-    parser = JitsiEventParser()
-    event_data = {
-        "type": "participant_joined",
-        "timestamp": 1234567891,
-        "room_name": "TestRoom",
-        "participant": {
-            "jid": "user1@meet.jitsi/resource",
-            "nick": "John Doe",
-            "id": "user1@meet.jitsi",
-            "is_moderator": False,
-        },
-    }
-
-    event = parser.parse_event(event_data)
-
-    assert isinstance(event, ParticipantJoinedEvent)
-    assert event.participant.nick == "John Doe"
-    assert event.participant.is_moderator is False
-
-
-def test_parse_unknown_event_returns_none():
-    parser = JitsiEventParser()
-    event_data = {"type": "unknown_event", "timestamp": 1234567890}
-
-    event = parser.parse_event(event_data)
-    assert event is None
-
-
-def test_parse_events_file_with_complete_session():
-    parser = JitsiEventParser()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        events_file = Path(tmpdir) / "events.jsonl"
-
-        events = [
-            {
-                "type": "room_created",
-                "timestamp": 1234567890,
-                "room_name": "TestRoom",
-                "room_jid": "testroom@conference.meet.jitsi",
-                "meeting_url": "https://meet.jitsi/TestRoom",
-            },
-            {
-                "type": "participant_joined",
-                "timestamp": 1234567892,
-                "room_name": "TestRoom",
-                "participant": {
-                    "jid": "user1@meet.jitsi/resource",
-                    "nick": "John Doe",
-                    "id": "user1@meet.jitsi",
-                    "is_moderator": False,
-                },
-            },
-            {
-                "type": "speaker_active",
-                "timestamp": 1234567895,
-                "room_name": "TestRoom",
-                "speaker_jid": "user1@meet.jitsi",
-                "speaker_nick": "John Doe",
-                "duration": 10,
-            },
-            {
-                "type": "participant_left",
-                "timestamp": 1234567920,
-                "room_name": "TestRoom",
-                "participant": {
-                    "jid": "user1@meet.jitsi/resource",
-                    "duration_seconds": 28,
-                },
-            },
-        ]
-
-        with open(events_file, "w") as f:
-            for event in events:
-                f.write(json.dumps(event) + "\n")
-
-        metadata = parser.parse_events_file(tmpdir)
-
-        assert metadata["room"]["name"] == "TestRoom"
-        assert metadata["room"]["meeting_url"] == "https://meet.jitsi/TestRoom"
-        assert len(metadata["participants"]) == 1
-        assert metadata["event_count"] == 4
-
-
-def test_parse_events_file_missing_file():
-    parser = JitsiEventParser()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        metadata = parser.parse_events_file(tmpdir)
-
-        assert metadata["room"]["name"] == ""
-        assert len(metadata["participants"]) == 0
-        assert metadata["event_count"] == 0

server/tests/test_jibri_webhook.py

@@ -1,254 +0,0 @@
-import json
-import tempfile
-from pathlib import Path
-from unittest.mock import Mock, patch
-
-import pytest
-from fastapi.testclient import TestClient
-from sqlalchemy.orm import Session
-
-from reflector.api.jibri_webhook import router
-from reflector.models import Transcript
-
-
-@pytest.fixture
-def client():
-    from fastapi import FastAPI
-
-    app = FastAPI()
-    app.include_router(router)
-    return TestClient(app)
-
-
-@pytest.fixture
-def mock_db():
-    db = Mock(spec=Session)
-    db.add = Mock()
-    db.commit = Mock()
-    db.refresh = Mock()
-    return db
-
-
-@pytest.fixture
-def mock_settings():
-    with patch("reflector.api.jibri_webhook.settings") as mock:
-        mock.JIBRI_RECORDINGS_PATH = "/recordings"
-        yield mock
-
-
-@pytest.fixture
-def mock_pipeline():
-    with patch("reflector.api.jibri_webhook.TranscriptMainPipeline") as mock:
-        pipeline_instance = Mock()
-        pipeline_instance.create = Mock()
-        mock.return_value = pipeline_instance
-        yield mock
-
-
-class TestJibriWebhook:
-    def test_recording_ready_success_with_events(
-        self, client, mock_db, mock_settings, mock_pipeline
-    ):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            mock_settings.JIBRI_RECORDINGS_PATH = tmpdir
-
-            # Create recording directory and files
-            session_id = "test-session-123"
-            recording_dir = Path(tmpdir) / session_id
-            recording_dir.mkdir()
-
-            recording_file = recording_dir / "recording.mp4"
-            recording_file.write_text("fake video content")
-
-            events_file = recording_dir / "events.jsonl"
-            events = [
-                {
-                    "type": "room_created",
-                    "timestamp": 1234567890,
-                    "room_name": "TestRoom",
-                    "room_jid": "testroom@conference.meet.jitsi",
-                    "meeting_url": "https://meet.jitsi/TestRoom",
-                },
-                {
-                    "type": "participant_joined",
-                    "timestamp": 1234567892,
-                    "room_name": "TestRoom",
-                    "participant": {
-                        "jid": "user1@meet.jitsi/resource",
-                        "nick": "John Doe",
-                        "id": "user1@meet.jitsi",
-                        "is_moderator": False,
-                    },
-                },
-            ]
-
-            with open(events_file, "w") as f:
-                for event in events:
-                    f.write(json.dumps(event) + "\n")
-
-            # Mock database dependency
-            with patch("reflector.api.jibri_webhook.get_db") as mock_get_db:
-                mock_get_db.return_value = mock_db
-
-                response = client.post(
-                    "/api/v1/jibri/recording-ready",
-                    json={
-                        "session_id": session_id,
-                        "path": session_id,
-                        "meeting_url": "https://meet.jitsi/TestRoom",
-                    },
-                )
-
-            assert response.status_code == 200
-            data = response.json()
-
-            assert data["status"] == "accepted"
-            assert data["session_id"] == session_id
-            assert data["events_found"] is True
-            assert data["participant_count"] == 1
-
-            # Verify transcript was created
-            mock_db.add.assert_called_once()
-            transcript_arg = mock_db.add.call_args[0][0]
-            assert isinstance(transcript_arg, Transcript)
-            assert "TestRoom" in transcript_arg.title
-            assert transcript_arg.metadata["jitsi"]["room"]["name"] == "TestRoom"
-
-            # Verify pipeline was triggered
-            mock_pipeline.return_value.create.assert_called_once()
-
-    def test_recording_ready_success_without_events(
-        self, client, mock_db, mock_settings, mock_pipeline
-    ):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            mock_settings.JIBRI_RECORDINGS_PATH = tmpdir
-
-            session_id = "test-session-456"
-            recording_dir = Path(tmpdir) / session_id
-            recording_dir.mkdir()
-
-            recording_file = recording_dir / "recording.mp4"
-            recording_file.write_text("fake video content")
-
-            with patch("reflector.api.jibri_webhook.get_db") as mock_get_db:
-                mock_get_db.return_value = mock_db
-
-                response = client.post(
-                    "/api/v1/jibri/recording-ready",
-                    json={
-                        "session_id": session_id,
-                        "path": session_id,
-                        "meeting_url": "https://meet.jitsi/NoEventsRoom",
-                    },
-                )
-
-            assert response.status_code == 200
-            data = response.json()
-
-            assert data["status"] == "accepted"
-            assert data["events_found"] is False
-            assert data["participant_count"] == 0
-
-            # Verify transcript was created with minimal metadata
-            mock_db.add.assert_called_once()
-            transcript_arg = mock_db.add.call_args[0][0]
-            assert transcript_arg.metadata["jitsi"]["participants"] == []
-
-    def test_recording_ready_path_not_found(self, client, mock_settings):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            mock_settings.JIBRI_RECORDINGS_PATH = tmpdir
-
-            response = client.post(
-                "/api/v1/jibri/recording-ready",
-                json={
-                    "session_id": "nonexistent",
-                    "path": "nonexistent",
-                    "meeting_url": "https://meet.jitsi/Test",
-                },
-            )
-
-            assert response.status_code == 404
-            assert "Recording path not found" in response.json()["detail"]
-
-    def test_recording_ready_recording_file_not_found(self, client, mock_settings):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            mock_settings.JIBRI_RECORDINGS_PATH = tmpdir
-
-            session_id = "test-no-recording"
-            recording_dir = Path(tmpdir) / session_id
-            recording_dir.mkdir()
-
-            # No recording.mp4 file created
-
-            response = client.post(
-                "/api/v1/jibri/recording-ready",
-                json={
-                    "session_id": session_id,
-                    "path": session_id,
-                    "meeting_url": "https://meet.jitsi/Test",
-                },
-            )
-
-            assert response.status_code == 404
-            assert "Recording file not found" in response.json()["detail"]
-
-    def test_recording_ready_with_relative_path(
-        self, client, mock_db, mock_settings, mock_pipeline
-    ):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            mock_settings.JIBRI_RECORDINGS_PATH = tmpdir
-
-            # Create nested directory structure
-            session_id = "2024/01/15/test-session"
-            recording_dir = Path(tmpdir) / session_id
-            recording_dir.mkdir(parents=True)
-
-            recording_file = recording_dir / "recording.mp4"
-            recording_file.write_text("fake video content")
-
-            with patch("reflector.api.jibri_webhook.get_db") as mock_get_db:
-                mock_get_db.return_value = mock_db
-
-                response = client.post(
-                    "/api/v1/jibri/recording-ready",
-                    json={
-                        "session_id": "test-session",
-                        "path": session_id,  # Relative path with subdirectories
-                        "meeting_url": "https://meet.jitsi/Test",
-                    },
-                )
-
-            assert response.status_code == 200
-            data = response.json()
-            assert data["status"] == "accepted"
-
-    def test_recording_ready_empty_meeting_url(
-        self, client, mock_db, mock_settings, mock_pipeline
-    ):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            mock_settings.JIBRI_RECORDINGS_PATH = tmpdir
-
-            session_id = "test-session"
-            recording_dir = Path(tmpdir) / session_id
-            recording_dir.mkdir()
-
-            recording_file = recording_dir / "recording.mp4"
-            recording_file.write_text("fake video content")
-
-            with patch("reflector.api.jibri_webhook.get_db") as mock_get_db:
-                mock_get_db.return_value = mock_db
-
-                response = client.post(
-                    "/api/v1/jibri/recording-ready",
-                    json={
-                        "session_id": session_id,
-                        "path": session_id,
-                        "meeting_url": "",
-                    },
-                )
-
-            assert response.status_code == 200
-
-            # Verify fallback URL was used
-            transcript_arg = mock_db.add.call_args[0][0]
-            assert transcript_arg.source_url == f"jitsi://{session_id}"

server/tests/test_model_api_diarization.py

@@ -0,0 +1,63 @@
+"""
+Tests for diarization Model API endpoint (self-hosted service compatible shape).
+
+Marked with the "model_api" marker and skipped unless DIARIZATION_URL is provided.
+
+Run with for local self-hosted server:
+    DIARIZATION_API_KEY=dev-key \
+    DIARIZATION_URL=http://localhost:8000 \
+    uv run -m pytest -m model_api --no-cov tests/test_model_api_diarization.py
+"""
+
+import os
+
+import httpx
+import pytest
+
+# Public test audio file hosted on S3 specifically for reflector pytests
+TEST_AUDIO_URL = (
+    "https://reflector-github-pytest.s3.us-east-1.amazonaws.com/test_mathieu_hello.mp3"
+)
+
+
+def get_modal_diarization_url():
+    url = os.environ.get("DIARIZATION_URL")
+    if not url:
+        pytest.skip(
+            "DIARIZATION_URL environment variable is required for Model API tests"
+        )
+    return url
+
+
+def get_auth_headers():
+    api_key = os.environ.get("DIARIZATION_API_KEY") or os.environ.get(
+        "REFLECTOR_GPU_APIKEY"
+    )
+    return {"Authorization": f"Bearer {api_key}"} if api_key else {}
+
+
+@pytest.mark.model_api
+class TestModelAPIDiarization:
+    def test_diarize_from_url(self):
+        url = get_modal_diarization_url()
+        headers = get_auth_headers()
+
+        with httpx.Client(timeout=60.0) as client:
+            response = client.post(
+                f"{url}/diarize",
+                params={"audio_file_url": TEST_AUDIO_URL, "timestamp": 0.0},
+                headers=headers,
+            )
+
+            assert response.status_code == 200, f"Request failed: {response.text}"
+            result = response.json()
+
+            assert "diarization" in result
+            assert isinstance(result["diarization"], list)
+            assert len(result["diarization"]) > 0
+
+            for seg in result["diarization"]:
+                assert "start" in seg and "end" in seg and "speaker" in seg
+                assert isinstance(seg["start"], (int, float))
+                assert isinstance(seg["end"], (int, float))
+                assert seg["start"] <= seg["end"]

server/tests/test_model_api_transcript.py

@@ -1,21 +1,21 @@
 """
-Tests for GPU Modal transcription endpoints.
+Tests for transcription Model API endpoints.
 
-These tests are marked with the "gpu-modal" group and will not run by default.
-Run them with: pytest -m gpu-modal tests/test_gpu_modal_transcript_parakeet.py
+These tests are marked with the "model_api" group and will not run by default.
+Run them with: pytest -m model_api tests/test_model_api_transcript.py
 
 Required environment variables:
-- TRANSCRIPT_URL: URL to the Modal.com endpoint (required)
-- TRANSCRIPT_MODAL_API_KEY: API key for authentication (optional)
+- TRANSCRIPT_URL: URL to the Model API endpoint (required)
+- TRANSCRIPT_API_KEY: API key for authentication (optional)
 - TRANSCRIPT_MODEL: Model name to use (optional, defaults to nvidia/parakeet-tdt-0.6b-v2)
 
-Example with pytest (override default addopts to run ONLY gpu_modal tests):
+Example with pytest (override default addopts to run ONLY model_api tests):
     TRANSCRIPT_URL=https://monadical-sas--reflector-transcriber-parakeet-web-dev.modal.run \
-    TRANSCRIPT_MODAL_API_KEY=your-api-key \
-    uv run -m pytest -m gpu_modal --no-cov tests/test_gpu_modal_transcript.py
+    TRANSCRIPT_API_KEY=your-api-key \
+    uv run -m pytest -m model_api --no-cov tests/test_model_api_transcript.py
 
     # Or with completely clean options:
-    uv run -m pytest -m gpu_modal -o addopts="" tests/
+    uv run -m pytest -m model_api -o addopts="" tests/
 
 Running Modal locally for testing:
     modal serve gpu/modal_deployments/reflector_transcriber_parakeet.py
@@ -40,14 +40,16 @@ def get_modal_transcript_url():
     url = os.environ.get("TRANSCRIPT_URL")
     if not url:
         pytest.skip(
-            "TRANSCRIPT_URL environment variable is required for GPU Modal tests"
+            "TRANSCRIPT_URL environment variable is required for Model API tests"
         )
     return url
 
 
 def get_auth_headers():
     """Get authentication headers if API key is available."""
-    api_key = os.environ.get("TRANSCRIPT_MODAL_API_KEY")
+    api_key = os.environ.get("TRANSCRIPT_API_KEY") or os.environ.get(
+        "REFLECTOR_GPU_APIKEY"
+    )
     if api_key:
         return {"Authorization": f"Bearer {api_key}"}
     return {}
@@ -58,8 +60,8 @@ def get_model_name():
     return os.environ.get("TRANSCRIPT_MODEL", "nvidia/parakeet-tdt-0.6b-v2")
 
 
-@pytest.mark.gpu_modal
-class TestGPUModalTranscript:
+@pytest.mark.model_api
+class TestModelAPITranscript:
     """Test suite for GPU Modal transcription endpoints."""
 
     def test_transcriptions_from_url(self):

server/tests/test_model_api_translation.py

@@ -0,0 +1,56 @@
+"""
+Tests for translation Model API endpoint (self-hosted service compatible shape).
+
+Marked with the "model_api" marker and skipped unless TRANSLATION_URL is provided
+or we fallback to TRANSCRIPT_URL base (same host for self-hosted).
+
+Run locally against self-hosted server:
+    TRANSLATION_API_KEY=dev-key \
+    TRANSLATION_URL=http://localhost:8000 \
+    uv run -m pytest -m model_api --no-cov tests/test_model_api_translation.py
+"""
+
+import os
+
+import httpx
+import pytest
+
+
+def get_translation_url():
+    url = os.environ.get("TRANSLATION_URL") or os.environ.get("TRANSCRIPT_URL")
+    if not url:
+        pytest.skip(
+            "TRANSLATION_URL or TRANSCRIPT_URL environment variable is required for Model API tests"
+        )
+    return url
+
+
+def get_auth_headers():
+    api_key = os.environ.get("TRANSLATION_API_KEY") or os.environ.get(
+        "REFLECTOR_GPU_APIKEY"
+    )
+    return {"Authorization": f"Bearer {api_key}"} if api_key else {}
+
+
+@pytest.mark.model_api
+class TestModelAPITranslation:
+    def test_translate_text(self):
+        url = get_translation_url()
+        headers = get_auth_headers()
+
+        with httpx.Client(timeout=60.0) as client:
+            response = client.post(
+                f"{url}/translate",
+                params={"text": "The meeting will start in five minutes."},
+                json={"source_language": "en", "target_language": "fr"},
+                headers=headers,
+            )
+
+            assert response.status_code == 200, f"Request failed: {response.text}"
+            data = response.json()
+
+            assert "text" in data and isinstance(data["text"], dict)
+            assert data["text"].get("en") == "The meeting will start in five minutes."
+            assert isinstance(data["text"].get("fr", ""), str)
+            assert len(data["text"]["fr"]) > 0
+            assert data["text"]["fr"] == "La réunion commencera dans cinq minutes."

server/tests/test_multiple_active_meetings.py

@@ -0,0 +1,167 @@
+"""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,
+        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,
+        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,
+        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_calendar_meeting_deactivates_after_scheduled_end():
+    """Test that unused calendar meetings deactivate after scheduled end time."""
+    # 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 that ended 35 minutes ago
+    event = CalendarEvent(
+        room_id=room.id,
+        ics_uid="test-event-unused",
+        title="Test Meeting Unused",
+        start_time=datetime.now(timezone.utc) - timedelta(hours=2),
+        end_time=datetime.now(timezone.utc) - timedelta(minutes=35),
+    )
+    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-unused",
+        room_name="test-meeting-unused",
+        room_url="https://whereby.com/test-unused",
+        host_room_url="https://whereby.com/test-unused-host",
+        start_date=event.start_time,
+        end_date=event.end_time,
+        room=room,
+        calendar_event_id=event.id,
+    )
+
+    # Test the new logic: unused calendar meetings deactivate after scheduled end
+    # The meeting ended 35 minutes ago and was never used, so it should be deactivated
+
+    # Simulate process_meetings logic for unused calendar meeting past end time
+    if meeting.calendar_event_id and current_time > meeting.end_date:
+        # In real code, we'd check has_had_sessions = False here
+        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  # Deactivated after scheduled end

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,390 @@
+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,
+            "webhook_url": "",
+            "webhook_secret": "",
+            "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,
+            "webhook_url": "",
+            "webhook_secret": "",
+        },
+    )
+    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.UI_BASE_URL}/{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) == 2
+    assert data[0]["title"] == "Soon"
+    assert data[1]["title"] == "Later"
+
+    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_video_platforms.py

@@ -1,768 +0,0 @@
-"""Tests for video platform abstraction and Jitsi integration."""
-
-from datetime import datetime, timedelta, timezone
-from unittest.mock import Mock, patch
-
-import pytest
-from fastapi.testclient import TestClient
-
-from reflector.db.rooms import Room, VideoPlatform
-from reflector.video_platforms.base import (
-    MeetingData,
-    VideoPlatformClient,
-    VideoPlatformConfig,
-)
-from reflector.video_platforms.factory import (
-    create_platform_client,
-    get_platform_config,
-)
-from reflector.video_platforms.jitsi import JitsiClient
-from reflector.video_platforms.registry import (
-    get_available_platforms,
-    get_platform_client,
-    register_platform,
-)
-from reflector.video_platforms.whereby import WherebyClient
-
-
-class TestVideoPlatformBase:
-    """Test the video platform base classes and interfaces."""
-
-    def test_video_platform_config_creation(self):
-        """Test VideoPlatformConfig can be created with required fields."""
-        config = VideoPlatformConfig(
-            api_key="test-key",
-            webhook_secret="test-secret",
-            api_url="https://test.example.com",
-        )
-        assert config.api_key == "test-key"
-        assert config.webhook_secret == "test-secret"
-        assert config.api_url == "https://test.example.com"
-
-    def test_meeting_data_creation(self):
-        """Test MeetingData can be created with all fields."""
-        meeting_data = MeetingData(
-            meeting_id="test-123",
-            room_name="test-room",
-            room_url="https://test.com/room",
-            host_room_url="https://test.com/host",
-            platform=VideoPlatform.JITSI,
-            extra_data={"jwt": "token123"},
-        )
-        assert meeting_data.meeting_id == "test-123"
-        assert meeting_data.room_name == "test-room"
-        assert meeting_data.platform == VideoPlatform.JITSI
-        assert meeting_data.extra_data["jwt"] == "token123"
-
-
-class TestJitsiClient:
-    """Test JitsiClient implementation."""
-
-    def setup_method(self):
-        """Set up test fixtures."""
-        self.config = VideoPlatformConfig(
-            api_key="",  # Jitsi doesn't use API key
-            webhook_secret="test-webhook-secret",
-            api_url="https://meet.example.com",
-        )
-        self.client = JitsiClient(self.config)
-        self.test_room = Room(
-            id="test-room-id", name="test-room", user_id="test-user", platform="jitsi"
-        )
-
-    @patch("reflector.settings.settings.JITSI_JWT_SECRET", "test-secret-123")
-    @patch("reflector.settings.settings.JITSI_DOMAIN", "meet.example.com")
-    @patch("reflector.settings.settings.JITSI_JWT_ISSUER", "reflector")
-    @patch("reflector.settings.settings.JITSI_JWT_AUDIENCE", "jitsi")
-    def test_jwt_generation(self):
-        """Test JWT token generation with proper payload."""
-        exp_time = datetime.now(timezone.utc) + timedelta(hours=1)
-        jwt_token = self.client._generate_jwt(
-            room="test-room", moderator=True, exp=exp_time
-        )
-
-        # Verify token is generated
-        assert jwt_token is not None
-        assert len(jwt_token) > 50  # JWT tokens are quite long
-        assert jwt_token.count(".") == 2  # JWT has 3 parts separated by dots
-
-    @patch("reflector.settings.settings.JITSI_JWT_SECRET", None)
-    def test_jwt_generation_without_secret_fails(self):
-        """Test JWT generation fails without secret."""
-        exp_time = datetime.now(timezone.utc) + timedelta(hours=1)
-
-        with pytest.raises(ValueError, match="JITSI_JWT_SECRET is required"):
-            self.client._generate_jwt(room="test-room", moderator=False, exp=exp_time)
-
-    @patch(
-        "reflector.video_platforms.jitsi.client.generate_uuid4",
-        return_value="test-uuid-123",
-    )
-    @patch("reflector.settings.settings.JITSI_JWT_SECRET", "test-secret-123")
-    @patch("reflector.settings.settings.JITSI_DOMAIN", "meet.example.com")
-    @patch("reflector.settings.settings.JITSI_JWT_ISSUER", "reflector")
-    @patch("reflector.settings.settings.JITSI_JWT_AUDIENCE", "jitsi")
-    async def test_create_meeting(self, mock_uuid):
-        """Test meeting creation with JWT tokens."""
-        end_date = datetime.now(timezone.utc) + timedelta(hours=2)
-
-        meeting_data = await self.client.create_meeting(
-            room_name_prefix="test", end_date=end_date, room=self.test_room
-        )
-
-        # Verify meeting data structure
-        assert meeting_data.meeting_id == "test-uuid-123"
-        assert meeting_data.platform == VideoPlatform.JITSI
-        assert "reflector-test-room" in meeting_data.room_name
-        assert "meet.example.com" in meeting_data.room_url
-        assert "jwt=" in meeting_data.room_url
-        assert "jwt=" in meeting_data.host_room_url
-
-        # Verify extra data contains JWT tokens
-        assert "user_jwt" in meeting_data.extra_data
-        assert "host_jwt" in meeting_data.extra_data
-        assert "domain" in meeting_data.extra_data
-
-    async def test_get_room_sessions(self):
-        """Test room sessions retrieval (mock implementation)."""
-        sessions = await self.client.get_room_sessions("test-room")
-
-        assert "roomName" in sessions
-        assert "sessions" in sessions
-        assert sessions["roomName"] == "test-room"
-        assert len(sessions["sessions"]) > 0
-        assert sessions["sessions"][0]["isActive"] is True
-
-    async def test_delete_room(self):
-        """Test room deletion (no-op for Jitsi)."""
-        result = await self.client.delete_room("test-room")
-        assert result is True
-
-    async def test_upload_logo(self):
-        """Test logo upload (no-op for Jitsi)."""
-        result = await self.client.upload_logo("test-room", "logo.png")
-        assert result is True
-
-    def test_verify_webhook_signature_valid(self):
-        """Test webhook signature verification with valid signature."""
-        body = b'{"event": "test"}'
-        # Generate expected signature
-        import hmac
-        from hashlib import sha256
-
-        expected_signature = hmac.new(
-            self.config.webhook_secret.encode(), body, sha256
-        ).hexdigest()
-
-        result = self.client.verify_webhook_signature(body, expected_signature)
-        assert result is True
-
-    def test_verify_webhook_signature_invalid(self):
-        """Test webhook signature verification with invalid signature."""
-        body = b'{"event": "test"}'
-        invalid_signature = "invalid-signature"
-
-        result = self.client.verify_webhook_signature(body, invalid_signature)
-        assert result is False
-
-    def test_verify_webhook_signature_no_secret(self):
-        """Test webhook signature verification without secret."""
-        config = VideoPlatformConfig(
-            api_key="", webhook_secret="", api_url="https://meet.example.com"
-        )
-        client = JitsiClient(config)
-
-        result = client.verify_webhook_signature(b'{"event": "test"}', "signature")
-        assert result is False
-
-
-class TestWherebyClient:
-    """Test WherebyClient implementation."""
-
-    def setup_method(self):
-        """Set up test fixtures."""
-        self.config = VideoPlatformConfig(
-            api_key="test-whereby-api-key",
-            webhook_secret="test-whereby-webhook-secret",
-            api_url="https://api.whereby.dev",
-            s3_bucket="test-recordings-bucket",
-            aws_access_key_id="test-access-key",
-            aws_access_key_secret="test-access-secret",
-        )
-        self.client = WherebyClient(self.config)
-        self.test_room = Room(
-            id="test-room-id",
-            name="test-room",
-            user_id="test-user",
-            platform=VideoPlatform.WHEREBY,
-        )
-
-    @patch("httpx.AsyncClient")
-    async def test_create_meeting(self, mock_client_class):
-        """Test Whereby meeting creation."""
-        # Mock the HTTP response
-        mock_client = mock_client_class.return_value.__aenter__.return_value
-        mock_response = Mock()
-        mock_response.json.return_value = {
-            "meetingId": "whereby-meeting-123",
-            "roomName": "whereby-room-456",
-            "roomUrl": "https://whereby.com/room",
-            "hostRoomUrl": "https://whereby.com/host-room",
-            "startDate": "2025-01-15T10:00:00.000Z",
-            "endDate": "2025-01-15T18:00:00.000Z",
-        }
-        mock_response.raise_for_status.return_value = None
-        mock_client.post.return_value = mock_response
-
-        end_date = datetime.now(timezone.utc) + timedelta(hours=2)
-
-        meeting_data = await self.client.create_meeting(
-            room_name_prefix="test", end_date=end_date, room=self.test_room
-        )
-
-        # Verify meeting data structure
-        assert meeting_data.meeting_id == "whereby-meeting-123"
-        assert meeting_data.room_name == "whereby-room-456"
-        assert meeting_data.platform == VideoPlatform.WHEREBY
-        assert "whereby.com" in meeting_data.room_url
-        assert "whereby.com" in meeting_data.host_room_url
-
-        # Verify HTTP call was made with correct parameters
-        mock_client.post.assert_called_once()
-        call_args = mock_client.post.call_args
-        assert "whereby.dev" in call_args[0][0]  # URL
-        assert "Bearer test-whereby-api-key" in call_args[1]["headers"]["Authorization"]
-
-    @patch("httpx.AsyncClient")
-    async def test_get_room_sessions(self, mock_client_class):
-        """Test Whereby room sessions retrieval."""
-        mock_client = mock_client_class.return_value.__aenter__.return_value
-        mock_response = Mock()
-        mock_response.json.return_value = {
-            "sessions": [
-                {
-                    "id": "session-123",
-                    "startTime": "2025-01-15T10:00:00Z",
-                    "participants": [],
-                }
-            ]
-        }
-        mock_response.raise_for_status.return_value = None
-        mock_client.get.return_value = mock_response
-
-        sessions = await self.client.get_room_sessions("test-room")
-
-        assert "sessions" in sessions
-        assert len(sessions["sessions"]) == 1
-        assert sessions["sessions"][0]["id"] == "session-123"
-
-        # Verify HTTP call
-        mock_client.get.assert_called_once()
-
-    async def test_delete_room(self):
-        """Test room deletion (no-op for Whereby)."""
-        result = await self.client.delete_room("test-room")
-        assert result is True
-
-    @patch("httpx.AsyncClient")
-    async def test_upload_logo_success(self, mock_client_class):
-        """Test logo upload success."""
-        mock_client = mock_client_class.return_value.__aenter__.return_value
-        mock_response = Mock()
-        mock_response.raise_for_status.return_value = None
-        mock_client.put.return_value = mock_response
-
-        # Create a temporary file for testing
-        import tempfile
-
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".png", delete=False) as f:
-            f.write("fake logo content")
-            temp_file = f.name
-
-        result = await self.client.upload_logo("test-room", temp_file)
-        assert result is True
-
-        # Verify HTTP call
-        mock_client.put.assert_called_once()
-
-        # Cleanup
-        import os
-
-        os.unlink(temp_file)
-
-    @patch("httpx.AsyncClient")
-    async def test_upload_logo_failure(self, mock_client_class):
-        """Test logo upload handles HTTP errors gracefully."""
-        mock_client = mock_client_class.return_value.__aenter__.return_value
-        mock_client.put.side_effect = Exception("HTTP error")
-
-        result = await self.client.upload_logo("test-room", "logo.png")
-        assert result is False
-
-    def test_verify_webhook_signature_valid(self):
-        """Test Whereby webhook signature verification with valid signature."""
-        body = b'{"event": "test"}'
-        import hmac
-        from hashlib import sha256
-
-        expected_signature = hmac.new(
-            self.config.webhook_secret.encode(), body, sha256
-        ).hexdigest()
-
-        result = self.client.verify_webhook_signature(body, expected_signature)
-        assert result is True
-
-    def test_verify_webhook_signature_invalid(self):
-        """Test Whereby webhook signature verification with invalid signature."""
-        body = b'{"event": "test"}'
-        invalid_signature = "invalid-signature"
-
-        result = self.client.verify_webhook_signature(body, invalid_signature)
-        assert result is False
-
-
-class TestPlatformRegistry:
-    """Test platform registry functionality."""
-
-    def test_platform_registration(self):
-        """Test platform registration and retrieval."""
-
-        # Create mock client class
-        class MockClient(VideoPlatformClient):
-            async def create_meeting(self, room_name_prefix, end_date, room):
-                pass
-
-            async def get_room_sessions(self, room_name):
-                pass
-
-            async def delete_room(self, room_name):
-                pass
-
-            async def upload_logo(self, room_name, logo_path):
-                pass
-
-            def verify_webhook_signature(self, body, signature, timestamp=None):
-                pass
-
-        # Register mock platform
-        register_platform("test-platform", MockClient)
-
-        # Verify it's available
-        available = get_available_platforms()
-        assert "test-platform" in available
-
-        # Test client creation
-        config = VideoPlatformConfig(
-            api_key="test", webhook_secret="test", api_url="test"
-        )
-        client = get_platform_client("test-platform", config)
-        assert isinstance(client, MockClient)
-
-    def test_get_unknown_platform_raises_error(self):
-        """Test that requesting unknown platform raises error."""
-        config = VideoPlatformConfig(
-            api_key="test", webhook_secret="test", api_url="test"
-        )
-
-        with pytest.raises(ValueError, match="Unknown video platform: nonexistent"):
-            get_platform_client("nonexistent", config)
-
-    def test_builtin_platforms_registered(self):
-        """Test that built-in platforms are registered."""
-        available = get_available_platforms()
-        assert "jitsi" in available
-        assert "whereby" in available
-
-
-class TestPlatformFactory:
-    """Test platform factory functionality."""
-
-    @patch("reflector.settings.settings.JITSI_JWT_SECRET", "test-secret")
-    @patch("reflector.settings.settings.JITSI_WEBHOOK_SECRET", "webhook-secret")
-    @patch("reflector.settings.settings.JITSI_DOMAIN", "meet.example.com")
-    def test_get_jitsi_platform_config(self):
-        """Test Jitsi platform configuration."""
-        config = get_platform_config("jitsi")
-
-        assert config.api_key == ""  # Jitsi uses JWT, no API key
-        assert config.webhook_secret == "webhook-secret"
-        assert config.api_url == "https://meet.example.com"
-
-    @patch("reflector.settings.settings.WHEREBY_API_KEY", "whereby-key")
-    @patch("reflector.settings.settings.WHEREBY_WEBHOOK_SECRET", "whereby-secret")
-    @patch("reflector.settings.settings.WHEREBY_API_URL", "https://api.whereby.dev")
-    def test_get_whereby_platform_config(self):
-        """Test Whereby platform configuration."""
-        config = get_platform_config("whereby")
-
-        assert config.api_key == "whereby-key"
-        assert config.webhook_secret == "whereby-secret"
-        assert config.api_url == "https://api.whereby.dev"
-
-    def test_get_unknown_platform_config_raises_error(self):
-        """Test that unknown platform config raises error."""
-        with pytest.raises(ValueError, match="Unknown platform: nonexistent"):
-            get_platform_config("nonexistent")
-
-    def test_create_platform_client(self):
-        """Test platform client creation via factory."""
-        with patch(
-            "reflector.video_platforms.factory.get_platform_config"
-        ) as mock_config:
-            mock_config.return_value = VideoPlatformConfig(
-                api_key="",
-                webhook_secret="test-secret",
-                api_url="https://meet.example.com",
-            )
-
-            client = create_platform_client("jitsi")
-            assert isinstance(client, JitsiClient)
-
-    def test_create_jitsi_client_typing(self):
-        """Test that create_platform_client returns correctly typed JitsiClient."""
-        with patch(
-            "reflector.video_platforms.factory.get_platform_config"
-        ) as mock_config:
-            mock_config.return_value = VideoPlatformConfig(
-                api_key="",
-                webhook_secret="test-secret",
-                api_url="https://meet.example.com",
-            )
-
-            # The typing overload should ensure this returns JitsiClient
-            client = create_platform_client("jitsi")
-            assert isinstance(client, JitsiClient)
-            # Verify it has Jitsi-specific methods
-            assert hasattr(client, "_generate_jwt")
-
-    def test_create_whereby_client_typing(self):
-        """Test that create_platform_client returns correctly typed WherebyClient."""
-        with patch(
-            "reflector.video_platforms.factory.get_platform_config"
-        ) as mock_config:
-            mock_config.return_value = VideoPlatformConfig(
-                api_key="whereby-key",
-                webhook_secret="whereby-secret",
-                api_url="https://api.whereby.dev",
-            )
-
-            # The typing overload should ensure this returns WherebyClient
-            client = create_platform_client("whereby")
-            assert isinstance(client, WherebyClient)
-            # Verify it has Whereby-specific attributes
-            assert hasattr(client, "headers")
-            assert hasattr(client, "timeout")
-
-
-class TestWebhookEventStorage:
-    """Test webhook event storage functionality."""
-
-    def setup_method(self):
-        """Set up test fixtures."""
-        from reflector.app import app
-
-        self.client = TestClient(app)
-
-    @patch("reflector.db.meetings.meetings_controller.participant_joined")
-    @patch("reflector.db.meetings.meetings_controller.get_by_room_name")
-    @patch(
-        "reflector.video_platforms.jitsi.router.verify_jitsi_webhook_signature",
-        return_value=True,
-    )
-    def test_participant_joined_event_storage(
-        self, mock_verify, mock_get, mock_participant_joined
-    ):
-        """Test that participant joined events are stored correctly."""
-        # Mock meeting
-        mock_meeting = Mock()
-        mock_meeting.id = "test-meeting-id"
-        mock_meeting.num_clients = 1
-        mock_get.return_value = mock_meeting
-
-        payload = {
-            "event": "muc-occupant-joined",
-            "room": "test-room",
-            "timestamp": "2025-01-15T10:30:00.000Z",
-            "data": {"user_id": "test-user", "display_name": "John Doe"},
-        }
-
-        response = self.client.post(
-            "/v1/jitsi/events",
-            json=payload,
-            headers={"x-jitsi-signature": "valid-signature"},
-        )
-
-        assert response.status_code == 200
-        # Verify event was stored with correct data
-        mock_participant_joined.assert_called_once_with(
-            "test-meeting-id",
-            {
-                "timestamp": datetime.fromisoformat(
-                    "2025-01-15T10:30:00.000Z".replace("Z", "+00:00")
-                ),
-                "data": {"user_id": "test-user", "display_name": "John Doe"},
-            },
-        )
-
-    @patch("reflector.db.meetings.meetings_controller.recording_started")
-    @patch("reflector.db.meetings.meetings_controller.get_by_room_name")
-    @patch(
-        "reflector.video_platforms.jitsi.router.verify_jitsi_webhook_signature",
-        return_value=True,
-    )
-    def test_recording_started_event_storage(
-        self, mock_verify, mock_get, mock_recording_started
-    ):
-        """Test that recording started events are stored correctly."""
-        mock_meeting = Mock()
-        mock_meeting.id = "test-meeting-id"
-        mock_meeting.num_clients = 1
-        mock_get.return_value = mock_meeting
-
-        payload = {
-            "event": "jibri-recording-on",
-            "room": "test-room",
-            "timestamp": "2025-01-15T10:32:00.000Z",
-            "data": {"recording_id": "rec-123"},
-        }
-
-        response = self.client.post(
-            "/v1/jitsi/events",
-            json=payload,
-            headers={"x-jitsi-signature": "valid-signature"},
-        )
-
-        assert response.status_code == 200
-        mock_recording_started.assert_called_once_with(
-            "test-meeting-id",
-            {
-                "timestamp": datetime.fromisoformat(
-                    "2025-01-15T10:32:00.000Z".replace("Z", "+00:00")
-                ),
-                "data": {"recording_id": "rec-123"},
-            },
-        )
-
-    @patch("reflector.db.meetings.meetings_controller.add_event")
-    @patch("reflector.db.meetings.meetings_controller.get_by_room_name")
-    @patch(
-        "reflector.video_platforms.jitsi.router.verify_jitsi_webhook_signature",
-        return_value=True,
-    )
-    def test_recording_complete_event_storage(
-        self, mock_verify, mock_get, mock_add_event
-    ):
-        """Test that recording completion events are stored correctly."""
-        mock_meeting = Mock()
-        mock_meeting.id = "test-meeting-id"
-        mock_meeting.num_clients = 1
-        mock_get.return_value = mock_meeting
-
-        payload = {
-            "room_name": "test-room",
-            "recording_file": "/recordings/test.mp4",
-            "recording_status": "completed",
-            "timestamp": "2025-01-15T11:15:00.000Z",
-        }
-
-        response = self.client.post(
-            "/v1/jibri/recording-complete",
-            json=payload,
-            headers={"x-jitsi-signature": "valid-signature"},
-        )
-
-        assert response.status_code == 200
-        mock_add_event.assert_called_once_with(
-            "test-meeting-id",
-            "recording_completed",
-            {
-                "recording_file": "/recordings/test.mp4",
-                "recording_status": "completed",
-                "timestamp": datetime.fromisoformat(
-                    "2025-01-15T11:15:00.000Z".replace("Z", "+00:00")
-                ),
-            },
-        )
-
-
-class TestWebhookEndpoints:
-    """Test Jitsi webhook endpoints."""
-
-    def setup_method(self):
-        """Set up test client."""
-        from reflector.app import app
-
-        self.client = TestClient(app)
-
-    def test_health_endpoint(self):
-        """Test Jitsi health check endpoint."""
-        response = self.client.get("/v1/jitsi/health")
-
-        assert response.status_code == 200
-        data = response.json()
-        assert data["status"] == "ok"
-        assert data["service"] == "jitsi-webhooks"
-        assert "timestamp" in data
-        assert "webhook_secret_configured" in data
-
-    @patch(
-        "reflector.video_platforms.jitsi.router.verify_jitsi_webhook_signature",
-        return_value=True,
-    )
-    @patch("reflector.db.meetings.meetings_controller.get_by_room_name")
-    @patch("reflector.db.meetings.meetings_controller.participant_joined")
-    @patch("reflector.db.meetings.meetings_controller.update_meeting")
-    async def test_jitsi_events_webhook_join(
-        self, mock_update, mock_participant_joined, mock_get, mock_verify
-    ):
-        """Test participant join event webhook."""
-        # Mock meeting
-        mock_meeting = Mock()
-        mock_meeting.id = "test-meeting-id"
-        mock_meeting.num_clients = 1
-        mock_get.return_value = mock_meeting
-
-        payload = {
-            "event": "muc-occupant-joined",
-            "room": "test-room",
-            "timestamp": "2025-01-15T10:30:00.000Z",
-            "data": {},
-        }
-
-        response = self.client.post(
-            "/v1/jitsi/events",
-            json=payload,
-            headers={"x-jitsi-signature": "valid-signature"},
-        )
-
-        assert response.status_code == 200
-        data = response.json()
-        assert data["status"] == "ok"
-        assert data["event"] == "muc-occupant-joined"
-        assert data["room"] == "test-room"
-
-    @patch(
-        "reflector.video_platforms.jitsi.router.verify_jitsi_webhook_signature",
-        return_value=False,
-    )
-    async def test_jitsi_events_webhook_invalid_signature(self, mock_verify):
-        """Test webhook with invalid signature returns 401."""
-        payload = {
-            "event": "muc-occupant-joined",
-            "room": "test-room",
-            "timestamp": "2025-01-15T10:30:00.000Z",
-            "data": {},
-        }
-
-        response = self.client.post(
-            "/v1/jitsi/events",
-            json=payload,
-            headers={"x-jitsi-signature": "invalid-signature"},
-        )
-
-        assert response.status_code == 401
-        assert "Invalid webhook signature" in response.text
-
-    @patch(
-        "reflector.video_platforms.jitsi.router.verify_jitsi_webhook_signature",
-        return_value=True,
-    )
-    @patch(
-        "reflector.db.meetings.meetings_controller.get_by_room_name", return_value=None
-    )
-    async def test_jitsi_events_webhook_meeting_not_found(self, mock_get, mock_verify):
-        """Test webhook with nonexistent meeting returns 404."""
-        payload = {
-            "event": "muc-occupant-joined",
-            "room": "nonexistent-room",
-            "timestamp": "2025-01-15T10:30:00.000Z",
-            "data": {},
-        }
-
-        response = self.client.post(
-            "/v1/jitsi/events",
-            json=payload,
-            headers={"x-jitsi-signature": "valid-signature"},
-        )
-
-        assert response.status_code == 404
-        assert "Meeting not found" in response.text
-
-
-class TestRoomsPlatformIntegration:
-    """Test rooms endpoint integration with platform abstraction."""
-
-    def setup_method(self):
-        """Set up test client."""
-        from reflector.app import app
-
-        self.client = TestClient(app)
-
-    @patch("reflector.auth.current_user_optional")
-    @patch("reflector.db.rooms.rooms_controller.add")
-    def test_create_room_with_jitsi_platform(self, mock_add, mock_auth):
-        """Test room creation with Jitsi platform."""
-        from datetime import datetime, timezone
-
-        mock_auth.return_value = {"sub": "test-user"}
-
-        # Create a proper Room object for the mock return
-        from reflector.db.rooms import Room
-
-        mock_room = Room(
-            id="test-room-id",
-            name="test-jitsi-room",
-            user_id="test-user",
-            created_at=datetime.now(timezone.utc),
-            zulip_auto_post=False,
-            zulip_stream="",
-            zulip_topic="",
-            is_locked=False,
-            room_mode="normal",
-            recording_type="cloud",
-            recording_trigger="automatic-2nd-participant",
-            is_shared=False,
-            platform=VideoPlatform.JITSI,
-        )
-        mock_add.return_value = mock_room
-
-        payload = {
-            "name": "test-jitsi-room",
-            "platform": "jitsi",
-            "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,
-            "webhook_url": "",
-            "webhook_secret": "",
-        }
-
-        response = self.client.post("/v1/rooms", json=payload)
-
-        # Verify the add method was called with platform parameter
-        mock_add.assert_called_once()
-        call_args = mock_add.call_args
-        assert call_args.kwargs["platform"] == "jitsi"
-        assert call_args.kwargs["name"] == "test-jitsi-room"
-        assert response.status_code == 200
-
-    def test_create_meeting_with_jitsi_platform_fallback(self):
-        """Test that meeting creation falls back to whereby when platform client unavailable."""
-        # This tests the fallback behavior in rooms.py when platform client returns None
-        # The actual platform integration test is covered in the unit tests above
-
-        # Just verify the endpoint exists and has the right structure
-        # More detailed integration testing would require a full test database setup
-        assert hasattr(self.client.app, "routes")
-
-        # Find the meeting creation route
-        meeting_routes = [
-            r
-            for r in self.client.app.routes
-            if hasattr(r, "path") and "meeting" in r.path
-        ]
-        assert len(meeting_routes) > 0

server/uv.lock

@@ -2,13 +2,15 @@ version = 1
 revision = 3
 requires-python = ">=3.11, <3.13"
 resolution-markers = [
-    "python_full_version >= '3.12' and platform_python_implementation == 'PyPy'",
+    "python_full_version >= '3.12' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin'",
     "(python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_python_implementation != 'CPython' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')",
     "python_full_version >= '3.12' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux'",
+    "python_full_version >= '3.12' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'",
     "python_full_version >= '3.12' and platform_python_implementation != 'PyPy' and sys_platform == 'darwin'",
-    "python_full_version < '3.12' and platform_python_implementation == 'PyPy'",
+    "python_full_version < '3.12' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin'",
     "(python_full_version < '3.12' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_python_implementation != 'CPython' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')",
     "python_full_version < '3.12' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux'",
+    "python_full_version < '3.12' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'",
     "python_full_version < '3.12' and platform_python_implementation != 'PyPy' and sys_platform == 'darwin'",
 ]
 
@@ -1035,27 +1037,27 @@ wheels = [
 
 [[package]]
 name = "fonttools"
-version = "4.59.1"
+version = "4.59.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/11/7f/29c9c3fe4246f6ad96fee52b88d0dc3a863c7563b0afc959e36d78b965dc/fonttools-4.59.1.tar.gz", hash = "sha256:74995b402ad09822a4c8002438e54940d9f1ecda898d2bb057729d7da983e4cb", size = 3534394, upload-time = "2025-08-14T16:28:14.266Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0d/a5/fba25f9fbdab96e26dedcaeeba125e5f05a09043bf888e0305326e55685b/fonttools-4.59.2.tar.gz", hash = "sha256:e72c0749b06113f50bcb80332364c6be83a9582d6e3db3fe0b280f996dc2ef22", size = 3540889, upload-time = "2025-08-27T16:40:30.97Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/34/62/9667599561f623d4a523cc9eb4f66f3b94b6155464110fa9aebbf90bbec7/fonttools-4.59.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4909cce2e35706f3d18c54d3dcce0414ba5e0fb436a454dffec459c61653b513", size = 2778815, upload-time = "2025-08-14T16:26:28.484Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/78/cc25bcb2ce86033a9df243418d175e58f1956a35047c685ef553acae67d6/fonttools-4.59.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:efbec204fa9f877641747f2d9612b2b656071390d7a7ef07a9dbf0ecf9c7195c", size = 2341631, upload-time = "2025-08-14T16:26:30.396Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/cc/fcbb606dd6871f457ac32f281c20bcd6cc77d9fce77b5a4e2b2afab1f500/fonttools-4.59.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39dfd42cc2dc647b2c5469bc7a5b234d9a49e72565b96dd14ae6f11c2c59ef15", size = 5022222, upload-time = "2025-08-14T16:26:32.447Z" },
-    { url = "https://files.pythonhosted.org/packages/61/96/c0b1cf2b74d08eb616a80dbf5564351fe4686147291a25f7dce8ace51eb3/fonttools-4.59.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b11bc177a0d428b37890825d7d025040d591aa833f85f8d8878ed183354f47df", size = 4966512, upload-time = "2025-08-14T16:26:34.621Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/26/51ce2e3e0835ffc2562b1b11d1fb9dafd0aca89c9041b64a9e903790a761/fonttools-4.59.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5b9b4c35b3be45e5bc774d3fc9608bbf4f9a8d371103b858c80edbeed31dd5aa", size = 5001645, upload-time = "2025-08-14T16:26:36.876Z" },
-    { url = "https://files.pythonhosted.org/packages/36/11/ef0b23f4266349b6d5ccbd1a07b7adc998d5bce925792aa5d1ec33f593e3/fonttools-4.59.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:01158376b8a418a0bae9625c476cebfcfcb5e6761e9d243b219cd58341e7afbb", size = 5113777, upload-time = "2025-08-14T16:26:39.002Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/da/b398fe61ef433da0a0472cdb5d4399124f7581ffe1a31b6242c91477d802/fonttools-4.59.1-cp311-cp311-win32.whl", hash = "sha256:cf7c5089d37787387123f1cb8f1793a47c5e1e3d1e4e7bfbc1cc96e0f925eabe", size = 2215076, upload-time = "2025-08-14T16:26:41.196Z" },
-    { url = "https://files.pythonhosted.org/packages/94/bd/e2624d06ab94e41c7c77727b2941f1baed7edb647e63503953e6888020c9/fonttools-4.59.1-cp311-cp311-win_amd64.whl", hash = "sha256:c866eef7a0ba320486ade6c32bfc12813d1a5db8567e6904fb56d3d40acc5116", size = 2262779, upload-time = "2025-08-14T16:26:43.483Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/fe/6e069cc4cb8881d164a9bd956e9df555bc62d3eb36f6282e43440200009c/fonttools-4.59.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:43ab814bbba5f02a93a152ee61a04182bb5809bd2bc3609f7822e12c53ae2c91", size = 2769172, upload-time = "2025-08-14T16:26:45.729Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/98/ec4e03f748fefa0dd72d9d95235aff6fef16601267f4a2340f0e16b9330f/fonttools-4.59.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4f04c3ffbfa0baafcbc550657cf83657034eb63304d27b05cff1653b448ccff6", size = 2337281, upload-time = "2025-08-14T16:26:47.921Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/b1/890360a7e3d04a30ba50b267aca2783f4c1364363797e892e78a4f036076/fonttools-4.59.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:d601b153e51a5a6221f0d4ec077b6bfc6ac35bfe6c19aeaa233d8990b2b71726", size = 4909215, upload-time = "2025-08-14T16:26:49.682Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/ec/2490599550d6c9c97a44c1e36ef4de52d6acf742359eaa385735e30c05c4/fonttools-4.59.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c735e385e30278c54f43a0d056736942023c9043f84ee1021eff9fd616d17693", size = 4951958, upload-time = "2025-08-14T16:26:51.616Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/40/bd053f6f7634234a9b9805ff8ae4f32df4f2168bee23cafd1271ba9915a9/fonttools-4.59.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1017413cdc8555dce7ee23720da490282ab7ec1cf022af90a241f33f9a49afc4", size = 4894738, upload-time = "2025-08-14T16:26:53.836Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/a1/3cd12a010d288325a7cfcf298a84825f0f9c29b01dee1baba64edfe89257/fonttools-4.59.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5c6d8d773470a5107052874341ed3c487c16ecd179976d81afed89dea5cd7406", size = 5045983, upload-time = "2025-08-14T16:26:56.153Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/af/8a2c3f6619cc43cf87951405337cc8460d08a4e717bb05eaa94b335d11dc/fonttools-4.59.1-cp312-cp312-win32.whl", hash = "sha256:2a2d0d33307f6ad3a2086a95dd607c202ea8852fa9fb52af9b48811154d1428a", size = 2203407, upload-time = "2025-08-14T16:26:58.165Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/f2/a19b874ddbd3ebcf11d7e25188ef9ac3f68b9219c62263acb34aca8cde05/fonttools-4.59.1-cp312-cp312-win_amd64.whl", hash = "sha256:0b9e4fa7eaf046ed6ac470f6033d52c052481ff7a6e0a92373d14f556f298dc0", size = 2251561, upload-time = "2025-08-14T16:27:00.646Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/64/9d606e66d498917cd7a2ff24f558010d42d6fd4576d9dd57f0bd98333f5a/fonttools-4.59.1-py3-none-any.whl", hash = "sha256:647db657073672a8330608970a984d51573557f328030566521bc03415535042", size = 1130094, upload-time = "2025-08-14T16:28:12.048Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/53/742fcd750ae0bdc74de4c0ff923111199cc2f90a4ee87aaddad505b6f477/fonttools-4.59.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:511946e8d7ea5c0d6c7a53c4cb3ee48eda9ab9797cd9bf5d95829a398400354f", size = 2774961, upload-time = "2025-08-27T16:38:47.536Z" },
+    { url = "https://files.pythonhosted.org/packages/57/2a/976f5f9fa3b4dd911dc58d07358467bec20e813d933bc5d3db1a955dd456/fonttools-4.59.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8e5e2682cf7be766d84f462ba8828d01e00c8751a8e8e7ce12d7784ccb69a30d", size = 2344690, upload-time = "2025-08-27T16:38:49.723Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/8f/b7eefc274fcf370911e292e95565c8253b0b87c82a53919ab3c795a4f50e/fonttools-4.59.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5729e12a982dba3eeae650de48b06f3b9ddb51e9aee2fcaf195b7d09a96250e2", size = 5026910, upload-time = "2025-08-27T16:38:51.904Z" },
+    { url = "https://files.pythonhosted.org/packages/69/95/864726eaa8f9d4e053d0c462e64d5830ec7c599cbdf1db9e40f25ca3972e/fonttools-4.59.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c52694eae5d652361d59ecdb5a2246bff7cff13b6367a12da8499e9df56d148d", size = 4971031, upload-time = "2025-08-27T16:38:53.676Z" },
+    { url = "https://files.pythonhosted.org/packages/24/4c/b8c4735ebdea20696277c70c79e0de615dbe477834e5a7c2569aa1db4033/fonttools-4.59.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f1f1bbc23ba1312bd8959896f46f667753b90216852d2a8cfa2d07e0cb234144", size = 5006112, upload-time = "2025-08-27T16:38:55.69Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/23/f9ea29c292aa2fc1ea381b2e5621ac436d5e3e0a5dee24ffe5404e58eae8/fonttools-4.59.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1a1bfe5378962825dabe741720885e8b9ae9745ec7ecc4a5ec1f1ce59a6062bf", size = 5117671, upload-time = "2025-08-27T16:38:58.984Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/07/cfea304c555bf06e86071ff2a3916bc90f7c07ec85b23bab758d4908c33d/fonttools-4.59.2-cp311-cp311-win32.whl", hash = "sha256:e937790f3c2c18a1cbc7da101550a84319eb48023a715914477d2e7faeaba570", size = 2218157, upload-time = "2025-08-27T16:39:00.75Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/de/35d839aa69db737a3f9f3a45000ca24721834d40118652a5775d5eca8ebb/fonttools-4.59.2-cp311-cp311-win_amd64.whl", hash = "sha256:9836394e2f4ce5f9c0a7690ee93bd90aa1adc6b054f1a57b562c5d242c903104", size = 2265846, upload-time = "2025-08-27T16:39:02.453Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/3d/1f45db2df51e7bfa55492e8f23f383d372200be3a0ded4bf56a92753dd1f/fonttools-4.59.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:82906d002c349cad647a7634b004825a7335f8159d0d035ae89253b4abf6f3ea", size = 2769711, upload-time = "2025-08-27T16:39:04.423Z" },
+    { url = "https://files.pythonhosted.org/packages/29/df/cd236ab32a8abfd11558f296e064424258db5edefd1279ffdbcfd4fd8b76/fonttools-4.59.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a10c1bd7644dc58f8862d8ba0cf9fb7fef0af01ea184ba6ce3f50ab7dfe74d5a", size = 2340225, upload-time = "2025-08-27T16:39:06.143Z" },
+    { url = "https://files.pythonhosted.org/packages/98/12/b6f9f964fe6d4b4dd4406bcbd3328821c3de1f909ffc3ffa558fe72af48c/fonttools-4.59.2-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:738f31f23e0339785fd67652a94bc69ea49e413dfdb14dcb8c8ff383d249464e", size = 4912766, upload-time = "2025-08-27T16:39:08.138Z" },
+    { url = "https://files.pythonhosted.org/packages/73/78/82bde2f2d2c306ef3909b927363170b83df96171f74e0ccb47ad344563cd/fonttools-4.59.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ec99f9bdfee9cdb4a9172f9e8fd578cce5feb231f598909e0aecf5418da4f25", size = 4955178, upload-time = "2025-08-27T16:39:10.094Z" },
+    { url = "https://files.pythonhosted.org/packages/92/77/7de766afe2d31dda8ee46d7e479f35c7d48747e558961489a2d6e3a02bd4/fonttools-4.59.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0476ea74161322e08c7a982f83558a2b81b491509984523a1a540baf8611cc31", size = 4897898, upload-time = "2025-08-27T16:39:12.087Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/77/ce0e0b905d62a06415fda9f2b2e109a24a5db54a59502b769e9e297d2242/fonttools-4.59.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:95922a922daa1f77cc72611747c156cfb38030ead72436a2c551d30ecef519b9", size = 5049144, upload-time = "2025-08-27T16:39:13.84Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/ea/870d93aefd23fff2e07cbeebdc332527868422a433c64062c09d4d5e7fe6/fonttools-4.59.2-cp312-cp312-win32.whl", hash = "sha256:39ad9612c6a622726a6a130e8ab15794558591f999673f1ee7d2f3d30f6a3e1c", size = 2206473, upload-time = "2025-08-27T16:39:15.854Z" },
+    { url = "https://files.pythonhosted.org/packages/61/c4/e44bad000c4a4bb2e9ca11491d266e857df98ab6d7428441b173f0fe2517/fonttools-4.59.2-cp312-cp312-win_amd64.whl", hash = "sha256:980fd7388e461b19a881d35013fec32c713ffea1fc37aef2f77d11f332dfd7da", size = 2254706, upload-time = "2025-08-27T16:39:17.893Z" },
+    { url = "https://files.pythonhosted.org/packages/65/a4/d2f7be3c86708912c02571db0b550121caab8cd88a3c0aacb9cfa15ea66e/fonttools-4.59.2-py3-none-any.whl", hash = "sha256:8bd0f759020e87bb5d323e6283914d9bf4ae35a7307dafb2cbd1e379e720ad37", size = 1132315, upload-time = "2025-08-27T16:40:28.984Z" },
 ]
 
 [[package]]
@@ -1307,6 +1309,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/33/c9/751b6401887f4b50f9307cc1e53d287b3dc77c375c126aeb6335aff73ccb/HyperPyYAML-1.2.2-py3-none-any.whl", hash = "sha256:3c5864bdc8864b2f0fbd7bc495e7e8fdf2dfd5dd80116f72da27ca96a128bdeb", size = 16118, upload-time = "2023-09-21T14:45:25.101Z" },
 ]
 
+[[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"
@@ -1325,15 +1340,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9c/1f/19ebc343cc71a7ffa78f17018535adc5cbdd87afb31d7c34874680148b32/ifaddr-0.2.0-py3-none-any.whl", hash = "sha256:085e0305cfe6f16ab12d72e2024030f5d52674afad6911bb1eee207177b8a748", size = 12314, upload-time = "2022-06-15T21:40:25.756Z" },
 ]
 
-[[package]]
-name = "inflection"
-version = "0.5.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e1/7e/691d061b7329bc8d54edbf0ec22fbfb2afe61facb681f9aaa9bff7a27d04/inflection-0.5.1.tar.gz", hash = "sha256:1a29730d366e996aaacffb2f1f1cb9593dc38e2ddd30c91250c6dde09ea9b417", size = 15091, upload-time = "2020-08-22T08:16:29.139Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/59/91/aa6bde563e0085a02a435aa99b49ef75b0a4b062635e606dab23ce18d720/inflection-0.5.1-py2.py3-none-any.whl", hash = "sha256:f38b2b640938a4f35ade69ac3d053042959b62a0f1076a5bbaa1b9526605a8a2", size = 9454, upload-time = "2020-08-22T08:16:27.816Z" },
-]
-
 [[package]]
 name = "iniconfig"
 version = "2.1.0"
@@ -1558,7 +1564,7 @@ wheels = [
 
 [[package]]
 name = "lightning"
-version = "2.5.3"
+version = "2.5.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "fsspec", extra = ["http"] },
@@ -1572,9 +1578,9 @@ dependencies = [
     { name = "tqdm" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/01/80/dddb5a382aa0ff18045aee6491f81e40371102cb05da2ad5a8436a51c475/lightning-2.5.3.tar.gz", hash = "sha256:4ed3e12369a1e0f928beecf5c9f5efdabda60a9216057954851e2d89f1abecde", size = 636577, upload-time = "2025-08-13T20:29:32.361Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/dd/86bb3bebadcdbc6e6e5a63657f0a03f74cd065b5ea965896679f76fec0b4/lightning-2.5.5.tar.gz", hash = "sha256:4d3d66c5b1481364a7e6a1ce8ddde1777a04fa740a3145ec218a9941aed7dd30", size = 640770, upload-time = "2025-09-05T16:01:21.026Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/6b/00e9c2b03a449c21d7a4d73a7104ac94f56c37a1e6eae77b1c702d8dddf0/lightning-2.5.3-py3-none-any.whl", hash = "sha256:c551111fda0db0bce267791f9a90cd4f9cf94bc327d36348af0ef79ec752d666", size = 824181, upload-time = "2025-08-13T20:29:30.244Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/d0/4b4fbafc3b18df91207a6e46782d9fd1905f9f45cb2c3b8dfbb239aef781/lightning-2.5.5-py3-none-any.whl", hash = "sha256:69eb248beadd7b600bf48eff00a0ec8af171ec7a678d23787c4aedf12e225e8f", size = 828490, upload-time = "2025-09-05T16:01:17.845Z" },
 ]
 
 [[package]]
@@ -1874,19 +1880,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fa/24/8497595be04a8a0209536e9ce70d4132f8f8e001986f4c700414b3777758/llama_parse-0.6.43-py3-none-any.whl", hash = "sha256:fe435309638c4fdec4fec31f97c5031b743c92268962d03b99bd76704f566c32", size = 4944, upload-time = "2025-07-08T18:20:57.089Z" },
 ]
 
-[[package]]
-name = "loguru"
-version = "0.7.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-    { name = "win32-setctime", marker = "sys_platform == 'win32'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", hash = "sha256:19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6", size = 63559, upload-time = "2024-12-06T11:20:56.608Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", hash = "sha256:31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c", size = 61595, upload-time = "2024-12-06T11:20:54.538Z" },
-]
-
 [[package]]
 name = "mako"
 version = "1.3.10"
@@ -1953,7 +1946,7 @@ wheels = [
 
 [[package]]
 name = "matplotlib"
-version = "3.10.5"
+version = "3.10.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "contourpy" },
@@ -1966,25 +1959,25 @@ dependencies = [
     { name = "pyparsing" },
     { name = "python-dateutil" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/43/91/f2939bb60b7ebf12478b030e0d7f340247390f402b3b189616aad790c366/matplotlib-3.10.5.tar.gz", hash = "sha256:352ed6ccfb7998a00881692f38b4ca083c691d3e275b4145423704c34c909076", size = 34804044, upload-time = "2025-07-31T18:09:33.805Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a0/59/c3e6453a9676ffba145309a73c462bb407f4400de7de3f2b41af70720a3c/matplotlib-3.10.6.tar.gz", hash = "sha256:ec01b645840dd1996df21ee37f208cd8ba57644779fa20464010638013d3203c", size = 34804264, upload-time = "2025-08-30T00:14:25.137Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/aa/c7/1f2db90a1d43710478bb1e9b57b162852f79234d28e4f48a28cc415aa583/matplotlib-3.10.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:dcfc39c452c6a9f9028d3e44d2d721484f665304857188124b505b2c95e1eecf", size = 8239216, upload-time = "2025-07-31T18:07:51.947Z" },
-    { url = "https://files.pythonhosted.org/packages/82/6d/ca6844c77a4f89b1c9e4d481c412e1d1dbabf2aae2cbc5aa2da4a1d6683e/matplotlib-3.10.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:903352681b59f3efbf4546985142a9686ea1d616bb054b09a537a06e4b892ccf", size = 8102130, upload-time = "2025-07-31T18:07:53.65Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/1e/5e187a30cc673a3e384f3723e5f3c416033c1d8d5da414f82e4e731128ea/matplotlib-3.10.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:080c3676a56b8ee1c762bcf8fca3fe709daa1ee23e6ef06ad9f3fc17332f2d2a", size = 8666471, upload-time = "2025-07-31T18:07:55.304Z" },
-    { url = "https://files.pythonhosted.org/packages/03/c0/95540d584d7d645324db99a845ac194e915ef75011a0d5e19e1b5cee7e69/matplotlib-3.10.5-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4b4984d5064a35b6f66d2c11d668565f4389b1119cc64db7a4c1725bc11adffc", size = 9500518, upload-time = "2025-07-31T18:07:57.199Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/2e/e019352099ea58b4169adb9c6e1a2ad0c568c6377c2b677ee1f06de2adc7/matplotlib-3.10.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3967424121d3a46705c9fa9bdb0931de3228f13f73d7bb03c999c88343a89d89", size = 9552372, upload-time = "2025-07-31T18:07:59.41Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/81/3200b792a5e8b354f31f4101ad7834743ad07b6d620259f2059317b25e4d/matplotlib-3.10.5-cp311-cp311-win_amd64.whl", hash = "sha256:33775bbeb75528555a15ac29396940128ef5613cf9a2d31fb1bfd18b3c0c0903", size = 8100634, upload-time = "2025-07-31T18:08:01.801Z" },
-    { url = "https://files.pythonhosted.org/packages/52/46/a944f6f0c1f5476a0adfa501969d229ce5ae60cf9a663be0e70361381f89/matplotlib-3.10.5-cp311-cp311-win_arm64.whl", hash = "sha256:c61333a8e5e6240e73769d5826b9a31d8b22df76c0778f8480baf1b4b01c9420", size = 7978880, upload-time = "2025-07-31T18:08:03.407Z" },
-    { url = "https://files.pythonhosted.org/packages/66/1e/c6f6bcd882d589410b475ca1fc22e34e34c82adff519caf18f3e6dd9d682/matplotlib-3.10.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:00b6feadc28a08bd3c65b2894f56cf3c94fc8f7adcbc6ab4516ae1e8ed8f62e2", size = 8253056, upload-time = "2025-07-31T18:08:05.385Z" },
-    { url = "https://files.pythonhosted.org/packages/53/e6/d6f7d1b59413f233793dda14419776f5f443bcccb2dfc84b09f09fe05dbe/matplotlib-3.10.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ee98a5c5344dc7f48dc261b6ba5d9900c008fc12beb3fa6ebda81273602cc389", size = 8110131, upload-time = "2025-07-31T18:08:07.293Z" },
-    { url = "https://files.pythonhosted.org/packages/66/2b/bed8a45e74957549197a2ac2e1259671cd80b55ed9e1fe2b5c94d88a9202/matplotlib-3.10.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a17e57e33de901d221a07af32c08870ed4528db0b6059dce7d7e65c1122d4bea", size = 8669603, upload-time = "2025-07-31T18:08:09.064Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/a7/315e9435b10d057f5e52dfc603cd353167ae28bb1a4e033d41540c0067a4/matplotlib-3.10.5-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97b9d6443419085950ee4a5b1ee08c363e5c43d7176e55513479e53669e88468", size = 9508127, upload-time = "2025-07-31T18:08:10.845Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/d9/edcbb1f02ca99165365d2768d517898c22c6040187e2ae2ce7294437c413/matplotlib-3.10.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ceefe5d40807d29a66ae916c6a3915d60ef9f028ce1927b84e727be91d884369", size = 9566926, upload-time = "2025-07-31T18:08:13.186Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/d9/6dd924ad5616c97b7308e6320cf392c466237a82a2040381163b7500510a/matplotlib-3.10.5-cp312-cp312-win_amd64.whl", hash = "sha256:c04cba0f93d40e45b3c187c6c52c17f24535b27d545f757a2fffebc06c12b98b", size = 8107599, upload-time = "2025-07-31T18:08:15.116Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/f3/522dc319a50f7b0279fbe74f86f7a3506ce414bc23172098e8d2bdf21894/matplotlib-3.10.5-cp312-cp312-win_arm64.whl", hash = "sha256:a41bcb6e2c8e79dc99c5511ae6f7787d2fb52efd3d805fff06d5d4f667db16b2", size = 7978173, upload-time = "2025-07-31T18:08:21.518Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/d6/e921be4e1a5f7aca5194e1f016cb67ec294548e530013251f630713e456d/matplotlib-3.10.5-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:160e125da27a749481eaddc0627962990f6029811dbeae23881833a011a0907f", size = 8233224, upload-time = "2025-07-31T18:09:27.512Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/74/a2b9b04824b9c349c8f1b2d21d5af43fa7010039427f2b133a034cb09e59/matplotlib-3.10.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ac3d50760394d78a3c9be6b28318fe22b494c4fcf6407e8fd4794b538251899b", size = 8098539, upload-time = "2025-07-31T18:09:29.629Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/66/cd29ebc7f6c0d2a15d216fb572573e8fc38bd5d6dec3bd9d7d904c0949f7/matplotlib-3.10.5-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6c49465bf689c4d59d174d0c7795fb42a21d4244d11d70e52b8011987367ac61", size = 8672192, upload-time = "2025-07-31T18:09:31.407Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d6/5d3665aa44c49005aaacaa68ddea6fcb27345961cd538a98bb0177934ede/matplotlib-3.10.6-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:905b60d1cb0ee604ce65b297b61cf8be9f4e6cfecf95a3fe1c388b5266bc8f4f", size = 8257527, upload-time = "2025-08-30T00:12:45.31Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/af/30ddefe19ca67eebd70047dabf50f899eaff6f3c5e6a1a7edaecaf63f794/matplotlib-3.10.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7bac38d816637343e53d7185d0c66677ff30ffb131044a81898b5792c956ba76", size = 8119583, upload-time = "2025-08-30T00:12:47.236Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/29/4a8650a3dcae97fa4f375d46efcb25920d67b512186f8a6788b896062a81/matplotlib-3.10.6-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:942a8de2b5bfff1de31d95722f702e2966b8a7e31f4e68f7cd963c7cd8861cf6", size = 8692682, upload-time = "2025-08-30T00:12:48.781Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/d3/b793b9cb061cfd5d42ff0f69d1822f8d5dbc94e004618e48a97a8373179a/matplotlib-3.10.6-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a3276c85370bc0dfca051ec65c5817d1e0f8f5ce1b7787528ec8ed2d524bbc2f", size = 9521065, upload-time = "2025-08-30T00:12:50.602Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/c5/53de5629f223c1c66668d46ac2621961970d21916a4bc3862b174eb2a88f/matplotlib-3.10.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9df5851b219225731f564e4b9e7f2ac1e13c9e6481f941b5631a0f8e2d9387ce", size = 9576888, upload-time = "2025-08-30T00:12:52.92Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/8e/0a18d6d7d2d0a2e66585032a760d13662e5250c784d53ad50434e9560991/matplotlib-3.10.6-cp311-cp311-win_amd64.whl", hash = "sha256:abb5d9478625dd9c9eb51a06d39aae71eda749ae9b3138afb23eb38824026c7e", size = 8115158, upload-time = "2025-08-30T00:12:54.863Z" },
+    { url = "https://files.pythonhosted.org/packages/07/b3/1a5107bb66c261e23b9338070702597a2d374e5aa7004b7adfc754fbed02/matplotlib-3.10.6-cp311-cp311-win_arm64.whl", hash = "sha256:886f989ccfae63659183173bb3fced7fd65e9eb793c3cc21c273add368536951", size = 7992444, upload-time = "2025-08-30T00:12:57.067Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/1a/7042f7430055d567cc3257ac409fcf608599ab27459457f13772c2d9778b/matplotlib-3.10.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:31ca662df6a80bd426f871105fdd69db7543e28e73a9f2afe80de7e531eb2347", size = 8272404, upload-time = "2025-08-30T00:12:59.112Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/5d/1d5f33f5b43f4f9e69e6a5fe1fb9090936ae7bc8e2ff6158e7a76542633b/matplotlib-3.10.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1678bb61d897bb4ac4757b5ecfb02bfb3fddf7f808000fb81e09c510712fda75", size = 8128262, upload-time = "2025-08-30T00:13:01.141Z" },
+    { url = "https://files.pythonhosted.org/packages/67/c3/135fdbbbf84e0979712df58e5e22b4f257b3f5e52a3c4aacf1b8abec0d09/matplotlib-3.10.6-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:56cd2d20842f58c03d2d6e6c1f1cf5548ad6f66b91e1e48f814e4fb5abd1cb95", size = 8697008, upload-time = "2025-08-30T00:13:03.24Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/be/c443ea428fb2488a3ea7608714b1bd85a82738c45da21b447dc49e2f8e5d/matplotlib-3.10.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:662df55604a2f9a45435566d6e2660e41efe83cd94f4288dfbf1e6d1eae4b0bb", size = 9530166, upload-time = "2025-08-30T00:13:05.951Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/35/48441422b044d74034aea2a3e0d1a49023f12150ebc58f16600132b9bbaf/matplotlib-3.10.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:08f141d55148cd1fc870c3387d70ca4df16dee10e909b3b038782bd4bda6ea07", size = 9593105, upload-time = "2025-08-30T00:13:08.356Z" },
+    { url = "https://files.pythonhosted.org/packages/45/c3/994ef20eb4154ab84cc08d033834555319e4af970165e6c8894050af0b3c/matplotlib-3.10.6-cp312-cp312-win_amd64.whl", hash = "sha256:590f5925c2d650b5c9d813c5b3b5fc53f2929c3f8ef463e4ecfa7e052044fb2b", size = 8122784, upload-time = "2025-08-30T00:13:10.367Z" },
+    { url = "https://files.pythonhosted.org/packages/57/b8/5c85d9ae0e40f04e71bedb053aada5d6bab1f9b5399a0937afb5d6b02d98/matplotlib-3.10.6-cp312-cp312-win_arm64.whl", hash = "sha256:f44c8d264a71609c79a78d50349e724f5d5fc3684ead7c2a473665ee63d868aa", size = 7992823, upload-time = "2025-08-30T00:13:12.24Z" },
+    { url = "https://files.pythonhosted.org/packages/12/bb/02c35a51484aae5f49bd29f091286e7af5f3f677a9736c58a92b3c78baeb/matplotlib-3.10.6-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:f2d684c3204fa62421bbf770ddfebc6b50130f9cad65531eeba19236d73bb488", size = 8252296, upload-time = "2025-08-30T00:14:19.49Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/85/41701e3092005aee9a2445f5ee3904d9dbd4a7df7a45905ffef29b7ef098/matplotlib-3.10.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:6f4a69196e663a41d12a728fab8751177215357906436804217d6d9cf0d4d6cf", size = 8116749, upload-time = "2025-08-30T00:14:21.344Z" },
+    { url = "https://files.pythonhosted.org/packages/16/53/8d8fa0ea32a8c8239e04d022f6c059ee5e1b77517769feccd50f1df43d6d/matplotlib-3.10.6-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d6ca6ef03dfd269f4ead566ec6f3fb9becf8dab146fb999022ed85ee9f6b3eb", size = 8693933, upload-time = "2025-08-30T00:14:22.942Z" },
 ]
 
 [[package]]
@@ -2185,7 +2178,7 @@ wheels = [
 
 [[package]]
 name = "optuna"
-version = "4.4.0"
+version = "4.5.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "alembic" },
@@ -2196,9 +2189,9 @@ dependencies = [
     { name = "sqlalchemy" },
     { name = "tqdm" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a5/e0/b303190ae8032d12f320a24c42af04038bacb1f3b17ede354dd1044a5642/optuna-4.4.0.tar.gz", hash = "sha256:a9029f6a92a1d6c8494a94e45abd8057823b535c2570819072dbcdc06f1c1da4", size = 467708, upload-time = "2025-06-16T05:13:00.024Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/a3/bcd1e5500de6ec794c085a277e5b624e60b4fac1790681d7cdbde25b93a2/optuna-4.5.0.tar.gz", hash = "sha256:264844da16dad744dea295057d8bc218646129c47567d52c35a201d9f99942ba", size = 472338, upload-time = "2025-08-18T06:49:22.402Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5c/5e/068798a8c7087863e7772e9363a880ab13fe55a5a7ede8ec42fab8a1acbb/optuna-4.4.0-py3-none-any.whl", hash = "sha256:fad8d9c5d5af993ae1280d6ce140aecc031c514a44c3b639d8c8658a8b7920ea", size = 395949, upload-time = "2025-06-16T05:12:58.37Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/12/cba81286cbaf0f0c3f0473846cfd992cb240bdcea816bf2ef7de8ed0f744/optuna-4.5.0-py3-none-any.whl", hash = "sha256:5b8a783e84e448b0742501bc27195344a28d2c77bd2feef5b558544d954851b0", size = 400872, upload-time = "2025-08-18T06:49:20.697Z" },
 ]
 
 [[package]]
@@ -2311,18 +2304,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/74/c1/bb7e334135859c3a92ec399bc89293ea73f28e815e35b43929c8db6af030/primePy-1.3-py3-none-any.whl", hash = "sha256:5ed443718765be9bf7e2ff4c56cdff71b42140a15b39d054f9d99f0009e2317a", size = 4040, upload-time = "2018-05-29T17:18:17.53Z" },
 ]
 
-[[package]]
-name = "profanityfilter"
-version = "2.1.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "inflection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/8d/03/08740b5e0800f9eb9f675c149a497a3f3735e7b04e414bcce64136e7e487/profanityfilter-2.1.0.tar.gz", hash = "sha256:0ede04e92a9d7255faa52b53776518edc6586dda828aca677c74b5994dfdd9d8", size = 7910, upload-time = "2024-11-25T22:31:51.194Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/88/03/eb18f72dc6e6398e75e3762677f18ab3a773a384b18efd3ed9119844e892/profanityfilter-2.1.0-py2.py3-none-any.whl", hash = "sha256:e1bc07012760fd74512a335abb93a36877831ed26abab78bfe31bebb68f8c844", size = 7483, upload-time = "2024-11-25T22:31:50.129Z" },
-]
-
 [[package]]
 name = "prometheus-client"
 version = "0.22.1"
@@ -2706,15 +2687,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0c/7f/113b16d55e8d2dd9143628eec39b138fd6c52f72dcd11b4dae4a3845da4d/pyinstrument-5.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:88df7e3ab11604ae7cef1f576c097a08752bf8fc13c5755803bd3cd92f15aba3", size = 124314, upload-time = "2025-07-02T14:13:26.708Z" },
 ]
 
-[[package]]
-name = "pyjwt"
-version = "2.10.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e7/46/bd74733ff231675599650d3e47f361794b22ef3e3770998dda30d3b63726/pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953", size = 87785, upload-time = "2024-11-28T03:43:29.933Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/61/ad/689f02752eeec26aed679477e80e632ef1b682313be70793d798c1d5fc8f/PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb", size = 22997, upload-time = "2024-11-28T03:43:27.893Z" },
-]
-
 [[package]]
 name = "pylibsrtp"
 version = "0.12.0"
@@ -2967,7 +2939,7 @@ wheels = [
 
 [[package]]
 name = "pytorch-lightning"
-version = "2.5.3"
+version = "2.5.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "fsspec", extra = ["http"] },
@@ -2980,14 +2952,14 @@ dependencies = [
     { name = "tqdm" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/32/a8/31fe79bf96dab33cee5537ed6f08230ed6f032834bb4ff529cc487fb40e8/pytorch_lightning-2.5.3.tar.gz", hash = "sha256:65f4eee774ee1adba181aacacffb9f677fe5c5f9fd3d01a95f603403f940be6a", size = 639897, upload-time = "2025-08-13T20:29:39.161Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/16/78/bce84aab9a5b3b2e9d087d4f1a6be9b481adbfaac4903bc9daaaf09d49a3/pytorch_lightning-2.5.5.tar.gz", hash = "sha256:d6fc8173d1d6e49abfd16855ea05d2eb2415e68593f33d43e59028ecb4e64087", size = 643703, upload-time = "2025-09-05T16:01:18.313Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6a/a2/5f2b7b40ec5213db5282e98dd32fd419fe5b73b5b53895dfff56fe12fed0/pytorch_lightning-2.5.3-py3-none-any.whl", hash = "sha256:7476bd36282d9253dda175b9263b07942489d70ad90bbd1bc0a59c46e012f353", size = 828186, upload-time = "2025-08-13T20:29:37.41Z" },
+    { url = "https://files.pythonhosted.org/packages/04/f6/99a5c66478f469598dee25b0e29b302b5bddd4e03ed0da79608ac964056e/pytorch_lightning-2.5.5-py3-none-any.whl", hash = "sha256:0b533991df2353c0c6ea9ca10a7d0728b73631fd61f5a15511b19bee2aef8af0", size = 832431, upload-time = "2025-09-05T16:01:16.234Z" },
 ]
 
 [[package]]
 name = "pytorch-metric-learning"
-version = "2.8.1"
+version = "2.9.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "numpy" },
@@ -2996,9 +2968,9 @@ dependencies = [
     { name = "torch", version = "2.8.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "platform_python_implementation == 'PyPy' or sys_platform != 'darwin'" },
     { name = "tqdm" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/78/94/1bfb2c3eaf195b2d72912b65b3d417f2d9ac22491563eca360d453512c59/pytorch-metric-learning-2.8.1.tar.gz", hash = "sha256:fcc4d3b4a805e5fce25fb2e67505c47ba6fea0563fc09c5655ea1f08d1e8ed93", size = 83117, upload-time = "2024-12-11T19:21:15.982Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9b/80/6e61b1a91debf4c1b47d441f9a9d7fe2aabcdd9575ed70b2811474eb95c3/pytorch-metric-learning-2.9.0.tar.gz", hash = "sha256:27a626caf5e2876a0fd666605a78cb67ef7597e25d7a68c18053dd503830701f", size = 84530, upload-time = "2025-08-17T17:11:19.501Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/60/15/eee4e24c3f5a63b3e73692ff79766a66cab8844e24f5912be29350937592/pytorch_metric_learning-2.8.1-py3-none-any.whl", hash = "sha256:aba6da0508d29ee9661a67fbfee911cdf62e65fc07e404b167d82871ca7e3e88", size = 125923, upload-time = "2024-12-11T19:21:13.448Z" },
+    { url = "https://files.pythonhosted.org/packages/46/7d/73ef5052f57b7720cad00e16598db3592a5ef4826745ffca67a2f085d4dc/pytorch_metric_learning-2.9.0-py3-none-any.whl", hash = "sha256:d51646006dc87168f00cf954785db133a4c5aac81253877248737aa42ef6432a", size = 127801, upload-time = "2025-08-17T17:11:18.185Z" },
 ]
 
 [[package]]
@@ -3134,18 +3106,16 @@ dependencies = [
     { name = "fastapi", extra = ["standard"] },
     { name = "fastapi-pagination" },
     { name = "httpx" },
+    { name = "icalendar" },
     { name = "jsonschema" },
     { name = "llama-index" },
     { name = "llama-index-llms-openai-like" },
-    { name = "loguru" },
     { name = "nltk" },
     { name = "openai" },
-    { name = "profanityfilter" },
     { name = "prometheus-fastapi-instrumentator" },
     { name = "protobuf" },
     { name = "psycopg2-binary" },
     { name = "pydantic-settings" },
-    { name = "pyjwt" },
     { name = "pytest-env" },
     { name = "python-jose", extra = ["cryptography"] },
     { name = "python-multipart" },
@@ -3212,18 +3182,16 @@ requires-dist = [
     { name = "fastapi", extras = ["standard"], specifier = ">=0.100.1" },
     { name = "fastapi-pagination", specifier = ">=0.12.6" },
     { 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" },
-    { name = "loguru", specifier = ">=0.7.0" },
     { name = "nltk", specifier = ">=3.8.1" },
     { name = "openai", specifier = ">=1.59.7" },
-    { name = "profanityfilter", specifier = ">=2.0.6" },
     { name = "prometheus-fastapi-instrumentator", specifier = ">=6.1.0" },
     { name = "protobuf", specifier = ">=4.24.3" },
     { name = "psycopg2-binary", specifier = ">=2.9.10" },
     { name = "pydantic-settings", specifier = ">=2.0.2" },
-    { name = "pyjwt", specifier = ">=2.8.0" },
     { name = "pytest-env", specifier = ">=1.1.5" },
     { name = "python-jose", extras = ["cryptography"], specifier = ">=3.3.0" },
     { name = "python-multipart", specifier = ">=0.0.6" },
@@ -3461,14 +3429,14 @@ wheels = [
 
 [[package]]
 name = "ruamel-yaml"
-version = "0.18.14"
+version = "0.18.15"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "ruamel-yaml-clib", marker = "platform_python_implementation == 'CPython'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/39/87/6da0df742a4684263261c253f00edd5829e6aca970fff69e75028cccc547/ruamel.yaml-0.18.14.tar.gz", hash = "sha256:7227b76aaec364df15936730efbf7d72b30c0b79b1d578bbb8e3dcb2d81f52b7", size = 145511, upload-time = "2025-06-09T08:51:09.828Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3e/db/f3950f5e5031b618aae9f423a39bf81a55c148aecd15a34527898e752cf4/ruamel.yaml-0.18.15.tar.gz", hash = "sha256:dbfca74b018c4c3fba0b9cc9ee33e53c371194a9000e694995e620490fd40700", size = 146865, upload-time = "2025-08-19T11:15:10.694Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/af/6d/6fe4805235e193aad4aaf979160dd1f3c487c57d48b810c816e6e842171b/ruamel.yaml-0.18.14-py3-none-any.whl", hash = "sha256:710ff198bb53da66718c7db27eec4fbcc9aa6ca7204e4c1df2f282b6fe5eb6b2", size = 118570, upload-time = "2025-06-09T08:51:06.348Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/e5/f2a0621f1781b76a38194acae72f01e37b1941470407345b6e8653ad7640/ruamel.yaml-0.18.15-py3-none-any.whl", hash = "sha256:148f6488d698b7a5eded5ea793a025308b25eca97208181b6a026037f391f701", size = 119702, upload-time = "2025-08-19T11:15:07.696Z" },
 ]
 
 [[package]]
@@ -3655,7 +3623,7 @@ wheels = [
 
 [[package]]
 name = "silero-vad"
-version = "5.1.2"
+version = "6.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "onnxruntime" },
@@ -3664,9 +3632,9 @@ dependencies = [
     { name = "torchaudio", version = "2.8.0", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (platform_python_implementation != 'PyPy' and sys_platform == 'darwin')" },
     { name = "torchaudio", version = "2.8.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (platform_python_implementation == 'PyPy' and sys_platform == 'darwin') or (platform_python_implementation != 'CPython' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux')" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/b4/d0311b2e6220a11f8f4699f4a278cb088131573286cdfe804c87c7eb5123/silero_vad-5.1.2.tar.gz", hash = "sha256:c442971160026d2d7aa0ad83f0c7ee86c89797a65289fe625c8ea59fc6fb828d", size = 5098526, upload-time = "2024-10-09T09:50:47.019Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/79/ff5b13ca491a2eef2a43cd989ac9a87fa2131c246d467d909f2568c56955/silero_vad-6.0.0.tar.gz", hash = "sha256:4d202cb662112d9cba0e3fbc9f2c67e2e265c853f319adf20e348d108c797b76", size = 14567206, upload-time = "2025-08-26T07:10:02.571Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/98/f7/5ae11d13fbb733cd3bfd7ff1c3a3902e6f55437df4b72307c1f168146268/silero_vad-5.1.2-py3-none-any.whl", hash = "sha256:93b41953d7774b165407fda6b533c119c5803864e367d5034dc626c82cfdf661", size = 5026737, upload-time = "2024-10-09T09:50:44.355Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/6a/a0a024878a1933a2326c42a3ce24fff6c0bf4882655f156c960ba50c2ed4/silero_vad-6.0.0-py3-none-any.whl", hash = "sha256:37d29be8944d2a2e6f1cc38a066076f13e78e6fc1b567a1beddcca72096f077f", size = 6119146, upload-time = "2025-08-26T07:10:00.637Z" },
 ]
 
 [[package]]
@@ -3974,12 +3942,14 @@ name = "torch"
 version = "2.8.0+cpu"
 source = { registry = "https://download.pytorch.org/whl/cpu" }
 resolution-markers = [
-    "python_full_version >= '3.12' and platform_python_implementation == 'PyPy'",
+    "python_full_version >= '3.12' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin'",
     "(python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_python_implementation != 'CPython' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')",
     "python_full_version >= '3.12' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux'",
-    "python_full_version < '3.12' and platform_python_implementation == 'PyPy'",
+    "python_full_version >= '3.12' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'",
+    "python_full_version < '3.12' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin'",
     "(python_full_version < '3.12' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_python_implementation != 'CPython' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')",
     "python_full_version < '3.12' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux'",
+    "python_full_version < '3.12' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'",
 ]
 dependencies = [
     { name = "filelock", marker = "platform_python_implementation == 'PyPy' or sys_platform != 'darwin'" },
@@ -4063,10 +4033,12 @@ name = "torchaudio"
 version = "2.8.0+cpu"
 source = { registry = "https://download.pytorch.org/whl/cpu" }
 resolution-markers = [
-    "python_full_version >= '3.12' and platform_python_implementation == 'PyPy'",
+    "python_full_version >= '3.12' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin'",
     "(python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_python_implementation != 'CPython' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')",
-    "python_full_version < '3.12' and platform_python_implementation == 'PyPy'",
+    "python_full_version >= '3.12' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'",
+    "python_full_version < '3.12' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin'",
     "(python_full_version < '3.12' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_python_implementation != 'CPython' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')",
+    "python_full_version < '3.12' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'",
 ]
 dependencies = [
     { name = "torch", version = "2.8.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (platform_python_implementation == 'PyPy' and sys_platform == 'darwin') or (platform_python_implementation != 'CPython' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux')" },
@@ -4080,7 +4052,7 @@ wheels = [
 
 [[package]]
 name = "torchmetrics"
-version = "1.8.1"
+version = "1.8.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "lightning-utilities" },
@@ -4089,9 +4061,9 @@ dependencies = [
     { name = "torch", version = "2.8.0", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "platform_python_implementation != 'PyPy' and sys_platform == 'darwin'" },
     { name = "torch", version = "2.8.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "platform_python_implementation == 'PyPy' or sys_platform != 'darwin'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/78/1f/2cd9eb8f3390c3ec4693ac0871913d4b468964b3833638e4091a70817e0a/torchmetrics-1.8.1.tar.gz", hash = "sha256:04ca021105871637c5d34d0a286b3ab665a1e3d2b395e561f14188a96e862fdb", size = 580373, upload-time = "2025-08-07T20:44:44.631Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/85/2e/48a887a59ecc4a10ce9e8b35b3e3c5cef29d902c4eac143378526e7485cb/torchmetrics-1.8.2.tar.gz", hash = "sha256:cf64a901036bf107f17a524009eea7781c9c5315d130713aeca5747a686fe7a5", size = 580679, upload-time = "2025-09-03T14:00:54.077Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8f/59/5c1c1cb08c494621901cf549a543f87143019fac1e6dd191eb4630bbc8fb/torchmetrics-1.8.1-py3-none-any.whl", hash = "sha256:2437501351e0da3d294c71210ce8139b9c762b5e20604f7a051a725443db8f4b", size = 982961, upload-time = "2025-08-07T20:44:42.608Z" },
+    { url = "https://files.pythonhosted.org/packages/02/21/aa0f434434c48490f91b65962b1ce863fdcce63febc166ca9fe9d706c2b6/torchmetrics-1.8.2-py3-none-any.whl", hash = "sha256:08382fd96b923e39e904c4d570f3d49e2cc71ccabd2a94e0f895d1f0dac86242", size = 983161, upload-time = "2025-09-03T14:00:51.921Z" },
 ]
 
 [[package]]
@@ -4243,8 +4215,10 @@ name = "vcrpy"
 version = "5.1.0"
 source = { registry = "https://pypi.org/simple" }
 resolution-markers = [
-    "python_full_version >= '3.12' and platform_python_implementation == 'PyPy'",
-    "python_full_version < '3.12' and platform_python_implementation == 'PyPy'",
+    "python_full_version >= '3.12' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin'",
+    "python_full_version >= '3.12' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'",
+    "python_full_version < '3.12' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin'",
+    "python_full_version < '3.12' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'",
 ]
 dependencies = [
     { name = "pyyaml", marker = "platform_python_implementation == 'PyPy'" },
@@ -4378,15 +4352,6 @@ 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"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b3/8f/705086c9d734d3b663af0e9bb3d4de6578d08f46b1b101c2442fd9aecaa2/win32_setctime-1.2.0.tar.gz", hash = "sha256:ae1fdf948f5640aae05c511ade119313fb6a30d7eabe25fef9764dca5873c4c0", size = 4867, upload-time = "2024-12-07T15:28:28.314Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e1/07/c6fe3ad3e685340704d314d765b7912993bcb8dc198f0e7a89382d37974b/win32_setctime-1.2.0-py3-none-any.whl", hash = "sha256:95d644c4e708aba81dc3704a116d8cbc974d70b3bdb8be1d150e36be6e9d1390", size = 4083, upload-time = "2024-12-07T15:28:26.465Z" },
-]
-
 [[package]]
 name = "wrapt"
 version = "1.17.2"

www/.env.template

@@ -1,46 +0,0 @@
-# NextAuth configuration
-NEXTAUTH_SECRET="your-secret-key"
-NEXTAUTH_URL="http://localhost:3000/"
-
-# API configuration
-NEXT_PUBLIC_API_URL="http://127.0.0.1:1250"
-NEXT_PUBLIC_WEBSOCKET_URL="ws://127.0.0.1:1250"
-NEXT_PUBLIC_AUTH_CALLBACK_URL="http://localhost:3000/auth-callback"
-NEXT_PUBLIC_SITE_URL="http://localhost:3000/"
-
-# Environment
-NEXT_PUBLIC_ENV="development"
-ENVIRONMENT="development"
-
-# Video Platform Configuration
-# Options: "whereby" | "jitsi" (default: whereby)
-NEXT_PUBLIC_VIDEO_PLATFORM="whereby"
-
-# Features
-NEXT_PUBLIC_PROJECTOR_MODE="false"
-
-# Authentication providers (optional)
-# Authentik
-AUTHENTIK_CLIENT_ID=""
-AUTHENTIK_CLIENT_SECRET=""
-AUTHENTIK_ISSUER=""
-AUTHENTIK_REFRESH_TOKEN_URL=""
-
-# Fief
-FIEF_CLIENT_ID=""
-FIEF_CLIENT_SECRET=""
-FIEF_URL=""
-
-# Zulip integration (optional)
-ZULIP_API_KEY=""
-ZULIP_BOT_EMAIL=""
-ZULIP_REALM=""
-
-# External services (optional)
-ZEPHYR_LLM_URL=""
-
-# Redis/KV (optional)
-KV_REST_API_TOKEN=""
-KV_REST_API_READ_ONLY_TOKEN=""
-KV_REST_API_URL=""
-KV_URL=""

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

@@ -0,0 +1,345 @@
+import {
+  VStack,
+  HStack,
+  Field,
+  Input,
+  Select,
+  Checkbox,
+  Button,
+  Text,
+  Badge,
+  createListCollection,
+  Spinner,
+  Box,
+  IconButton,
+} from "@chakra-ui/react";
+import { useState, useEffect, useRef } from "react";
+import { LuRefreshCw, LuCopy, LuCheck } from "react-icons/lu";
+import { FaCheckCircle, FaExclamationCircle } from "react-icons/fa";
+import { useRoomIcsSync, useRoomIcsStatus } from "../../../lib/apiHooks";
+import { toaster } from "../../../components/ui/toaster";
+import { roomAbsoluteUrl } from "../../../lib/routesClient";
+import {
+  assertExists,
+  assertExistsAndNonEmptyString,
+  NonEmptyString,
+  parseNonEmptyString,
+} from "../../../lib/utils";
+
+interface ICSSettingsProps {
+  roomName: NonEmptyString | null;
+  icsUrl?: string;
+  icsEnabled?: boolean;
+  icsFetchInterval?: number;
+  icsLastSync?: string;
+  icsLastEtag?: string;
+  onChange: (settings: Partial<ICSSettingsData>) => void;
+  isOwner?: boolean;
+  isEditing?: 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({
+  roomName,
+  icsUrl = "",
+  icsEnabled = false,
+  icsFetchInterval = 5,
+  icsLastSync,
+  icsLastEtag,
+  onChange,
+  isOwner = true,
+  isEditing = false,
+}: ICSSettingsProps) {
+  const [syncStatus, setSyncStatus] = useState<
+    "idle" | "syncing" | "success" | "error"
+  >("idle");
+  const [syncMessage, setSyncMessage] = useState<string>("");
+  const [syncResult, setSyncResult] = useState<{
+    eventsFound: number;
+    totalEvents: number;
+    eventsCreated: number;
+    eventsUpdated: number;
+  } | null>(null);
+  const [justCopied, setJustCopied] = useState(false);
+  const roomUrlInputRef = useRef<HTMLInputElement>(null);
+
+  const syncMutation = useRoomIcsSync();
+
+  const fetchIntervalCollection = createListCollection({
+    items: fetchIntervalOptions,
+  });
+
+  const handleCopyRoomUrl = async () => {
+    try {
+      await navigator.clipboard.writeText(
+        roomAbsoluteUrl(assertExists(roomName)),
+      );
+      setJustCopied(true);
+
+      toaster
+        .create({
+          placement: "top",
+          duration: 3000,
+          render: ({ dismiss }) => (
+            <Box
+              bg="green.500"
+              color="white"
+              px={4}
+              py={3}
+              borderRadius="md"
+              display="flex"
+              alignItems="center"
+              gap={2}
+              boxShadow="lg"
+            >
+              <LuCheck />
+              <Text>Room URL copied to clipboard!</Text>
+            </Box>
+          ),
+        })
+        .then(() => {});
+
+      setTimeout(() => {
+        setJustCopied(false);
+      }, 2000);
+    } catch (err) {
+      console.error("Failed to copy room url:", err);
+    }
+  };
+
+  const handleRoomUrlClick = () => {
+    if (roomUrlInputRef.current) {
+      roomUrlInputRef.current.select();
+      handleCopyRoomUrl().then(() => {});
+    }
+  };
+
+  // Clear sync results when dialog closes
+  useEffect(() => {
+    if (!isEditing) {
+      setSyncStatus("idle");
+      setSyncResult(null);
+      setSyncMessage("");
+    }
+  }, [isEditing]);
+
+  const handleForceSync = async () => {
+    if (!roomName || !isEditing) return;
+
+    // Clear previous results
+    setSyncStatus("syncing");
+    setSyncResult(null);
+    setSyncMessage("");
+
+    try {
+      const result = await syncMutation.mutateAsync({
+        params: {
+          path: { room_name: roomName },
+        },
+      });
+
+      if (result.status === "success" || result.status === "unchanged") {
+        setSyncStatus("success");
+        setSyncResult({
+          eventsFound: result.events_found || 0,
+          totalEvents: result.total_events || 0,
+          eventsCreated: result.events_created || 0,
+          eventsUpdated: result.events_updated || 0,
+        });
+      } else {
+        setSyncStatus("error");
+        setSyncMessage(result.error || "Sync failed");
+      }
+    } catch (err: any) {
+      setSyncStatus("error");
+      setSyncMessage(err.body?.detail || "Failed to force sync calendar");
+    }
+  };
+
+  if (!isOwner) {
+    return null; // ICS settings only visible to room owner
+  }
+
+  return (
+    <VStack gap={4} align="stretch">
+      <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>Room URL</Field.Label>
+            <Field.HelperText>
+              To enable Reflector to recognize your calendar events as meetings,
+              add this URL as the location in your calendar events
+            </Field.HelperText>
+            {roomName ? (
+              <HStack gap={0} position="relative" width="100%">
+                <Input
+                  ref={roomUrlInputRef}
+                  value={roomAbsoluteUrl(parseNonEmptyString(roomName))}
+                  readOnly
+                  onClick={handleRoomUrlClick}
+                  cursor="pointer"
+                  bg="gray.100"
+                  _hover={{ bg: "gray.200" }}
+                  _focus={{ bg: "gray.200" }}
+                  pr="90px"
+                  width="100%"
+                />
+                <HStack position="absolute" right="4px" gap={1} zIndex={1}>
+                  <IconButton
+                    aria-label="Copy room URL"
+                    onClick={handleCopyRoomUrl}
+                    variant="ghost"
+                    size="sm"
+                  >
+                    {justCopied ? <LuCheck /> : <LuCopy />}
+                  </IconButton>
+                </HStack>
+              </HStack>
+            ) : null}
+          </Field.Root>
+
+          <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 && isEditing && roomName && (
+            <HStack gap={3}>
+              <Button
+                size="sm"
+                variant="outline"
+                onClick={handleForceSync}
+                disabled={syncStatus === "syncing"}
+              >
+                {syncStatus === "syncing" ? (
+                  <Spinner size="sm" />
+                ) : (
+                  <LuRefreshCw />
+                )}
+                Force Sync
+              </Button>
+            </HStack>
+          )}
+
+          {syncResult && syncStatus === "success" && (
+            <Box
+              p={3}
+              borderRadius="md"
+              bg="green.50"
+              borderLeft="4px solid"
+              borderColor="green.400"
+            >
+              <VStack gap={1} align="stretch">
+                <Text fontSize="sm" color="green.800" fontWeight="medium">
+                  Sync completed
+                </Text>
+                <Text fontSize="sm" color="green.700">
+                  {syncResult.totalEvents} events downloaded,{" "}
+                  {syncResult.eventsFound} match this room
+                </Text>
+                {(syncResult.eventsCreated > 0 ||
+                  syncResult.eventsUpdated > 0) && (
+                  <Text fontSize="sm" color="green.700">
+                    {syncResult.eventsCreated} created,{" "}
+                    {syncResult.eventsUpdated} updated
+                  </Text>
+                )}
+              </VStack>
+            </Box>
+          )}
+
+          {syncMessage && (
+            <Box
+              p={3}
+              borderRadius="md"
+              bg={syncStatus === "success" ? "green.50" : "red.50"}
+              borderLeft="4px solid"
+              borderColor={syncStatus === "success" ? "green.400" : "red.400"}
+            >
+              <Text
+                fontSize="sm"
+                color={syncStatus === "success" ? "green.800" : "red.800"}
+              >
+                {syncMessage}
+              </Text>
+            </Box>
+          )}
+
+          {icsLastSync && (
+            <HStack gap={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/_components/RoomCards.tsx

@@ -10,17 +10,12 @@ import {
   Text,
   VStack,
   HStack,
-  Badge,
 } from "@chakra-ui/react";
 import { LuLink } from "react-icons/lu";
 import type { components } from "../../../reflector-api";
 
 type Room = components["schemas"]["Room"];
 import { RoomActionsMenu } from "./RoomActionsMenu";
-import {
-  getPlatformDisplayName,
-  getPlatformColor,
-} from "../../../lib/videoPlatforms";
 
 interface RoomCardsProps {
   rooms: Room[];
@@ -100,15 +95,6 @@ export function RoomCards({
                 />
               </Flex>
               <VStack align="start" fontSize="sm" gap={0}>
-                <HStack gap={2}>
-                  <Text fontWeight="500">Platform:</Text>
-                  <Badge
-                    colorPalette={getPlatformColor(room.platform)}
-                    size="sm"
-                  >
-                    {getPlatformDisplayName(room.platform)}
-                  </Badge>
-                </HStack>
                 {room.zulip_auto_post && (
                   <HStack gap={2}>
                     <Text fontWeight="500">Zulip:</Text>

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

@@ -4,12 +4,13 @@ import type { components } from "../../../reflector-api";
 type Room = components["schemas"]["Room"];
 import { RoomTable } from "./RoomTable";
 import { RoomCards } from "./RoomCards";
+import { NonEmptyString } from "../../../lib/utils";
 
 interface RoomListProps {
   title: string;
   rooms: Room[];
   linkCopied: string;
-  onCopyUrl: (roomName: string) => void;
+  onCopyUrl: (roomName: NonEmptyString) => void;
   onEdit: (roomId: string, roomData: any) => void;
   onDelete: (roomId: string) => void;
   emptyMessage?: string;

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

@@ -1,4 +1,4 @@
-import React from "react";
+import React, { useState } from "react";
 import {
   Box,
   Table,
@@ -8,21 +8,57 @@ import {
   Text,
   Spinner,
   Badge,
+  VStack,
+  Icon,
 } from "@chakra-ui/react";
-import { LuLink } from "react-icons/lu";
+import { LuLink, LuRefreshCw } from "react-icons/lu";
+import { FaCalendarAlt } from "react-icons/fa";
 import type { components } from "../../../reflector-api";
+import {
+  useRoomActiveMeetings,
+  useRoomUpcomingMeetings,
+  useRoomIcsSync,
+} from "../../../lib/apiHooks";
 
 type Room = components["schemas"]["Room"];
+type Meeting = components["schemas"]["Meeting"];
+type CalendarEventResponse = components["schemas"]["CalendarEventResponse"];
 import { RoomActionsMenu } from "./RoomActionsMenu";
-import {
-  getPlatformDisplayName,
-  getPlatformColor,
-} from "../../../lib/videoPlatforms";
+import { MEETING_DEFAULT_TIME_MINUTES } from "../../../[roomName]/[meetingId]/constants";
+import { NonEmptyString, parseNonEmptyString } from "../../../lib/utils";
+
+// Custom icon component that combines calendar and refresh icons
+const CalendarSyncIcon = () => (
+  <Box position="relative" display="inline-block" w="20px" h="20px">
+    <Icon
+      as={FaCalendarAlt}
+      position="absolute"
+      top={0}
+      left={0}
+      boxSize="20px"
+    />
+    <Box
+      position="absolute"
+      bottom="-2px"
+      right="-2px"
+      bg="white"
+      borderRadius="full"
+      p="1px"
+      display="flex"
+      alignItems="center"
+      justifyContent="center"
+      w="12px"
+      h="12px"
+    >
+      <Icon as={LuRefreshCw} boxSize="10px" color="gray.700" />
+    </Box>
+  </Box>
+);
 
 interface RoomTableProps {
   rooms: Room[];
   linkCopied: string;
-  onCopyUrl: (roomName: string) => void;
+  onCopyUrl: (roomName: NonEmptyString) => void;
   onEdit: (roomId: string, roomData: any) => void;
   onDelete: (roomId: string) => void;
   loading?: boolean;
@@ -68,6 +104,71 @@ const getZulipDisplay = (
   return "Enabled";
 };
 
+function MeetingStatus({ roomName }: { roomName: string }) {
+  const activeMeetingsQuery = useRoomActiveMeetings(roomName);
+  const upcomingMeetingsQuery = useRoomUpcomingMeetings(roomName);
+
+  const activeMeetings = activeMeetingsQuery.data || [];
+  const upcomingMeetings = upcomingMeetingsQuery.data || [];
+
+  if (activeMeetingsQuery.isLoading || upcomingMeetingsQuery.isLoading) {
+    return <Spinner size="sm" />;
+  }
+
+  if (activeMeetings.length > 0) {
+    const meeting = activeMeetings[0];
+    const title = String(
+      meeting.calendar_metadata?.["title"] || "Active Meeting",
+    );
+    return (
+      <VStack gap={1} alignItems="start">
+        <Text fontSize="xs" color="gray.600" lineHeight={1}>
+          {title}
+        </Text>
+        <Text fontSize="xs" color="gray.500" lineHeight={1}>
+          {meeting.num_clients} participants
+        </Text>
+      </VStack>
+    );
+  }
+
+  if (upcomingMeetings.length > 0) {
+    const event = upcomingMeetings[0];
+    const startTime = new Date(event.start_time);
+    const now = new Date();
+    const diffMinutes = Math.floor(
+      (startTime.getTime() - now.getTime()) / 60000,
+    );
+
+    return (
+      <VStack gap={1} alignItems="start">
+        <Badge colorScheme="orange" size="sm">
+          {diffMinutes < MEETING_DEFAULT_TIME_MINUTES
+            ? `In ${diffMinutes}m`
+            : "Upcoming"}
+        </Badge>
+        <Text fontSize="xs" color="gray.600" lineHeight={1}>
+          {event.title || "Scheduled Meeting"}
+        </Text>
+        <Text fontSize="xs" color="gray.500" lineHeight={1}>
+          {startTime.toLocaleTimeString("en-US", {
+            hour: "2-digit",
+            minute: "2-digit",
+            month: "short",
+            day: "numeric",
+          })}
+        </Text>
+      </VStack>
+    );
+  }
+
+  return (
+    <Text fontSize="xs" color="gray.500">
+      No meetings
+    </Text>
+  );
+}
+
 export function RoomTable({
   rooms,
   linkCopied,
@@ -76,6 +177,30 @@ export function RoomTable({
   onDelete,
   loading,
 }: RoomTableProps) {
+  const [syncingRooms, setSyncingRooms] = useState<Set<NonEmptyString>>(
+    new Set(),
+  );
+  const syncMutation = useRoomIcsSync();
+
+  const handleForceSync = async (roomName: NonEmptyString) => {
+    setSyncingRooms((prev) => new Set(prev).add(roomName));
+    try {
+      await syncMutation.mutateAsync({
+        params: {
+          path: { room_name: roomName },
+        },
+      });
+    } catch (err) {
+      console.error("Failed to sync calendar:", err);
+    } finally {
+      setSyncingRooms((prev) => {
+        const next = new Set(prev);
+        next.delete(roomName);
+        return next;
+      });
+    }
+  };
+
   return (
     <Box display={{ base: "none", lg: "block" }} position="relative">
       {loading && (
@@ -99,19 +224,19 @@ export function RoomTable({
         <Table.Root>
           <Table.Header>
             <Table.Row>
-              <Table.ColumnHeader width="200px" fontWeight="600">
+              <Table.ColumnHeader width="250px" fontWeight="600">
                 Room Name
               </Table.ColumnHeader>
-              <Table.ColumnHeader width="120px" fontWeight="600">
-                Platform
+              <Table.ColumnHeader width="200px" fontWeight="600">
+                Current Meeting
               </Table.ColumnHeader>
               <Table.ColumnHeader width="200px" fontWeight="600">
                 Zulip
               </Table.ColumnHeader>
-              <Table.ColumnHeader width="130px" fontWeight="600">
+              <Table.ColumnHeader width="120px" fontWeight="600">
                 Room Size
               </Table.ColumnHeader>
-              <Table.ColumnHeader width="180px" fontWeight="600">
+              <Table.ColumnHeader width="150px" fontWeight="600">
                 Recording
               </Table.ColumnHeader>
               <Table.ColumnHeader
@@ -127,12 +252,7 @@ export function RoomTable({
                   <Link href={`/${room.name}`}>{room.name}</Link>
                 </Table.Cell>
                 <Table.Cell>
-                  <Badge
-                    colorPalette={getPlatformColor(room.platform)}
-                    size="sm"
-                  >
-                    {getPlatformDisplayName(room.platform)}
-                  </Badge>
+                  <MeetingStatus roomName={room.name} />
                 </Table.Cell>
                 <Table.Cell>
                   {getZulipDisplay(
@@ -149,7 +269,26 @@ export function RoomTable({
                   )}
                 </Table.Cell>
                 <Table.Cell>
-                  <Flex alignItems="center" gap={2}>
+                  <Flex alignItems="center" gap={2} justifyContent="flex-end">
+                    {room.ics_enabled && (
+                      <IconButton
+                        aria-label="Force sync calendar"
+                        onClick={() =>
+                          handleForceSync(parseNonEmptyString(room.name))
+                        }
+                        size="sm"
+                        variant="ghost"
+                        disabled={syncingRooms.has(
+                          parseNonEmptyString(room.name),
+                        )}
+                      >
+                        {syncingRooms.has(parseNonEmptyString(room.name)) ? (
+                          <Spinner size="sm" />
+                        ) : (
+                          <CalendarSyncIcon />
+                        )}
+                      </IconButton>
+                    )}
                     {linkCopied === room.name ? (
                       <Text color="green.500" fontSize="sm">
                         Copied!
@@ -157,7 +296,9 @@ export function RoomTable({
                     ) : (
                       <IconButton
                         aria-label="Copy URL"
-                        onClick={() => onCopyUrl(room.name)}
+                        onClick={() =>
+                          onCopyUrl(parseNonEmptyString(room.name))
+                        }
                         size="sm"
                         variant="ghost"
                       >

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

@@ -14,6 +14,7 @@ import {
   IconButton,
   createListCollection,
   useDisclosure,
+  Tabs,
 } from "@chakra-ui/react";
 import { useEffect, useMemo, useState } from "react";
 import { LuEye, LuEyeOff } from "react-icons/lu";
@@ -30,7 +31,13 @@ import {
 } from "../../lib/apiHooks";
 import { RoomList } from "./_components/RoomList";
 import { PaginationPage } from "../browse/_components/Pagination";
-import { assertExists } from "../../lib/utils";
+import {
+  assertExists,
+  NonEmptyString,
+  parseNonEmptyString,
+} from "../../lib/utils";
+import ICSSettings from "./_components/ICSSettings";
+import { roomAbsoluteUrl } from "../../lib/routesClient";
 
 type Room = components["schemas"]["Room"];
 
@@ -40,6 +47,8 @@ interface SelectOption {
 }
 
 const RESERVED_PATHS = ["browse", "rooms", "transcripts"];
+const SUCCESS_EMOJI = "✅";
+const ERROR_EMOJI = "❌";
 
 const roomModeOptions: SelectOption[] = [
   { label: "2-4 people", value: "normal" },
@@ -70,6 +79,9 @@ const roomInitialState = {
   isShared: false,
   webhookUrl: "",
   webhookSecret: "",
+  icsUrl: "",
+  icsEnabled: false,
+  icsFetchInterval: 5,
 };
 
 export default function RoomsList() {
@@ -137,6 +149,9 @@ export default function RoomsList() {
             isShared: detailedEditedRoom.is_shared,
             webhookUrl: detailedEditedRoom.webhook_url || "",
             webhookSecret: detailedEditedRoom.webhook_secret || "",
+            icsUrl: detailedEditedRoom.ics_url || "",
+            icsEnabled: detailedEditedRoom.ics_enabled || false,
+            icsFetchInterval: detailedEditedRoom.ics_fetch_interval || 5,
           }
         : null,
     [detailedEditedRoom],
@@ -176,14 +191,13 @@ export default function RoomsList() {
     items: topicOptions,
   });
 
-  const handleCopyUrl = (roomName: string) => {
-    const roomUrl = `${window.location.origin}/${roomName}`;
-    navigator.clipboard.writeText(roomUrl);
+  const handleCopyUrl = (roomName: NonEmptyString) => {
+    navigator.clipboard.writeText(roomAbsoluteUrl(roomName)).then(() => {
       setLinkCopied(roomName);
-
       setTimeout(() => {
         setLinkCopied("");
       }, 2000);
+    });
   };
 
   const handleCloseDialog = () => {
@@ -217,10 +231,10 @@ export default function RoomsList() {
 
       if (response.success) {
         setWebhookTestResult(
-          `✅ Webhook test successful! Status: ${response.status_code}`,
+          `${SUCCESS_EMOJI} Webhook test successful! Status: ${response.status_code}`,
         );
       } else {
-        let errorMsg = `❌ Webhook test failed`;
+        let errorMsg = `${ERROR_EMOJI} Webhook test failed`;
         errorMsg += ` (Status: ${response.status_code})`;
         if (response.error) {
           errorMsg += `: ${response.error}`;
@@ -275,6 +289,9 @@ export default function RoomsList() {
         is_shared: room.isShared,
         webhook_url: room.webhookUrl,
         webhook_secret: room.webhookSecret,
+        ics_url: room.icsUrl,
+        ics_enabled: room.icsEnabled,
+        ics_fetch_interval: room.icsFetchInterval,
       };
 
       if (isEditing) {
@@ -292,7 +309,7 @@ export default function RoomsList() {
 
       setRoomInput(null);
       setIsEditing(false);
-      setEditRoomId("");
+      setEditRoomId(null);
       setNameError("");
       refetch();
       onClose();
@@ -316,6 +333,22 @@ export default function RoomsList() {
     setShowWebhookSecret(false);
     setWebhookTestResult(null);
 
+    setRoomInput({
+      name: roomData.name,
+      zulipAutoPost: roomData.zulip_auto_post,
+      zulipStream: roomData.zulip_stream,
+      zulipTopic: roomData.zulip_topic,
+      isLocked: roomData.is_locked,
+      roomMode: roomData.room_mode,
+      recordingType: roomData.recording_type,
+      recordingTrigger: roomData.recording_trigger,
+      isShared: roomData.is_shared,
+      webhookUrl: roomData.webhook_url || "",
+      webhookSecret: roomData.webhook_secret || "",
+      icsUrl: roomData.ics_url || "",
+      icsEnabled: roomData.ics_enabled || false,
+      icsFetchInterval: roomData.ics_fetch_interval || 5,
+    });
     setEditRoomId(roomId);
     setIsEditing(true);
     setNameError("");
@@ -416,6 +449,22 @@ export default function RoomsList() {
               </Dialog.CloseTrigger>
             </Dialog.Header>
             <Dialog.Body>
+              <form
+                id="room-form"
+                onSubmit={(e) => {
+                  e.preventDefault();
+                  handleSaveRoom();
+                }}
+              >
+                <Tabs.Root defaultValue="general">
+                  <Tabs.List>
+                    <Tabs.Trigger value="general">General</Tabs.Trigger>
+                    <Tabs.Trigger value="calendar">Calendar</Tabs.Trigger>
+                    <Tabs.Trigger value="share">Share</Tabs.Trigger>
+                    <Tabs.Trigger value="webhook">WebHook</Tabs.Trigger>
+                  </Tabs.List>
+
+                  <Tabs.Content value="general" pt={6}>
                     <Field.Root>
                       <Field.Label>Room name</Field.Label>
                       <Input
@@ -423,11 +472,14 @@ export default function RoomsList() {
                         placeholder="room-name"
                         value={room.name}
                         onChange={handleRoomChange}
+                        enterKeyHint="next"
                       />
                       <Field.HelperText>
                         No spaces or special characters allowed
                       </Field.HelperText>
-                {nameError && <Field.ErrorText>{nameError}</Field.ErrorText>}
+                      {nameError && (
+                        <Field.ErrorText>{nameError}</Field.ErrorText>
+                      )}
                     </Field.Root>
 
                     <Field.Root mt={4}>
@@ -491,7 +543,9 @@ export default function RoomsList() {
                             ...room,
                             recordingType: e.value[0],
                             recordingTrigger:
-                        e.value[0] !== "cloud" ? "none" : room.recordingTrigger,
+                              e.value[0] !== "cloud"
+                                ? "none"
+                                : room.recordingTrigger,
                           })
                         }
                         collection={recordingTypeCollection}
@@ -522,7 +576,10 @@ export default function RoomsList() {
                       <Select.Root
                         value={[room.recordingTrigger]}
                         onValueChange={(e) =>
-                    setRoomInput({ ...room, recordingTrigger: e.value[0] })
+                          setRoomInput({
+                            ...room,
+                            recordingTrigger: e.value[0],
+                          })
                         }
                         collection={recordingTriggerCollection}
                         disabled={room.recordingType !== "cloud"}
@@ -548,7 +605,33 @@ export default function RoomsList() {
                         </Select.Positioner>
                       </Select.Root>
                     </Field.Root>
-              <Field.Root mt={8}>
+
+                    <Field.Root mt={4}>
+                      <Checkbox.Root
+                        name="isShared"
+                        checked={room.isShared}
+                        onCheckedChange={(e) => {
+                          const syntheticEvent = {
+                            target: {
+                              name: "isShared",
+                              type: "checkbox",
+                              checked: e.checked,
+                            },
+                          };
+                          handleRoomChange(syntheticEvent);
+                        }}
+                      >
+                        <Checkbox.HiddenInput />
+                        <Checkbox.Control>
+                          <Checkbox.Indicator />
+                        </Checkbox.Control>
+                        <Checkbox.Label>Shared room</Checkbox.Label>
+                      </Checkbox.Root>
+                    </Field.Root>
+                  </Tabs.Content>
+
+                  <Tabs.Content value="share" pt={6}>
+                    <Field.Root>
                       <Checkbox.Root
                         name="zulipAutoPost"
                         checked={room.zulipAutoPost}
@@ -638,20 +721,21 @@ export default function RoomsList() {
                         </Select.Positioner>
                       </Select.Root>
                     </Field.Root>
+                  </Tabs.Content>
 
-              {/* Webhook Configuration Section */}
-              <Field.Root mt={8}>
+                  <Tabs.Content value="webhook" pt={6}>
+                    <Field.Root>
                       <Field.Label>Webhook URL</Field.Label>
                       <Input
                         name="webhookUrl"
-                  type="url"
                         placeholder="https://example.com/webhook"
                         value={room.webhookUrl}
                         onChange={handleRoomChange}
+                        enterKeyHint="next"
                       />
                       <Field.HelperText>
-                  Optional: URL to receive notifications when transcripts are
-                  ready
+                        Optional: URL to receive notifications when transcripts
+                        are ready
                       </Field.HelperText>
                     </Field.Root>
 
@@ -677,7 +761,9 @@ export default function RoomsList() {
                                 size="sm"
                                 variant="ghost"
                                 aria-label={
-                            showWebhookSecret ? "Hide secret" : "Show secret"
+                                  showWebhookSecret
+                                    ? "Hide secret"
+                                    : "Show secret"
                                 }
                                 onClick={() =>
                                   setShowWebhookSecret(!showWebhookSecret)
@@ -688,8 +774,8 @@ export default function RoomsList() {
                             )}
                           </Flex>
                           <Field.HelperText>
-                      Used for HMAC signature verification (auto-generated if
-                      left empty)
+                            Used for HMAC signature verification (auto-generated
+                            if left empty)
                           </Field.HelperText>
                         </Field.Root>
 
@@ -724,12 +810,13 @@ export default function RoomsList() {
                                     maxWidth: "100%",
                                     padding: "8px",
                                     borderRadius: "4px",
-                              backgroundColor: webhookTestResult.startsWith(
-                                "✅",
+                                    backgroundColor:
+                                      webhookTestResult.startsWith(
+                                        SUCCESS_EMOJI,
                                       )
                                         ? "#f0fdf4"
                                         : "#fef2f2",
-                              border: `1px solid ${webhookTestResult.startsWith("✅") ? "#86efac" : "#fca5a5"}`,
+                                    border: `1px solid ${webhookTestResult.startsWith(SUCCESS_EMOJI) ? "#86efac" : "#fca5a5"}`,
                                   }}
                                 >
                                   {webhookTestResult}
@@ -740,37 +827,50 @@ export default function RoomsList() {
                         )}
                       </>
                     )}
+                  </Tabs.Content>
 
-              <Field.Root mt={4}>
-                <Checkbox.Root
-                  name="isShared"
-                  checked={room.isShared}
-                  onCheckedChange={(e) => {
-                    const syntheticEvent = {
-                      target: {
-                        name: "isShared",
-                        type: "checkbox",
-                        checked: e.checked,
-                      },
-                    };
-                    handleRoomChange(syntheticEvent);
+                  <Tabs.Content value="calendar" pt={6}>
+                    <Field.Root>
+                      <ICSSettings
+                        roomName={
+                          room.name ? parseNonEmptyString(room.name) : null
+                        }
+                        icsUrl={room.icsUrl}
+                        icsEnabled={room.icsEnabled}
+                        icsFetchInterval={room.icsFetchInterval}
+                        onChange={(settings) => {
+                          setRoomInput({
+                            ...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,
+                          });
                         }}
-                >
-                  <Checkbox.HiddenInput />
-                  <Checkbox.Control>
-                    <Checkbox.Indicator />
-                  </Checkbox.Control>
-                  <Checkbox.Label>Shared room</Checkbox.Label>
-                </Checkbox.Root>
+                        isOwner={true}
+                        isEditing={isEditing}
+                      />
                     </Field.Root>
+                  </Tabs.Content>
+                </Tabs.Root>
+              </form>
             </Dialog.Body>
             <Dialog.Footer>
               <Button variant="ghost" onClick={handleCloseDialog}>
                 Cancel
               </Button>
               <Button
+                type="submit"
                 colorPalette="primary"
-                onClick={handleSaveRoom}
+                form="room-form"
                 disabled={
                   !room.name || (room.zulipAutoPost && !room.zulipTopic)
                 }

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

@@ -33,17 +33,27 @@ export default function Player(props: PlayerProps) {
   const topicsRef = useRef(props.topics);
   const [firstRender, setFirstRender] = useState<boolean>(true);
 
-  const keyHandler = (e) => {
-    if (e.key == " ") {
+  const shouldIgnoreHotkeys = (target: EventTarget | null) => {
+    return (
+      target instanceof HTMLInputElement ||
+      target instanceof HTMLTextAreaElement
+    );
+  };
+
+  const keyHandler = (e: KeyboardEvent) => {
+    if (e.key === " ") {
+      if (e.repeat) return;
+      if (shouldIgnoreHotkeys(e.target)) return;
+      e.preventDefault();
       wavesurfer?.playPause();
     }
   };
   useEffect(() => {
-    document.addEventListener("keyup", keyHandler);
+    document.addEventListener("keydown", keyHandler);
     return () => {
-      document.removeEventListener("keyup", keyHandler);
+      document.removeEventListener("keydown", keyHandler);
     };
-  });
+  }, [wavesurfer]);
 
   // Waveform setup
   useEffect(() => {

www/app/[roomName]/MeetingSelection.tsx

@@ -0,0 +1,569 @@
+"use client";
+
+import { partition } from "remeda";
+import {
+  Box,
+  VStack,
+  HStack,
+  Text,
+  Button,
+  Spinner,
+  Badge,
+  Icon,
+  Flex,
+} from "@chakra-ui/react";
+import React from "react";
+import { FaUsers, FaClock, FaCalendarAlt, FaPlus } from "react-icons/fa";
+import { LuX } from "react-icons/lu";
+import type { components } from "../reflector-api";
+import {
+  useRoomActiveMeetings,
+  useRoomJoinMeeting,
+  useMeetingDeactivate,
+  useRoomGetByName,
+} from "../lib/apiHooks";
+import { useRouter } from "next/navigation";
+import { formatDateTime, formatStartedAgo } from "../lib/timeUtils";
+import MeetingMinimalHeader from "../components/MeetingMinimalHeader";
+import { NonEmptyString } from "../lib/utils";
+
+type Meeting = components["schemas"]["Meeting"];
+
+interface MeetingSelectionProps {
+  roomName: NonEmptyString;
+  isOwner: boolean;
+  isSharedRoom: boolean;
+  authLoading: boolean;
+  onMeetingSelect: (meeting: Meeting) => void;
+  onCreateUnscheduled: () => void;
+  isCreatingMeeting?: boolean;
+}
+
+export default function MeetingSelection({
+  roomName,
+  isOwner,
+  isSharedRoom,
+  onMeetingSelect,
+  onCreateUnscheduled,
+  isCreatingMeeting = false,
+}: MeetingSelectionProps) {
+  const router = useRouter();
+  const roomQuery = useRoomGetByName(roomName);
+  const activeMeetingsQuery = useRoomActiveMeetings(roomName);
+  const joinMeetingMutation = useRoomJoinMeeting();
+  const deactivateMeetingMutation = useMeetingDeactivate();
+
+  const room = roomQuery.data;
+  const allMeetings = activeMeetingsQuery.data || [];
+
+  const now = new Date();
+  const [currentMeetings, nonCurrentMeetings] = partition(
+    allMeetings,
+    (meeting) => {
+      const startTime = new Date(meeting.start_date);
+      const endTime = new Date(meeting.end_date);
+      // Meeting is ongoing if current time is between start and end
+      return now >= startTime && now <= endTime;
+    },
+  );
+
+  const upcomingMeetings = nonCurrentMeetings.filter((meeting) => {
+    const startTime = new Date(meeting.start_date);
+    // Meeting is upcoming if it hasn't started yet
+    return now < startTime;
+  });
+
+  const loading = roomQuery.isLoading || activeMeetingsQuery.isLoading;
+  const error = roomQuery.error || activeMeetingsQuery.error;
+
+  const handleJoinUpcoming = async (meeting: Meeting) => {
+    // Join the upcoming meeting and navigate to local meeting page
+    try {
+      const joinedMeeting = await joinMeetingMutation.mutateAsync({
+        params: {
+          path: {
+            room_name: roomName,
+            meeting_id: meeting.id,
+          },
+        },
+      });
+      onMeetingSelect(joinedMeeting);
+    } catch (err) {
+      console.error("Failed to join upcoming meeting:", err);
+    }
+  };
+
+  const handleJoinDirect = (meeting: Meeting) => {
+    // Navigate to local meeting page instead of external URL
+    onMeetingSelect(meeting);
+  };
+
+  const handleEndMeeting = async (meetingId: string) => {
+    try {
+      await deactivateMeetingMutation.mutateAsync({
+        params: {
+          path: {
+            meeting_id: meetingId,
+          },
+        },
+      });
+    } catch (err) {
+      console.error("Failed to end meeting:", err);
+    }
+  };
+
+  if (loading) {
+    return (
+      <Box p={8} textAlign="center">
+        <Spinner size="lg" color="blue.500" />
+        <Text mt={4}>Loading meetings...</Text>
+      </Box>
+    );
+  }
+
+  if (error) {
+    return (
+      <Box
+        p={4}
+        borderRadius="md"
+        bg="red.50"
+        borderLeft="4px solid"
+        borderColor="red.400"
+      >
+        <Text fontWeight="semibold" color="red.800">
+          Error
+        </Text>
+        <Text color="red.700">{"Failed to load meetings"}</Text>
+      </Box>
+    );
+  }
+
+  const handleLeaveMeeting = () => {
+    router.push("/");
+  };
+
+  return (
+    <Flex flexDir="column" minH="100vh" position="relative">
+      {/* Loading overlay */}
+      {isCreatingMeeting && (
+        <Box
+          position="fixed"
+          top={0}
+          left={0}
+          right={0}
+          bottom={0}
+          bg="blackAlpha.600"
+          zIndex={9999}
+          display="flex"
+          alignItems="center"
+          justifyContent="center"
+        >
+          <VStack gap={4} p={8} bg="white" borderRadius="lg" boxShadow="xl">
+            <Spinner size="lg" color="blue.500" />
+            <Text fontSize="lg" fontWeight="medium">
+              Creating meeting...
+            </Text>
+          </VStack>
+        </Box>
+      )}
+
+      <MeetingMinimalHeader
+        roomName={roomName}
+        displayName={room?.name}
+        showLeaveButton={true}
+        onLeave={handleLeaveMeeting}
+        showCreateButton={isOwner || isSharedRoom}
+        onCreateMeeting={onCreateUnscheduled}
+        isCreatingMeeting={isCreatingMeeting}
+      />
+
+      <Flex
+        flexDir="column"
+        w="full"
+        maxW="800px"
+        mx="auto"
+        px={{ base: 4, md: 6 }}
+        py={{ base: 4, md: 8 }}
+        flex="1"
+        gap={{ base: 4, md: 6 }}
+      >
+        {/* Current Ongoing Meetings - BIG DISPLAY */}
+        {currentMeetings.length > 0 ? (
+          <VStack align="stretch" gap={6} mb={8}>
+            {currentMeetings.map((meeting) => (
+              <Box
+                key={meeting.id}
+                width="100%"
+                bg="gray.50"
+                borderRadius="xl"
+                p={{ base: 4, md: 8 }}
+              >
+                <Flex
+                  direction={{ base: "column", md: "row" }}
+                  justify="space-between"
+                  align={{ base: "stretch", md: "start" }}
+                  gap={{ base: 4, md: 6 }}
+                >
+                  <VStack align="start" gap={{ base: 3, md: 4 }} flex={1}>
+                    <HStack>
+                      <Icon
+                        as={FaCalendarAlt}
+                        color="blue.600"
+                        boxSize="24px"
+                      />
+                      <Text
+                        fontSize={{ base: "xl", md: "2xl" }}
+                        fontWeight="bold"
+                        color="blue.800"
+                      >
+                        {(meeting.calendar_metadata as any)?.title ||
+                          "Live Meeting"}
+                      </Text>
+                    </HStack>
+
+                    {isOwner &&
+                      (meeting.calendar_metadata as any)?.description && (
+                        <Text
+                          fontSize={{ base: "md", md: "lg" }}
+                          color="gray.700"
+                        >
+                          {(meeting.calendar_metadata as any).description}
+                        </Text>
+                      )}
+
+                    <Flex
+                      gap={{ base: 4, md: 8 }}
+                      fontSize={{ base: "sm", md: "md" }}
+                      color="gray.600"
+                      flexWrap="wrap"
+                    >
+                      <HStack>
+                        <Icon
+                          as={FaUsers}
+                          boxSize={{ base: "16px", md: "20px" }}
+                        />
+                        <Text fontWeight="medium">
+                          {meeting.num_clients || 0} participant
+                          {meeting.num_clients !== 1 ? "s" : ""}
+                        </Text>
+                      </HStack>
+                      <HStack>
+                        <Icon
+                          as={FaClock}
+                          boxSize={{ base: "16px", md: "20px" }}
+                        />
+                        <Text>
+                          {formatStartedAgo(new Date(meeting.start_date))}
+                        </Text>
+                      </HStack>
+                    </Flex>
+
+                    {isOwner &&
+                      (meeting.calendar_metadata as any)?.attendees && (
+                        <HStack gap={3} flexWrap="wrap">
+                          {(meeting.calendar_metadata as any).attendees
+                            .slice(0, 4)
+                            .map((attendee: any, idx: number) => (
+                              <Badge
+                                key={idx}
+                                colorScheme="blue"
+                                fontSize="sm"
+                                px={3}
+                                py={1}
+                              >
+                                {attendee.name || attendee.email}
+                              </Badge>
+                            ))}
+                          {(meeting.calendar_metadata as any).attendees.length >
+                            4 && (
+                            <Badge
+                              colorScheme="gray"
+                              fontSize="sm"
+                              px={3}
+                              py={1}
+                            >
+                              +
+                              {(meeting.calendar_metadata as any).attendees
+                                .length - 4}{" "}
+                              more
+                            </Badge>
+                          )}
+                        </HStack>
+                      )}
+                  </VStack>
+
+                  <VStack gap={3} width={{ base: "full", md: "auto" }}>
+                    <Button
+                      colorScheme="blue"
+                      size={{ base: "lg", md: "xl" }}
+                      fontSize={{ base: "md", md: "lg" }}
+                      px={{ base: 6, md: 8 }}
+                      py={{ base: 4, md: 6 }}
+                      width={{ base: "full", md: "auto" }}
+                      onClick={() => handleJoinDirect(meeting)}
+                    >
+                      <Icon
+                        as={FaUsers}
+                        boxSize={{ base: "18px", md: "20px" }}
+                        me={2}
+                      />
+                      Join Now
+                    </Button>
+                    {isOwner && (
+                      <Button
+                        variant="outline"
+                        colorScheme="red"
+                        size="md"
+                        onClick={() => handleEndMeeting(meeting.id)}
+                        loading={deactivateMeetingMutation.isPending}
+                      >
+                        <Icon as={LuX} me={2} />
+                        End Meeting
+                      </Button>
+                    )}
+                  </VStack>
+                </Flex>
+              </Box>
+            ))}
+          </VStack>
+        ) : upcomingMeetings.length > 0 ? (
+          /* Upcoming Meetings - BIG DISPLAY when no ongoing meetings */
+          <VStack align="stretch" gap={6} mb={8}>
+            <Text fontSize="xl" fontWeight="bold" color="gray.800">
+              Upcoming Meeting{upcomingMeetings.length > 1 ? "s" : ""}
+            </Text>
+            {upcomingMeetings.map((meeting) => {
+              const now = new Date();
+              const startTime = new Date(meeting.start_date);
+              const minutesUntilStart = Math.floor(
+                (startTime.getTime() - now.getTime()) / (1000 * 60),
+              );
+
+              return (
+                <Box
+                  key={meeting.id}
+                  width="100%"
+                  bg="orange.50"
+                  borderRadius="xl"
+                  p={{ base: 4, md: 8 }}
+                  border="2px solid"
+                  borderColor="orange.200"
+                >
+                  <Flex
+                    direction={{ base: "column", md: "row" }}
+                    justify="space-between"
+                    align={{ base: "stretch", md: "start" }}
+                    gap={{ base: 4, md: 6 }}
+                  >
+                    <VStack align="start" gap={{ base: 3, md: 4 }} flex={1}>
+                      <HStack>
+                        <Icon
+                          as={FaCalendarAlt}
+                          color="orange.600"
+                          boxSize="24px"
+                        />
+                        <Text
+                          fontSize={{ base: "xl", md: "2xl" }}
+                          fontWeight="bold"
+                          color="orange.800"
+                        >
+                          {(meeting.calendar_metadata as any)?.title ||
+                            "Upcoming Meeting"}
+                        </Text>
+                      </HStack>
+
+                      {isOwner &&
+                        (meeting.calendar_metadata as any)?.description && (
+                          <Text
+                            fontSize={{ base: "md", md: "lg" }}
+                            color="gray.700"
+                          >
+                            {(meeting.calendar_metadata as any).description}
+                          </Text>
+                        )}
+
+                      <Flex
+                        gap={{ base: 2, md: 8 }}
+                        fontSize={{ base: "sm", md: "md" }}
+                        color="gray.600"
+                        flexWrap="wrap"
+                        align="center"
+                      >
+                        <Badge
+                          colorScheme="orange"
+                          fontSize={{ base: "sm", md: "md" }}
+                          px={3}
+                          py={1}
+                        >
+                          Starts in {minutesUntilStart} minute
+                          {minutesUntilStart !== 1 ? "s" : ""}
+                        </Badge>
+                        <Text>
+                          {formatDateTime(new Date(meeting.start_date))}
+                        </Text>
+                      </Flex>
+
+                      {isOwner &&
+                        (meeting.calendar_metadata as any)?.attendees && (
+                          <HStack gap={3} flexWrap="wrap">
+                            {(meeting.calendar_metadata as any).attendees
+                              .slice(0, 4)
+                              .map((attendee: any, idx: number) => (
+                                <Badge
+                                  key={idx}
+                                  colorScheme="orange"
+                                  fontSize="sm"
+                                  px={3}
+                                  py={1}
+                                >
+                                  {attendee.name || attendee.email}
+                                </Badge>
+                              ))}
+                            {(meeting.calendar_metadata as any).attendees
+                              .length > 4 && (
+                              <Badge
+                                colorScheme="gray"
+                                fontSize="sm"
+                                px={3}
+                                py={1}
+                              >
+                                +
+                                {(meeting.calendar_metadata as any).attendees
+                                  .length - 4}{" "}
+                                more
+                              </Badge>
+                            )}
+                          </HStack>
+                        )}
+                    </VStack>
+
+                    <VStack gap={3} width={{ base: "full", md: "auto" }}>
+                      <Button
+                        colorScheme="orange"
+                        size={{ base: "lg", md: "xl" }}
+                        fontSize={{ base: "md", md: "lg" }}
+                        px={{ base: 6, md: 8 }}
+                        py={{ base: 4, md: 6 }}
+                        width={{ base: "full", md: "auto" }}
+                        onClick={() => handleJoinUpcoming(meeting)}
+                      >
+                        <Icon
+                          as={FaClock}
+                          boxSize={{ base: "18px", md: "20px" }}
+                          me={2}
+                        />
+                        Join Early
+                      </Button>
+                      {isOwner && (
+                        <Button
+                          variant="outline"
+                          colorScheme="red"
+                          size="md"
+                          onClick={() => handleEndMeeting(meeting.id)}
+                          loading={deactivateMeetingMutation.isPending}
+                        >
+                          <Icon as={LuX} me={2} />
+                          Cancel Meeting
+                        </Button>
+                      )}
+                    </VStack>
+                  </Flex>
+                </Box>
+              );
+            })}
+          </VStack>
+        ) : null}
+
+        {/* Upcoming Meetings - SMALLER ASIDE DISPLAY when there are ongoing meetings */}
+        {currentMeetings.length > 0 && upcomingMeetings.length > 0 && (
+          <VStack align="stretch" gap={4} mb={6}>
+            <Text fontSize="lg" fontWeight="semibold" color="gray.700">
+              Starting Soon
+            </Text>
+            <Flex
+              gap={4}
+              flexWrap="wrap"
+              direction={{ base: "column", sm: "row" }}
+            >
+              {upcomingMeetings.map((meeting) => {
+                const now = new Date();
+                const startTime = new Date(meeting.start_date);
+                const minutesUntilStart = Math.floor(
+                  (startTime.getTime() - now.getTime()) / (1000 * 60),
+                );
+
+                return (
+                  <Box
+                    key={meeting.id}
+                    bg="white"
+                    border="2px solid"
+                    borderColor="orange.200"
+                    borderRadius="lg"
+                    p={4}
+                    minW={{ base: "100%", sm: "300px" }}
+                    maxW={{ base: "100%", sm: "400px" }}
+                    _hover={{ borderColor: "orange.300", bg: "orange.50" }}
+                    transition="all 0.2s"
+                  >
+                    <VStack align="start" gap={3}>
+                      <HStack>
+                        <Icon as={FaCalendarAlt} color="orange.500" />
+                        <Text fontWeight="semibold" fontSize="md">
+                          {(meeting.calendar_metadata as any)?.title ||
+                            "Upcoming Meeting"}
+                        </Text>
+                      </HStack>
+
+                      <Badge colorScheme="orange" fontSize="sm" px={2} py={1}>
+                        in {minutesUntilStart} minute
+                        {minutesUntilStart !== 1 ? "s" : ""}
+                      </Badge>
+
+                      <Text fontSize="sm" color="gray.600">
+                        Starts: {formatDateTime(new Date(meeting.start_date))}
+                      </Text>
+
+                      <Button
+                        colorScheme="orange"
+                        size="sm"
+                        width="full"
+                        onClick={() => handleJoinUpcoming(meeting)}
+                      >
+                        Join Early
+                      </Button>
+                    </VStack>
+                  </Box>
+                );
+              })}
+            </Flex>
+          </VStack>
+        )}
+
+        {/* No meetings message - show when no ongoing or upcoming meetings */}
+        {currentMeetings.length === 0 && upcomingMeetings.length === 0 && (
+          <Flex
+            width="100%"
+            flex="1"
+            justify="center"
+            align="center"
+            textAlign="center"
+            mb={6}
+          >
+            <VStack gap={4}>
+              <Icon as={FaCalendarAlt} boxSize="48px" color="gray.400" />
+              <VStack gap={2}>
+                <Text fontSize="xl" fontWeight="semibold" color="black">
+                  No meetings right now
+                </Text>
+                <Text fontSize="md" color="gray.600" maxW="400px">
+                  There are no ongoing or upcoming meetings in this room at the
+                  moment.
+                </Text>
+              </VStack>
+            </VStack>
+          </Flex>
+        )}
+      </Flex>
+    </Flex>
+  );
+}

www/app/[roomName]/[meetingId]/constants.ts

@@ -0,0 +1 @@
+export const MEETING_DEFAULT_TIME_MINUTES = 60;