401 reauth experiments

* small typing

* typing fixes

---------

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

.github/workflows/docker-frontend.yml

@@ -1,57 +0,0 @@
-name: Build and Push Frontend Docker Image
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - 'www/**'
-      - '.github/workflows/docker-frontend.yml'
-  workflow_dispatch:
-
-env:
-  REGISTRY: ghcr.io
-  IMAGE_NAME: ${{ github.repository }}-frontend
-
-jobs:
-  build-and-push:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Extract metadata
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
-          tags: |
-            type=ref,event=branch
-            type=sha,prefix={{branch}}-
-            type=raw,value=latest,enable={{is_default_branch}}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Build and push Docker image
-        uses: docker/build-push-action@v5
-        with:
-          context: ./www
-          file: ./www/Dockerfile
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-          platforms: linux/amd64,linux/arm64

CHANGELOG.md

@@ -1,113 +1,5 @@
 # Changelog
 
-## [0.15.0](https://github.com/Monadical-SAS/reflector/compare/v0.14.0...v0.15.0) (2025-10-20)
-
-
-### Features
-
-* api tokens  ([#705](https://github.com/Monadical-SAS/reflector/issues/705)) ([9a258ab](https://github.com/Monadical-SAS/reflector/commit/9a258abc0209b0ac3799532a507ea6a9125d703a))
-
-## [0.14.0](https://github.com/Monadical-SAS/reflector/compare/v0.13.1...v0.14.0) (2025-10-08)
-
-
-### Features
-
-* Add calendar event data to transcript webhook payload ([#689](https://github.com/Monadical-SAS/reflector/issues/689)) ([5f6910e](https://github.com/Monadical-SAS/reflector/commit/5f6910e5131b7f28f86c9ecdcc57fed8412ee3cd))
-* container build for www / github ([#672](https://github.com/Monadical-SAS/reflector/issues/672)) ([969bd84](https://github.com/Monadical-SAS/reflector/commit/969bd84fcc14851d1a101412a0ba115f1b7cde82))
-* docker-compose for production frontend ([#664](https://github.com/Monadical-SAS/reflector/issues/664)) ([5bf64b5](https://github.com/Monadical-SAS/reflector/commit/5bf64b5a41f64535e22849b4bb11734d4dbb4aae))
-
-
-### Bug Fixes
-
-* restore feature boolean logic ([#671](https://github.com/Monadical-SAS/reflector/issues/671)) ([3660884](https://github.com/Monadical-SAS/reflector/commit/36608849ec64e953e3be456172502762e3c33df9))
-* security review ([#656](https://github.com/Monadical-SAS/reflector/issues/656)) ([5d98754](https://github.com/Monadical-SAS/reflector/commit/5d98754305c6c540dd194dda268544f6d88bfaf8))
-* update transcript list on reprocess ([#676](https://github.com/Monadical-SAS/reflector/issues/676)) ([9a71af1](https://github.com/Monadical-SAS/reflector/commit/9a71af145ee9b833078c78d0c684590ab12e9f0e))
-* upgrade nemo toolkit ([#678](https://github.com/Monadical-SAS/reflector/issues/678)) ([eef6dc3](https://github.com/Monadical-SAS/reflector/commit/eef6dc39037329b65804297786d852dddb0557f9))
-
-## [0.13.1](https://github.com/Monadical-SAS/reflector/compare/v0.13.0...v0.13.1) (2025-09-22)
-
-
-### Bug Fixes
-
-* TypeError on not all arguments converted during string formatting in logger ([#667](https://github.com/Monadical-SAS/reflector/issues/667)) ([565a629](https://github.com/Monadical-SAS/reflector/commit/565a62900f5a02fc946b68f9269a42190ed70ab6))
-
-## [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)
-
-
-### Features
-
-* replace nextjs-config with environment variables ([#632](https://github.com/Monadical-SAS/reflector/issues/632)) ([369ecdf](https://github.com/Monadical-SAS/reflector/commit/369ecdff13f3862d926a9c0b87df52c9d94c4dde))
-
-
-### Bug Fixes
-
-* anonymous users transcript permissions ([#621](https://github.com/Monadical-SAS/reflector/issues/621)) ([f81fe99](https://github.com/Monadical-SAS/reflector/commit/f81fe9948a9237b3e0001b2d8ca84f54d76878f9))
-* auth post ([#624](https://github.com/Monadical-SAS/reflector/issues/624)) ([cde99ca](https://github.com/Monadical-SAS/reflector/commit/cde99ca2716f84ba26798f289047732f0448742e))
-* auth post ([#626](https://github.com/Monadical-SAS/reflector/issues/626)) ([3b85ff3](https://github.com/Monadical-SAS/reflector/commit/3b85ff3bdf4fb053b103070646811bc990c0e70a))
-* auth post ([#627](https://github.com/Monadical-SAS/reflector/issues/627)) ([962038e](https://github.com/Monadical-SAS/reflector/commit/962038ee3f2a555dc3c03856be0e4409456e0996))
-* missing follow_redirects=True on modal endpoint ([#630](https://github.com/Monadical-SAS/reflector/issues/630)) ([fc363bd](https://github.com/Monadical-SAS/reflector/commit/fc363bd49b17b075e64f9186e5e0185abc325ea7))
-* sync backend and frontend token refresh logic ([#614](https://github.com/Monadical-SAS/reflector/issues/614)) ([5a5b323](https://github.com/Monadical-SAS/reflector/commit/5a5b3233820df9536da75e87ce6184a983d4713a))
-
-## [0.9.0](https://github.com/Monadical-SAS/reflector/compare/v0.8.2...v0.9.0) (2025-09-06)
-
-
-### Features
-
-* frontend openapi react query ([#606](https://github.com/Monadical-SAS/reflector/issues/606)) ([c4d2825](https://github.com/Monadical-SAS/reflector/commit/c4d2825c81f81ad8835629fbf6ea8c7383f8c31b))
-
-
-### Bug Fixes
-
-* align whisper transcriber api with parakeet ([#602](https://github.com/Monadical-SAS/reflector/issues/602)) ([0663700](https://github.com/Monadical-SAS/reflector/commit/0663700a615a4af69a03c96c410f049e23ec9443))
-* kv use tls explicit ([#610](https://github.com/Monadical-SAS/reflector/issues/610)) ([08d88ec](https://github.com/Monadical-SAS/reflector/commit/08d88ec349f38b0d13e0fa4cb73486c8dfd31836))
-* source kind for file processing ([#601](https://github.com/Monadical-SAS/reflector/issues/601)) ([dc82f8b](https://github.com/Monadical-SAS/reflector/commit/dc82f8bb3bdf3ab3d4088e592a30fd63907319e1))
-* token refresh locking ([#613](https://github.com/Monadical-SAS/reflector/issues/613)) ([7f5a4c9](https://github.com/Monadical-SAS/reflector/commit/7f5a4c9ddc7fd098860c8bdda2ca3b57f63ded2f))
-
 ## [0.8.2](https://github.com/Monadical-SAS/reflector/compare/v0.8.1...v0.8.2) (2025-08-29)
 
 

CLAUDE.md

@@ -66,6 +66,7 @@ pnpm install
 
 # Copy configuration templates
 cp .env_template .env
+cp config-template.ts config.ts
 ```
 
 **Development:**
@@ -151,7 +152,7 @@ All endpoints prefixed `/v1/`:
 
 **Frontend** (`www/.env`):
 - `NEXTAUTH_URL`, `NEXTAUTH_SECRET` - Authentication configuration
-- `REFLECTOR_API_URL` - Backend API endpoint
+- `NEXT_PUBLIC_REFLECTOR_API_URL` - Backend API endpoint
 - `REFLECTOR_DOMAIN_CONFIG` - Feature flags and domain settings
 
 ## Testing Strategy

README.md

@@ -99,10 +99,11 @@ Start with `cd www`.
 
 ```bash
 pnpm install
-cp .env.example .env
+cp .env_template .env
+cp config-template.ts config.ts
 ```
 
-Then, fill in the environment variables in `.env` as needed. If you are unsure on how to proceed, ask in Zulip.
+Then, fill in the environment variables in `.env` and the configuration in `config.ts` as needed. If you are unsure on how to proceed, ask in Zulip.
 
 **Run in development mode**
 
@@ -167,41 +168,3 @@ You can manually process an audio file by calling the process tool:
 ```bash
 uv run python -m reflector.tools.process path/to/audio.wav
 ```
-
-## Build-time env variables
-
-Next.js projects are more used to NEXT_PUBLIC_ prefixed buildtime vars. We don't have those for the reason we need to serve a ccustomizable prebuild docker container.
-
-Instead, all the variables are runtime. Variables needed to the frontend are served to the frontend app at initial render.
-
-It also means there's no static prebuild and no static files to serve for js/html.
-
-## Feature Flags
-
-Reflector uses environment variable-based feature flags to control application functionality. These flags allow you to enable or disable features without code changes.
-
-### Available Feature Flags
-
-| Feature Flag | Environment Variable |
-|-------------|---------------------|
-| `requireLogin` | `FEATURE_REQUIRE_LOGIN` |
-| `privacy` | `FEATURE_PRIVACY` |
-| `browse` | `FEATURE_BROWSE` |
-| `sendToZulip` | `FEATURE_SEND_TO_ZULIP` |
-| `rooms` | `FEATURE_ROOMS` |
-
-### Setting Feature Flags
-
-Feature flags are controlled via environment variables using the pattern `FEATURE_{FEATURE_NAME}` where `{FEATURE_NAME}` is the SCREAMING_SNAKE_CASE version of the feature name.
-
-**Examples:**
-```bash
-# Enable user authentication requirement
-FEATURE_REQUIRE_LOGIN=true
-
-# Disable browse functionality
-FEATURE_BROWSE=false
-
-# Enable Zulip integration
-FEATURE_SEND_TO_ZULIP=true
-```

compose.yml

@@ -39,7 +39,7 @@ services:
     ports:
       - 6379:6379
   web:
-    image: node:22-alpine
+    image: node:18
     ports:
       - "3000:3000"
     command: sh -c "corepack enable && pnpm install && pnpm dev"
@@ -50,8 +50,6 @@ services:
       - /app/node_modules
     env_file:
       - ./www/.env.local
-    environment:
-      - NODE_ENV=development
 
   postgres:
     image: postgres:17

docker-compose.prod.yml

@@ -1,39 +0,0 @@
-# Production Docker Compose configuration for Frontend
-# Usage: docker compose -f docker-compose.prod.yml up -d
-
-services:
-  web:
-    build:
-      context: ./www
-      dockerfile: Dockerfile
-    image: reflector-frontend:latest
-    environment:
-      - KV_URL=${KV_URL:-redis://redis:6379}
-      - SITE_URL=${SITE_URL}
-      - API_URL=${API_URL}
-      - WEBSOCKET_URL=${WEBSOCKET_URL}
-      - NEXTAUTH_URL=${NEXTAUTH_URL:-http://localhost:3000}
-      - NEXTAUTH_SECRET=${NEXTAUTH_SECRET:-changeme-in-production}
-      - AUTHENTIK_ISSUER=${AUTHENTIK_ISSUER}
-      - AUTHENTIK_CLIENT_ID=${AUTHENTIK_CLIENT_ID}
-      - AUTHENTIK_CLIENT_SECRET=${AUTHENTIK_CLIENT_SECRET}
-      - AUTHENTIK_REFRESH_TOKEN_URL=${AUTHENTIK_REFRESH_TOKEN_URL}
-      - SENTRY_DSN=${SENTRY_DSN}
-      - SENTRY_IGNORE_API_RESOLUTION_ERROR=${SENTRY_IGNORE_API_RESOLUTION_ERROR:-1}
-    depends_on:
-      - redis
-    restart: unless-stopped
-
-  redis:
-    image: redis:7.2-alpine
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "redis-cli", "ping"]
-      interval: 30s
-      timeout: 3s
-      retries: 3
-    volumes:
-      - redis_data:/data
-
-volumes:
-  redis_data:

gpu/modal_deployments/.gitignore

@@ -1,33 +0,0 @@
-# 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/modal_deployments/reflector_transcriber.py

@@ -1,608 +0,0 @@
-import os
-import sys
-import threading
-import uuid
-from typing import Generator, Mapping, NamedTuple, NewType, TypedDict
-from urllib.parse import urlparse
-
-import modal
-
-MODEL_NAME = "large-v2"
-MODEL_COMPUTE_TYPE: str = "float16"
-MODEL_NUM_WORKERS: int = 1
-MINUTES = 60  # seconds
-SAMPLERATE = 16000
-UPLOADS_PATH = "/uploads"
-CACHE_PATH = "/models"
-SUPPORTED_FILE_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
-VAD_CONFIG = {
-    "batch_max_duration": 30.0,
-    "silence_padding": 0.5,
-    "window_size": 512,
-}
-
-
-WhisperUniqFilename = NewType("WhisperUniqFilename", str)
-AudioFileExtension = NewType("AudioFileExtension", str)
-
-app = modal.App("reflector-transcriber")
-
-model_cache = modal.Volume.from_name("models", create_if_missing=True)
-upload_volume = modal.Volume.from_name("whisper-uploads", create_if_missing=True)
-
-
-class TimeSegment(NamedTuple):
-    """Represents a time segment with start and end times."""
-
-    start: float
-    end: float
-
-
-class AudioSegment(NamedTuple):
-    """Represents an audio segment with timing and audio data."""
-
-    start: float
-    end: float
-    audio: any
-
-
-class TranscriptResult(NamedTuple):
-    """Represents a transcription result with text and word timings."""
-
-    text: str
-    words: list["WordTiming"]
-
-
-class WordTiming(TypedDict):
-    """Represents a word with its timing information."""
-
-    word: str
-    start: float
-    end: float
-
-
-def download_model():
-    from faster_whisper import download_model
-
-    model_cache.reload()
-
-    download_model(MODEL_NAME, cache_dir=CACHE_PATH)
-
-    model_cache.commit()
-
-
-image = (
-    modal.Image.debian_slim(python_version="3.12")
-    .env(
-        {
-            "HF_HUB_ENABLE_HF_TRANSFER": "1",
-            "LD_LIBRARY_PATH": (
-                "/usr/local/lib/python3.12/site-packages/nvidia/cudnn/lib/:"
-                "/opt/conda/lib/python3.12/site-packages/nvidia/cublas/lib/"
-            ),
-        }
-    )
-    .apt_install("ffmpeg")
-    .pip_install(
-        "huggingface_hub==0.27.1",
-        "hf-transfer==0.1.9",
-        "torch==2.5.1",
-        "faster-whisper==1.1.1",
-        "fastapi==0.115.12",
-        "requests",
-        "librosa==0.10.1",
-        "numpy<2",
-        "silero-vad==5.1.0",
-    )
-    .run_function(download_model, volumes={CACHE_PATH: model_cache})
-)
-
-
-def detect_audio_format(url: str, headers: Mapping[str, str]) -> AudioFileExtension:
-    parsed_url = urlparse(url)
-    url_path = parsed_url.path
-
-    for ext in SUPPORTED_FILE_EXTENSIONS:
-        if url_path.lower().endswith(f".{ext}"):
-            return AudioFileExtension(ext)
-
-    content_type = headers.get("content-type", "").lower()
-    if "audio/mpeg" in content_type or "audio/mp3" in content_type:
-        return AudioFileExtension("mp3")
-    if "audio/wav" in content_type:
-        return AudioFileExtension("wav")
-    if "audio/mp4" in content_type:
-        return AudioFileExtension("mp4")
-
-    raise ValueError(
-        f"Unsupported audio format for URL: {url}. "
-        f"Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
-    )
-
-
-def download_audio_to_volume(
-    audio_file_url: str,
-) -> tuple[WhisperUniqFilename, AudioFileExtension]:
-    import requests
-    from fastapi import HTTPException
-
-    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 = WhisperUniqFilename(f"{uuid.uuid4()}.{audio_suffix}")
-    file_path = f"{UPLOADS_PATH}/{unique_filename}"
-
-    with open(file_path, "wb") as f:
-        f.write(response.content)
-
-    upload_volume.commit()
-    return unique_filename, audio_suffix
-
-
-def pad_audio(audio_array, sample_rate: int = SAMPLERATE):
-    """Add 0.5s of silence if audio is shorter than the silence_padding window.
-
-    Whisper does not require this strictly, but aligning behavior with Parakeet
-    avoids edge-case crashes on extremely short inputs and makes comparisons easier.
-    """
-    import numpy as np
-
-    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
-
-
-@app.cls(
-    gpu="A10G",
-    timeout=5 * MINUTES,
-    scaledown_window=5 * MINUTES,
-    image=image,
-    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
-)
-@modal.concurrent(max_inputs=10)
-class TranscriberWhisperLive:
-    """Live transcriber class for small audio segments (A10G).
-
-    Mirrors the Parakeet live class API but uses Faster-Whisper under the hood.
-    """
-
-    @modal.enter()
-    def enter(self):
-        import faster_whisper
-        import torch
-
-        self.lock = threading.Lock()
-        self.use_gpu = torch.cuda.is_available()
-        self.device = "cuda" if self.use_gpu else "cpu"
-        self.model = faster_whisper.WhisperModel(
-            MODEL_NAME,
-            device=self.device,
-            compute_type=MODEL_COMPUTE_TYPE,
-            num_workers=MODEL_NUM_WORKERS,
-            download_root=CACHE_PATH,
-            local_files_only=True,
-        )
-        print(f"Model is on device: {self.device}")
-
-    @modal.method()
-    def transcribe_segment(
-        self,
-        filename: str,
-        language: str = "en",
-    ):
-        """Transcribe a single uploaded audio file by filename."""
-        upload_volume.reload()
-
-        file_path = f"{UPLOADS_PATH}/{filename}"
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"File not found: {file_path}")
-
-        with self.lock:
-            with NoStdStreams():
-                segments, _ = self.model.transcribe(
-                    file_path,
-                    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
-        ]
-
-        return {"text": text, "words": words}
-
-    @modal.method()
-    def transcribe_batch(
-        self,
-        filenames: list[str],
-        language: str = "en",
-    ):
-        """Transcribe multiple uploaded audio files and return per-file results."""
-        upload_volume.reload()
-
-        results = []
-        for filename in filenames:
-            file_path = f"{UPLOADS_PATH}/{filename}"
-            if not os.path.exists(file_path):
-                raise FileNotFoundError(f"Batch file not found: {file_path}")
-
-            with self.lock:
-                with NoStdStreams():
-                    segments, _ = self.model.transcribe(
-                        file_path,
-                        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), 2),
-                    "end": round(float(w.end), 2),
-                }
-                for seg in segments
-                for w in seg.words
-            ]
-
-            results.append(
-                {
-                    "filename": filename,
-                    "text": text,
-                    "words": words,
-                }
-            )
-
-        return results
-
-
-@app.cls(
-    gpu="L40S",
-    timeout=15 * MINUTES,
-    image=image,
-    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
-)
-class TranscriberWhisperFile:
-    """File transcriber for larger/longer audio, using VAD-driven batching (L40S)."""
-
-    @modal.enter()
-    def enter(self):
-        import faster_whisper
-        import torch
-        from silero_vad import load_silero_vad
-
-        self.lock = threading.Lock()
-        self.use_gpu = torch.cuda.is_available()
-        self.device = "cuda" if self.use_gpu else "cpu"
-        self.model = faster_whisper.WhisperModel(
-            MODEL_NAME,
-            device=self.device,
-            compute_type=MODEL_COMPUTE_TYPE,
-            num_workers=MODEL_NUM_WORKERS,
-            download_root=CACHE_PATH,
-            local_files_only=True,
-        )
-        self.vad_model = load_silero_vad(onnx=False)
-
-    @modal.method()
-    def transcribe_segment(
-        self, filename: str, timestamp_offset: float = 0.0, language: str = "en"
-    ):
-        import librosa
-        import numpy as np
-        from silero_vad import VADIterator
-
-        def vad_segments(
-            audio_array,
-            sample_rate: int = SAMPLERATE,
-            window_size: int = VAD_CONFIG["window_size"],
-        ) -> Generator[TimeSegment, None, None]:
-            """Generate speech segments as TimeSegment using Silero VAD."""
-            iterator = VADIterator(self.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 TimeSegment(
-                        start / float(SAMPLERATE), end / float(SAMPLERATE)
-                    )
-                    start = None
-            iterator.reset_states()
-
-        upload_volume.reload()
-        file_path = f"{UPLOADS_PATH}/{filename}"
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"File not found: {file_path}")
-
-        audio_array, _sr = librosa.load(file_path, sr=SAMPLERATE, mono=True)
-
-        # Batch segments up to ~30s windows by merging contiguous VAD segments
-        merged_batches: list[TimeSegment] = []
-        batch_start = None
-        batch_end = None
-        max_duration = VAD_CONFIG["batch_max_duration"]
-        for segment in vad_segments(audio_array):
-            seg_start, seg_end = segment.start, segment.end
-            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(TimeSegment(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(TimeSegment(batch_start, batch_end))
-
-        all_text = []
-        all_words = []
-
-        for segment in merged_batches:
-            start_time, end_time = segment.start, segment.end
-            s_idx = int(start_time * SAMPLERATE)
-            e_idx = int(end_time * SAMPLERATE)
-            segment = audio_array[s_idx:e_idx]
-            segment = pad_audio(segment, SAMPLERATE)
-
-            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)
-
-        return {"text": " ".join(all_text), "words": all_words}
-
-
-def detect_audio_format(url: str, headers: dict) -> str:
-    from urllib.parse import urlparse
-
-    from fastapi import HTTPException
-
-    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_volume(audio_file_url: str) -> tuple[str, str]:
-    import requests
-    from fastapi import HTTPException
-
-    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 = f"{UPLOADS_PATH}/{unique_filename}"
-
-    with open(file_path, "wb") as f:
-        f.write(response.content)
-
-    upload_volume.commit()
-    return unique_filename, audio_suffix
-
-
-@app.function(
-    scaledown_window=60,
-    timeout=600,
-    secrets=[
-        modal.Secret.from_name("reflector-gpu"),
-    ],
-    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
-    image=image,
-)
-@modal.concurrent(max_inputs=40)
-@modal.asgi_app()
-def web():
-    from fastapi import (
-        Body,
-        Depends,
-        FastAPI,
-        Form,
-        HTTPException,
-        UploadFile,
-        status,
-    )
-    from fastapi.security import OAuth2PasswordBearer
-
-    transcriber_live = TranscriberWhisperLive()
-    transcriber_file = TranscriberWhisperFile()
-
-    app = FastAPI()
-
-    oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
-
-    def apikey_auth(apikey: str = Depends(oauth2_scheme)):
-        if apikey == os.environ["REFLECTOR_GPU_APIKEY"]:
-            return
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid API key",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
-
-    class TranscriptResponse(dict):
-        pass
-
-    @app.post("/v1/audio/transcriptions", dependencies=[Depends(apikey_auth)])
-    def transcribe(
-        file: UploadFile = None,
-        files: list[UploadFile] | None = None,
-        model: str = Form(MODEL_NAME),
-        language: str = Form("en"),
-        batch: bool = Form(False),
-    ):
-        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_filenames: list[str] = []
-        for upload_file in upload_files:
-            audio_suffix = upload_file.filename.split(".")[-1]
-            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 = f"{UPLOADS_PATH}/{unique_filename}"
-            with open(file_path, "wb") as f:
-                content = upload_file.file.read()
-                f.write(content)
-            uploaded_filenames.append(unique_filename)
-
-        upload_volume.commit()
-
-        try:
-            if batch and len(upload_files) > 1:
-                func = transcriber_live.transcribe_batch.spawn(
-                    filenames=uploaded_filenames,
-                    language=language,
-                )
-                results = func.get()
-                return {"results": results}
-
-            results = []
-            for filename in uploaded_filenames:
-                func = transcriber_live.transcribe_segment.spawn(
-                    filename=filename,
-                    language=language,
-                )
-                result = func.get()
-                result["filename"] = filename
-                results.append(result)
-
-            return {"results": results} if len(results) > 1 else results[0]
-        finally:
-            for filename in uploaded_filenames:
-                try:
-                    file_path = f"{UPLOADS_PATH}/{filename}"
-                    os.remove(file_path)
-                except Exception:
-                    pass
-            upload_volume.commit()
-
-    @app.post("/v1/audio/transcriptions-from-url", dependencies=[Depends(apikey_auth)])
-    def transcribe_from_url(
-        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),
-    ):
-        unique_filename, _audio_suffix = download_audio_to_volume(audio_file_url)
-        try:
-            func = transcriber_file.transcribe_segment.spawn(
-                filename=unique_filename,
-                timestamp_offset=timestamp_offset,
-                language=language,
-            )
-            result = func.get()
-            return result
-        finally:
-            try:
-                file_path = f"{UPLOADS_PATH}/{unique_filename}"
-                os.remove(file_path)
-                upload_volume.commit()
-            except Exception:
-                pass
-
-    return app
-
-
-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()

gpu/self_hosted/.env.example

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

gpu/self_hosted/.gitignore

@@ -1,38 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,73 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,208 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

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

gpu/self_hosted/main.py

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

gpu/self_hosted/pyproject.toml

@@ -1,19 +0,0 @@
-[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

@@ -1,17 +0,0 @@
-#!/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/README.md

@@ -1,29 +1,3 @@
-## API Key Management
-
-### Finding Your User ID
-
-```bash
-# Get your OAuth sub (user ID) - requires authentication
-curl -H "Authorization: Bearer <your_jwt>" http://localhost:1250/v1/me
-# Returns: {"sub": "your-oauth-sub-here", "email": "...", ...}
-```
-
-### Creating API Keys
-
-```bash
-curl -X POST http://localhost:1250/v1/user/api-keys \
-  -H "Authorization: Bearer <your_jwt>" \
-  -H "Content-Type: application/json" \
-  -d '{"name": "My API Key"}'
-```
-
-### Using API Keys
-
-```bash
-# Use X-API-Key header instead of Authorization
-curl -H "X-API-Key: <your_api_key>" http://localhost:1250/v1/transcripts
-```
-
 ## AWS S3/SQS usage clarification
 
 Whereby.com uploads recordings directly to our S3 bucket when meetings end.

server/docs/gpu/api-transcription.md

@@ -1,194 +0,0 @@
-## Reflector GPU Transcription API (Specification)
-
-This document defines the Reflector GPU transcription API that all implementations must adhere to. Current implementations include NVIDIA Parakeet (NeMo) and Whisper (faster-whisper), both deployed on Modal.com. The API surface and response shapes are OpenAI/Whisper-compatible, so clients can switch implementations by changing only the base URL.
-
-### Base URL and Authentication
-
-- Example base URLs (Modal web endpoints):
-
-  - Parakeet: `https://<account>--reflector-transcriber-parakeet-web.modal.run`
-  - Whisper: `https://<account>--reflector-transcriber-web.modal.run`
-
-- All endpoints are served under `/v1` and require a Bearer token:
-
-```
-Authorization: Bearer <REFLECTOR_GPU_APIKEY>
-```
-
-Note: To switch implementations, deploy the desired variant and point `TRANSCRIPT_URL` to its base URL. The API is identical.
-
-### Supported file types
-
-`mp3, mp4, mpeg, mpga, m4a, wav, webm`
-
-### Models and languages
-
-- Parakeet (NVIDIA NeMo): default `nvidia/parakeet-tdt-0.6b-v2`
-  - Language support: only `en`. Other languages return HTTP 400.
-- Whisper (faster-whisper): default `large-v2` (or deployment-specific)
-  - Language support: multilingual (per Whisper model capabilities).
-
-Note: The `model` parameter is accepted by all implementations for interface parity. Some backends may treat it as informational.
-
-### Endpoints
-
-#### POST /v1/audio/transcriptions
-
-Transcribe one or more uploaded audio files.
-
-Request: multipart/form-data
-
-- `file` (File) — optional. Single file to transcribe.
-- `files` (File[]) — optional. One or more files to transcribe.
-- `model` (string) — optional. Defaults to the implementation-specific model (see above).
-- `language` (string) — optional, defaults to `en`.
-  - Parakeet: only `en` is accepted; other values return HTTP 400
-  - Whisper: model-dependent; typically multilingual
-- `batch` (boolean) — optional, defaults to `false`.
-
-Notes:
-
-- Provide either `file` or `files`, not both. If neither is provided, HTTP 400.
-- `batch` requires `files`; using `batch=true` without `files` returns HTTP 400.
-- Response shape for multiple files is the same regardless of `batch`.
-- Files sent to this endpoint are processed in a single pass (no VAD/chunking). This is intended for short clips (roughly ≤ 30s; depends on GPU memory/model). For longer audio, prefer `/v1/audio/transcriptions-from-url` which supports VAD-based chunking.
-
-Responses
-
-Single file response:
-
-```json
-{
-  "text": "transcribed text",
-  "words": [
-    { "word": "hello", "start": 0.0, "end": 0.5 },
-    { "word": "world", "start": 0.5, "end": 1.0 }
-  ],
-  "filename": "audio.mp3"
-}
-```
-
-Multiple files response:
-
-```json
-{
-  "results": [
-    {"filename": "a1.mp3", "text": "...", "words": [...]},
-    {"filename": "a2.mp3", "text": "...", "words": [...]}]
-}
-```
-
-Notes:
-
-- Word objects always include keys: `word`, `start`, `end`.
-- Some implementations may include a trailing space in `word` to match Whisper tokenization behavior; clients should trim if needed.
-
-Example curl (single file):
-
-```bash
-curl -X POST \
-  -H "Authorization: Bearer $REFLECTOR_GPU_APIKEY" \
-  -F "file=@/path/to/audio.mp3" \
-  -F "language=en" \
-  "$BASE_URL/v1/audio/transcriptions"
-```
-
-Example curl (multiple files, batch):
-
-```bash
-curl -X POST \
-  -H "Authorization: Bearer $REFLECTOR_GPU_APIKEY" \
-  -F "files=@/path/a1.mp3" -F "files=@/path/a2.mp3" \
-  -F "batch=true" -F "language=en" \
-  "$BASE_URL/v1/audio/transcriptions"
-```
-
-#### POST /v1/audio/transcriptions-from-url
-
-Transcribe a single remote audio file by URL.
-
-Request: application/json
-
-Body parameters:
-
-- `audio_file_url` (string) — required. URL of the audio file to transcribe.
-- `model` (string) — optional. Defaults to the implementation-specific model (see above).
-- `language` (string) — optional, defaults to `en`. Parakeet only accepts `en`.
-- `timestamp_offset` (number) — optional, defaults to `0.0`. Added to each word's `start`/`end` in the response.
-
-```json
-{
-  "audio_file_url": "https://example.com/audio.mp3",
-  "model": "nvidia/parakeet-tdt-0.6b-v2",
-  "language": "en",
-  "timestamp_offset": 0.0
-}
-```
-
-Response:
-
-```json
-{
-  "text": "transcribed text",
-  "words": [
-    { "word": "hello", "start": 10.0, "end": 10.5 },
-    { "word": "world", "start": 10.5, "end": 11.0 }
-  ]
-}
-```
-
-Notes:
-
-- `timestamp_offset` is added to each word’s `start`/`end` in the response.
-- Implementations may perform VAD-based chunking and batching for long-form audio; word timings are adjusted accordingly.
-
-Example curl:
-
-```bash
-curl -X POST \
-  -H "Authorization: Bearer $REFLECTOR_GPU_APIKEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-        "audio_file_url": "https://example.com/audio.mp3",
-        "language": "en",
-        "timestamp_offset": 0
-      }' \
-  "$BASE_URL/v1/audio/transcriptions-from-url"
-```
-
-### Error handling
-
-- 400 Bad Request
-  - Parakeet: `language` other than `en`
-  - Missing required parameters (`file`/`files` for upload; `audio_file_url` for URL endpoint)
-  - Unsupported file extension
-- 401 Unauthorized
-  - Missing or invalid Bearer token
-- 404 Not Found
-  - `audio_file_url` does not exist
-
-### Implementation details
-
-- GPUs: A10G for small-file/live, L40S for large-file URL transcription (subject to deployment)
-- VAD chunking and segment batching; word timings adjusted and overlapping ends constrained
-- Pads very short segments (< 0.5s) to avoid model crashes on some backends
-
-### Server configuration (Reflector API)
-
-Set the Reflector server to use the Modal backend and point `TRANSCRIPT_URL` to your chosen deployment:
-
-```
-TRANSCRIPT_BACKEND=modal
-TRANSCRIPT_URL=https://<account>--reflector-transcriber-parakeet-web.modal.run
-TRANSCRIPT_MODAL_API_KEY=<REFLECTOR_GPU_APIKEY>
-```
-
-### Conformance tests
-
-Use the pytest-based conformance tests to validate any new implementation (including self-hosted) against this spec:
-
-```
-TRANSCRIPT_URL=https://<your-deployment-base> \
-TRANSCRIPT_MODAL_API_KEY=your-api-key \
-uv run -m pytest -m model_api --no-cov server/tests/test_model_api_transcript.py
-```

server/docs/webhook.md

@@ -14,7 +14,7 @@ Webhooks are configured at the room level with two fields:
 
 ### `transcript.completed`
 
-Triggered when a transcript has been fully processed, including transcription, diarization, summarization, topic detection and calendar event integration.
+Triggered when a transcript has been fully processed, including transcription, diarization, summarization, and topic detection.
 
 ### `test`
 
@@ -128,27 +128,6 @@ This event includes a convenient URL for accessing the transcript:
   "room": {
     "id": "room-789",
     "name": "Product Team Room"
-  },
-  "calendar_event": {
-    "id": "calendar-event-123",
-    "ics_uid": "event-123",
-    "title": "Q3 Product Planning Meeting",
-    "start_time": "2025-08-27T12:00:00Z",
-    "end_time": "2025-08-27T12:30:00Z",
-    "description": "Team discussed Q3 product roadmap, prioritizing mobile app features and API improvements.",
-    "location": "Conference Room 1",
-    "attendees": [
-      {
-        "id": "participant-1",
-        "name": "John Doe",
-        "speaker": "Speaker 1"
-      },
-      {
-        "id": "participant-2",
-        "name": "Jane Smith",
-        "speaker": "Speaker 2"
-      }
-    ]
   }
 }
 ```

server/env.example

@@ -27,7 +27,7 @@ AUTH_JWT_AUDIENCE=
 #TRANSCRIPT_MODAL_API_KEY=xxxxx
 
 TRANSCRIPT_BACKEND=modal
-TRANSCRIPT_URL=https://monadical-sas--reflector-transcriber-parakeet-web.modal.run
+TRANSCRIPT_URL=https://monadical-sas--reflector-transcriber-web.modal.run
 TRANSCRIPT_MODAL_API_KEY=
 
 ## =======================================================

server/gpu/modal_deployments/reflector_transcriber.py

@@ -0,0 +1,161 @@
+import os
+import tempfile
+import threading
+
+import modal
+from pydantic import BaseModel
+
+MODELS_DIR = "/models"
+
+MODEL_NAME = "large-v2"
+MODEL_COMPUTE_TYPE: str = "float16"
+MODEL_NUM_WORKERS: int = 1
+
+MINUTES = 60  # seconds
+
+volume = modal.Volume.from_name("models", create_if_missing=True)
+
+app = modal.App("reflector-transcriber")
+
+
+def download_model():
+    from faster_whisper import download_model
+
+    volume.reload()
+
+    download_model(MODEL_NAME, cache_dir=MODELS_DIR)
+
+    volume.commit()
+
+
+image = (
+    modal.Image.debian_slim(python_version="3.12")
+    .pip_install(
+        "huggingface_hub==0.27.1",
+        "hf-transfer==0.1.9",
+        "torch==2.5.1",
+        "faster-whisper==1.1.1",
+    )
+    .env(
+        {
+            "HF_HUB_ENABLE_HF_TRANSFER": "1",
+            "LD_LIBRARY_PATH": (
+                "/usr/local/lib/python3.12/site-packages/nvidia/cudnn/lib/:"
+                "/opt/conda/lib/python3.12/site-packages/nvidia/cublas/lib/"
+            ),
+        }
+    )
+    .run_function(download_model, volumes={MODELS_DIR: volume})
+)
+
+
+@app.cls(
+    gpu="A10G",
+    timeout=5 * MINUTES,
+    scaledown_window=5 * MINUTES,
+    allow_concurrent_inputs=6,
+    image=image,
+    volumes={MODELS_DIR: volume},
+)
+class Transcriber:
+    @modal.enter()
+    def enter(self):
+        import faster_whisper
+        import torch
+
+        self.lock = threading.Lock()
+        self.use_gpu = torch.cuda.is_available()
+        self.device = "cuda" if self.use_gpu else "cpu"
+        self.model = faster_whisper.WhisperModel(
+            MODEL_NAME,
+            device=self.device,
+            compute_type=MODEL_COMPUTE_TYPE,
+            num_workers=MODEL_NUM_WORKERS,
+            download_root=MODELS_DIR,
+            local_files_only=True,
+        )
+
+    @modal.method()
+    def transcribe_segment(
+        self,
+        audio_data: str,
+        audio_suffix: str,
+        language: str,
+    ):
+        with tempfile.NamedTemporaryFile("wb+", suffix=f".{audio_suffix}") as fp:
+            fp.write(audio_data)
+
+            with self.lock:
+                segments, _ = self.model.transcribe(
+                    fp.name,
+                    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)
+            words = [
+                {"word": word.word, "start": word.start, "end": word.end}
+                for segment in segments
+                for word in segment.words
+            ]
+
+            return {"text": text, "words": words}
+
+
+@app.function(
+    scaledown_window=60,
+    timeout=60,
+    allow_concurrent_inputs=40,
+    secrets=[
+        modal.Secret.from_name("reflector-gpu"),
+    ],
+    volumes={MODELS_DIR: volume},
+)
+@modal.asgi_app()
+def web():
+    from fastapi import Body, Depends, FastAPI, HTTPException, UploadFile, status
+    from fastapi.security import OAuth2PasswordBearer
+    from typing_extensions import Annotated
+
+    transcriber = Transcriber()
+
+    app = FastAPI()
+
+    oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+    supported_file_types = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
+
+    def apikey_auth(apikey: str = Depends(oauth2_scheme)):
+        if apikey != os.environ["REFLECTOR_GPU_APIKEY"]:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid API key",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+
+    class TranscriptResponse(BaseModel):
+        result: dict
+
+    @app.post("/v1/audio/transcriptions", dependencies=[Depends(apikey_auth)])
+    def transcribe(
+        file: UploadFile,
+        model: str = "whisper-1",
+        language: Annotated[str, Body(...)] = "en",
+    ) -> TranscriptResponse:
+        audio_data = file.file.read()
+        audio_suffix = file.filename.split(".")[-1]
+        assert audio_suffix in supported_file_types
+
+        func = transcriber.transcribe_segment.spawn(
+            audio_data=audio_data,
+            audio_suffix=audio_suffix,
+            language=language,
+        )
+        result = func.get()
+        return result
+
+    return app

server/gpu/modal_deployments/reflector_transcriber_parakeet.py

@@ -77,7 +77,7 @@ image = (
     .pip_install(
         "hf_transfer==0.1.9",
         "huggingface_hub[hf-xet]==0.31.2",
-        "nemo_toolkit[asr]==2.5.0",
+        "nemo_toolkit[asr]==2.3.0",
         "cuda-python==12.8.0",
         "fastapi==0.115.12",
         "numpy<2",

server/migrations/versions/0ce521cda2ee_remove_user_id_from_meeting_table.py

@@ -1,36 +0,0 @@
-"""remove user_id from meeting table
-
-Revision ID: 0ce521cda2ee
-Revises: 6dec9fb5b46c
-Create Date: 2025-09-10 12:40:55.688899
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "0ce521cda2ee"
-down_revision: Union[str, None] = "6dec9fb5b46c"
-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.drop_column("user_id")
-
-    # ### 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.add_column(
-            sa.Column("user_id", sa.VARCHAR(), autoincrement=False, nullable=True)
-        )
-
-    # ### end Alembic commands ###

server/migrations/versions/2ae3db106d4e_clean_up_orphaned_room_id_references_in_.py

@@ -1,32 +0,0 @@
-"""clean up orphaned room_id references in meeting table
-
-Revision ID: 2ae3db106d4e
-Revises: def1b5867d4c
-Create Date: 2025-09-11 10:35:15.759967
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "2ae3db106d4e"
-down_revision: Union[str, None] = "def1b5867d4c"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # Set room_id to NULL for meetings that reference non-existent rooms
-    op.execute("""
-        UPDATE meeting
-        SET room_id = NULL
-        WHERE room_id IS NOT NULL
-          AND room_id NOT IN (SELECT id FROM room WHERE id IS NOT NULL)
-    """)
-
-
-def downgrade() -> None:
-    # Cannot restore orphaned references - no operation needed
-    pass

server/migrations/versions/6025e9b2bef2_remove_one_active_meeting_per_room_.py

@@ -1,53 +0,0 @@
-"""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

@@ -1,35 +0,0 @@
-"""make meeting room_id required and add foreign key
-
-Revision ID: 6dec9fb5b46c
-Revises: 61882a919591
-Create Date: 2025-09-10 10:47:06.006819
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "6dec9fb5b46c"
-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.create_foreign_key(
-            None, "room", ["room_id"], ["id"], ondelete="CASCADE"
-        )
-
-    # ### 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_constraint("meeting_room_id_fkey", type_="foreignkey")
-
-    # ### end Alembic commands ###

server/migrations/versions/9e3f7b2a4c8e_add_user_api_keys.py

@@ -1,38 +0,0 @@
-"""add user api keys
-
-Revision ID: 9e3f7b2a4c8e
-Revises: dc035ff72fd5
-Create Date: 2025-10-17 00:00:00.000000
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "9e3f7b2a4c8e"
-down_revision: Union[str, None] = "dc035ff72fd5"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    op.create_table(
-        "user_api_key",
-        sa.Column("id", sa.String(), nullable=False),
-        sa.Column("user_id", sa.String(), nullable=False),
-        sa.Column("key_hash", sa.String(), nullable=False),
-        sa.Column("name", sa.String(), nullable=True),
-        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
-        sa.PrimaryKeyConstraint("id"),
-    )
-
-    with op.batch_alter_table("user_api_key", schema=None) as batch_op:
-        batch_op.create_index("idx_user_api_key_hash", ["key_hash"], unique=True)
-        batch_op.create_index("idx_user_api_key_user_id", ["user_id"], unique=False)
-
-
-def downgrade() -> None:
-    op.drop_table("user_api_key")

server/migrations/versions/d4a1c446458c_add_grace_period_fields_to_meeting.py

@@ -1,34 +0,0 @@
-"""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

@@ -1,129 +0,0 @@
-"""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

@@ -1,43 +0,0 @@
-"""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/migrations/versions/def1b5867d4c_make_meeting_room_id_nullable_but_keep_.py

@@ -1,34 +0,0 @@
-"""make meeting room_id nullable but keep foreign key
-
-Revision ID: def1b5867d4c
-Revises: 0ce521cda2ee
-Create Date: 2025-09-11 09:42:18.697264
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "def1b5867d4c"
-down_revision: Union[str, None] = "0ce521cda2ee"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.alter_column("room_id", existing_type=sa.VARCHAR(), nullable=True)
-
-    # ### 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.alter_column("room_id", existing_type=sa.VARCHAR(), nullable=False)
-
-    # ### end Alembic commands ###

server/pyproject.toml

@@ -12,6 +12,7 @@ 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",
@@ -26,6 +27,7 @@ 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",
@@ -38,7 +40,6 @@ dependencies = [
     "llama-index-llms-openai-like>=0.4.0",
     "pytest-env>=1.1.5",
     "webvtt-py>=0.5.0",
-    "icalendar>=6.0.0",
 ]
 
 [dependency-groups]
@@ -112,14 +113,13 @@ source = ["reflector"]
 [tool.pytest_env]
 ENVIRONMENT = "pytest"
 DATABASE_URL = "postgresql://test_user:test_password@localhost:15432/reflector_test"
-AUTH_BACKEND = "jwt"
 
 [tool.pytest.ini_options]
 addopts = "-ra -q --disable-pytest-warnings --cov --cov-report html -v"
 testpaths = ["tests"]
 asyncio_mode = "auto"
 markers = [
-    "model_api: tests for the unified model-serving HTTP API (backend- and hardware-agnostic)",
+    "gpu_modal: mark test to run only with GPU Modal endpoints (deselect with '-m \"not gpu_modal\"')",
 ]
 
 [tool.ruff.lint]
@@ -131,7 +131,7 @@ select = [
 
 [tool.ruff.lint.per-file-ignores]
 "reflector/processors/summary/summary_builder.py" = ["E501"]
-"gpu/modal_deployments/**.py" = ["PLC0415"]
+"gpu/**.py" = ["PLC0415"]
 "reflector/tools/**.py" = ["PLC0415"]
 "migrations/versions/**.py" = ["PLC0415"]
 "tests/**.py" = ["PLC0415"]

server/reflector/app.py

@@ -26,8 +26,6 @@ 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.user_api_keys import router as user_api_keys_router
-from reflector.views.user_websocket import router as user_ws_router
 from reflector.views.whereby import router as whereby_router
 from reflector.views.zulip import router as zulip_router
 
@@ -67,12 +65,6 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-
-@app.get("/health")
-async def health():
-    return {"status": "healthy"}
-
-
 # metrics
 instrumentator = Instrumentator(
     excluded_handlers=["/docs", "/metrics"],
@@ -92,8 +84,6 @@ app.include_router(transcripts_websocket_router, prefix="/v1")
 app.include_router(transcripts_webrtc_router, prefix="/v1")
 app.include_router(transcripts_process_router, prefix="/v1")
 app.include_router(user_router, prefix="/v1")
-app.include_router(user_api_keys_router, prefix="/v1")
-app.include_router(user_ws_router, prefix="/v1")
 app.include_router(zulip_router, prefix="/v1")
 app.include_router(whereby_router, prefix="/v1")
 add_pagination(app)

server/reflector/auth/auth_jwt.py

@@ -1,16 +1,14 @@
-from typing import Annotated, List, Optional
+from typing import Annotated, Optional
 
 from fastapi import Depends, HTTPException
-from fastapi.security import APIKeyHeader, OAuth2PasswordBearer
+from fastapi.security import OAuth2PasswordBearer
 from jose import JWTError, jwt
 from pydantic import BaseModel
 
-from reflector.db.user_api_keys import user_api_keys_controller
 from reflector.logger import logger
 from reflector.settings import settings
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token", auto_error=False)
-api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
 
 jwt_public_key = open(f"reflector/auth/jwt/keys/{settings.AUTH_JWT_PUBLIC_KEY}").read()
 jwt_algorithm = settings.AUTH_JWT_ALGORITHM
@@ -28,7 +26,7 @@ class JWTException(Exception):
 
 class UserInfo(BaseModel):
     sub: str
-    email: Optional[str] = None
+    email: str
 
     def __getitem__(self, key):
         return getattr(self, key)
@@ -60,53 +58,33 @@ def authenticated(token: Annotated[str, Depends(oauth2_scheme)]):
     return None
 
 
-async def _authenticate_user(
-    jwt_token: Optional[str],
-    api_key: Optional[str],
-    jwtauth: JWTAuth,
-) -> UserInfo | None:
-    user_infos: List[UserInfo] = []
-    if api_key:
-        user_api_key = await user_api_keys_controller.verify_key(api_key)
-        if user_api_key:
-            user_infos.append(UserInfo(sub=user_api_key.user_id, email=None))
-
-    if jwt_token:
-        try:
-            payload = jwtauth.verify_token(jwt_token)
-            sub = payload["sub"]
-            email = payload["email"]
-            user_infos.append(UserInfo(sub=sub, email=email))
-        except JWTError as e:
-            logger.error(f"JWT error: {e}")
-            raise HTTPException(status_code=401, detail="Invalid authentication")
-
-    if len(user_infos) == 0:
-        return None
-
-    if len(set([x.sub for x in user_infos])) > 1:
-        raise JWTException(
-            status_code=401,
-            detail="Invalid authentication: more than one user provided",
-        )
-
-    return user_infos[0]
-
-
-async def current_user(
-    jwt_token: Annotated[Optional[str], Depends(oauth2_scheme)],
-    api_key: Annotated[Optional[str], Depends(api_key_header)],
+def current_user(
+    token: Annotated[Optional[str], Depends(oauth2_scheme)],
     jwtauth: JWTAuth = Depends(),
 ):
-    user = await _authenticate_user(jwt_token, api_key, jwtauth)
-    if user is None:
+    if token is None:
         raise HTTPException(status_code=401, detail="Not authenticated")
-    return user
+    try:
+        payload = jwtauth.verify_token(token)
+        sub = payload["sub"]
+        return UserInfo(sub=sub)
+    except JWTError as e:
+        logger.error(f"JWT error: {e}")
+        raise HTTPException(status_code=401, detail="Invalid authentication")
 
 
-async def current_user_optional(
-    jwt_token: Annotated[Optional[str], Depends(oauth2_scheme)],
-    api_key: Annotated[Optional[str], Depends(api_key_header)],
+def current_user_optional(
+    token: Annotated[Optional[str], Depends(oauth2_scheme)],
     jwtauth: JWTAuth = Depends(),
 ):
-    return await _authenticate_user(jwt_token, api_key, jwtauth)
+    # we accept no token, but if one is provided, it must be a valid one.
+    if token is None:
+        return None
+    try:
+        payload = jwtauth.verify_token(token)
+        sub = payload["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,12 +24,10 @@ 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
 import reflector.db.transcripts  # noqa
-import reflector.db.user_api_keys  # noqa
 
 kwargs = {}
 if "postgres" not in settings.DATABASE_URL:

server/reflector/db/calendar_events.py

@@ -1,187 +0,0 @@
-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_id(self, event_id: str) -> CalendarEvent | None:
-        query = calendar_events.select().where(calendar_events.c.id == event_id)
-        result = await get_database().fetch_one(query)
-        return CalendarEvent(**result) if result else None
-
-    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,9 +1,9 @@
 from datetime import datetime
-from typing import Any, Literal
+from typing import Literal
 
 import sqlalchemy as sa
+from fastapi import HTTPException
 from pydantic import BaseModel, Field
-from sqlalchemy.dialects.postgresql import JSONB
 
 from reflector.db import get_database, metadata
 from reflector.db.rooms import Room
@@ -18,12 +18,8 @@ meetings = sa.Table(
     sa.Column("host_room_url", sa.String),
     sa.Column("start_date", sa.DateTime(timezone=True)),
     sa.Column("end_date", sa.DateTime(timezone=True)),
-    sa.Column(
-        "room_id",
-        sa.String,
-        sa.ForeignKey("room.id", ondelete="CASCADE"),
-        nullable=True,
-    ),
+    sa.Column("user_id", sa.String),
+    sa.Column("room_id", sa.String),
     sa.Column("is_locked", sa.Boolean, nullable=False, server_default=sa.false()),
     sa.Column("room_mode", sa.String, nullable=False, server_default="normal"),
     sa.Column("recording_type", sa.String, nullable=False, server_default="cloud"),
@@ -45,18 +41,13 @@ meetings = sa.Table(
         nullable=False,
         server_default=sa.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"),
+    sa.Index(
+        "idx_one_active_meeting_per_room",
+        "room_id",
+        unique=True,
+        postgresql_where=sa.text("is_active = true"),
+    ),
 )
 
 meeting_consent = sa.Table(
@@ -90,7 +81,8 @@ class Meeting(BaseModel):
     host_room_url: str
     start_date: datetime
     end_date: datetime
-    room_id: str | None
+    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"
@@ -98,9 +90,6 @@ class Meeting(BaseModel):
         "none", "prompt", "automatic", "automatic-2nd-participant"
     ] = "automatic-2nd-participant"
     num_clients: int = 0
-    is_active: bool = True
-    calendar_event_id: str | None = None
-    calendar_metadata: dict[str, Any] | None = None
 
 
 class MeetingController:
@@ -112,10 +101,12 @@ class MeetingController:
         host_room_url: str,
         start_date: datetime,
         end_date: datetime,
+        user_id: str,
         room: Room,
-        calendar_event_id: str | None = None,
-        calendar_metadata: dict[str, Any] | None = None,
     ):
+        """
+        Create a new meeting
+        """
         meeting = Meeting(
             id=id,
             room_name=room_name,
@@ -123,46 +114,41 @@ class MeetingController:
             host_room_url=host_room_url,
             start_date=start_date,
             end_date=end_date,
+            user_id=user_id,
             room_id=room.id,
             is_locked=room.is_locked,
             room_mode=room.room_mode,
             recording_type=room.recording_type,
             recording_trigger=room.recording_trigger,
-            calendar_event_id=calendar_event_id,
-            calendar_metadata=calendar_metadata,
         )
         query = meetings.insert().values(**meeting.model_dump())
         await get_database().execute(query)
         return meeting
 
     async def get_all_active(self) -> list[Meeting]:
+        """
+        Get active meetings.
+        """
         query = meetings.select().where(meetings.c.is_active)
         return await get_database().fetch_all(query)
 
     async def get_by_room_name(
         self,
         room_name: str,
-    ) -> Meeting | None:
+    ) -> Meeting:
         """
         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())
-        )
+        query = meetings.select().where(meetings.c.room_name == room_name)
         result = await get_database().fetch_one(query)
         if not result:
             return None
 
         return Meeting(**result)
 
-    async def get_active(self, room: Room, current_time: datetime) -> Meeting | None:
+    async def get_active(self, room: Room, current_time: datetime) -> Meeting:
         """
         Get latest active meeting for a room.
-        For backward compatibility, returns the most recent active meeting.
         """
         end_date = getattr(meetings.c, "end_date")
         query = (
@@ -182,58 +168,32 @@ 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:
+        """
+        Get a meeting by id
+        """
         query = meetings.select().where(meetings.c.id == meeting_id)
         result = await get_database().fetch_one(query)
         if not result:
             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
-        )
+    async def get_by_id_for_http(self, meeting_id: str, user_id: str | None) -> Meeting:
+        """
+        Get a meeting by ID for HTTP request.
+
+        If not found, it will raise a 404 error.
+        """
+        query = meetings.select().where(meetings.c.id == meeting_id)
         result = await get_database().fetch_one(query)
         if not result:
-            return None
-        return Meeting(**result)
+            raise HTTPException(status_code=404, detail="Meeting not found")
+
+        meeting = Meeting(**result)
+        if result["user_id"] != user_id:
+            meeting.host_room_url = ""
+
+        return meeting
 
     async def update_meeting(self, meeting_id: str, **kwargs):
         query = meetings.update().where(meetings.c.id == meeting_id).values(**kwargs)
@@ -259,9 +219,10 @@ class MeetingConsentController:
         result = await get_database().fetch_one(query)
         if result is None:
             return None
-        return MeetingConsent(**result)
+        return MeetingConsent(**result) if result else None
 
     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

@@ -43,15 +43,7 @@ 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(
-        "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"),
 )
 
 
@@ -72,11 +64,6 @@ class Room(BaseModel):
     is_shared: bool = False
     webhook_url: str | None = None
     webhook_secret: str | None = None
-    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:
@@ -127,9 +114,6 @@ class RoomController:
         is_shared: bool,
         webhook_url: str = "",
         webhook_secret: str = "",
-        ics_url: str | None = None,
-        ics_fetch_interval: int = 300,
-        ics_enabled: bool = False,
     ):
         """
         Add a new room
@@ -150,9 +134,6 @@ class RoomController:
             is_shared=is_shared,
             webhook_url=webhook_url,
             webhook_secret=webhook_secret,
-            ics_url=ics_url,
-            ics_fetch_interval=ics_fetch_interval,
-            ics_enabled=ics_enabled,
         )
         query = rooms.insert().values(**room.model_dump())
         try:
@@ -217,13 +198,6 @@ 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/db/search.py

@@ -23,7 +23,7 @@ from pydantic import (
 
 from reflector.db import get_database
 from reflector.db.rooms import rooms
-from reflector.db.transcripts import SourceKind, TranscriptStatus, transcripts
+from reflector.db.transcripts import SourceKind, transcripts
 from reflector.db.utils import is_postgresql
 from reflector.logger import logger
 from reflector.utils.string import NonEmptyString, try_parse_non_empty_string
@@ -161,7 +161,7 @@ class SearchResult(BaseModel):
     room_name: str | None = None
     source_kind: SourceKind
     created_at: datetime
-    status: TranscriptStatus = Field(..., min_length=1)
+    status: str = Field(..., min_length=1)
     rank: float = Field(..., ge=0, le=1)
     duration: NonNegativeFloat | None = Field(..., description="Duration in seconds")
     search_snippets: list[str] = Field(

server/reflector/db/transcripts.py

@@ -647,19 +647,6 @@ class TranscriptController:
         query = transcripts.delete().where(transcripts.c.recording_id == recording_id)
         await get_database().execute(query)
 
-    @staticmethod
-    def user_can_mutate(transcript: Transcript, user_id: str | None) -> bool:
-        """
-        Returns True if the given user is allowed to modify the transcript.
-
-        Policy:
-        - Anonymous transcripts (user_id is None) cannot be modified via API
-        - Only the owner (matching user_id) can modify their transcript
-        """
-        if transcript.user_id is None:
-            return False
-        return user_id and transcript.user_id == user_id
-
     @asynccontextmanager
     async def transaction(self):
         """

server/reflector/db/user_api_keys.py

@@ -1,90 +0,0 @@
-import hmac
-import secrets
-from datetime import datetime, timezone
-from hashlib import sha256
-
-import sqlalchemy
-from pydantic import BaseModel, Field
-
-from reflector.db import get_database, metadata
-from reflector.settings import settings
-from reflector.utils import generate_uuid4
-from reflector.utils.string import NonEmptyString
-
-user_api_keys = sqlalchemy.Table(
-    "user_api_key",
-    metadata,
-    sqlalchemy.Column("id", sqlalchemy.String, primary_key=True),
-    sqlalchemy.Column("user_id", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("key_hash", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("name", sqlalchemy.String, nullable=True),
-    sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True), nullable=False),
-    sqlalchemy.Index("idx_user_api_key_hash", "key_hash", unique=True),
-    sqlalchemy.Index("idx_user_api_key_user_id", "user_id"),
-)
-
-
-class UserApiKey(BaseModel):
-    id: NonEmptyString = Field(default_factory=generate_uuid4)
-    user_id: NonEmptyString
-    key_hash: NonEmptyString
-    name: NonEmptyString | None = None
-    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-
-
-class UserApiKeyController:
-    @staticmethod
-    def generate_key() -> NonEmptyString:
-        return secrets.token_urlsafe(48)
-
-    @staticmethod
-    def hash_key(key: NonEmptyString) -> str:
-        return hmac.new(
-            settings.SECRET_KEY.encode(), key.encode(), digestmod=sha256
-        ).hexdigest()
-
-    @classmethod
-    async def create_key(
-        cls,
-        user_id: NonEmptyString,
-        name: NonEmptyString | None = None,
-    ) -> tuple[UserApiKey, NonEmptyString]:
-        plaintext = cls.generate_key()
-        api_key = UserApiKey(
-            user_id=user_id,
-            key_hash=cls.hash_key(plaintext),
-            name=name,
-        )
-        query = user_api_keys.insert().values(**api_key.model_dump())
-        await get_database().execute(query)
-        return api_key, plaintext
-
-    @classmethod
-    async def verify_key(cls, plaintext_key: NonEmptyString) -> UserApiKey | None:
-        key_hash = cls.hash_key(plaintext_key)
-        query = user_api_keys.select().where(
-            user_api_keys.c.key_hash == key_hash,
-        )
-        result = await get_database().fetch_one(query)
-        return UserApiKey(**result) if result else None
-
-    @staticmethod
-    async def list_by_user_id(user_id: NonEmptyString) -> list[UserApiKey]:
-        query = (
-            user_api_keys.select()
-            .where(user_api_keys.c.user_id == user_id)
-            .order_by(user_api_keys.c.created_at.desc())
-        )
-        results = await get_database().fetch_all(query)
-        return [UserApiKey(**r) for r in results]
-
-    @staticmethod
-    async def delete_key(key_id: NonEmptyString, user_id: NonEmptyString) -> bool:
-        query = user_api_keys.delete().where(
-            (user_api_keys.c.id == key_id) & (user_api_keys.c.user_id == user_id)
-        )
-        result = await get_database().execute(query)
-        return result > 0
-
-
-user_api_keys_controller = UserApiKeyController()

server/reflector/pipelines/main_file_pipeline.py

@@ -12,7 +12,7 @@ from pathlib import Path
 
 import av
 import structlog
-from celery import chain, shared_task
+from celery import shared_task
 
 from reflector.asynctask import asynctask
 from reflector.db.rooms import rooms_controller
@@ -26,8 +26,6 @@ from reflector.logger import logger
 from reflector.pipelines.main_live_pipeline import (
     PipelineMainBase,
     broadcast_to_sockets,
-    task_cleanup_consent,
-    task_pipeline_post_to_zulip,
 )
 from reflector.processors import (
     AudioFileWriterProcessor,
@@ -131,7 +129,7 @@ class PipelineMainFile(PipelineMainBase):
 
         self.logger.info("File pipeline complete")
 
-        await self.set_status(transcript.id, "ended")
+        await transcripts_controller.set_status(transcript.id, "ended")
 
     async def extract_and_write_audio(
         self, file_path: Path, transcript: Transcript
@@ -381,28 +379,6 @@ class PipelineMainFile(PipelineMainBase):
         await processor.flush()
 
 
-@shared_task
-@asynctask
-async def task_send_webhook_if_needed(*, transcript_id: str):
-    """Send webhook if this is a room recording with webhook configured"""
-    transcript = await transcripts_controller.get_by_id(transcript_id)
-    if not transcript:
-        return
-
-    if transcript.source_kind == SourceKind.ROOM and transcript.room_id:
-        room = await rooms_controller.get_by_id(transcript.room_id)
-        if room and room.webhook_url:
-            logger.info(
-                "Dispatching webhook",
-                transcript_id=transcript_id,
-                room_id=room.id,
-                webhook_url=room.webhook_url,
-            )
-            send_transcript_webhook.delay(
-                transcript_id, room.id, event_id=uuid.uuid4().hex
-            )
-
-
 @shared_task
 @asynctask
 async def task_pipeline_file_process(*, transcript_id: str):
@@ -430,10 +406,16 @@ async def task_pipeline_file_process(*, transcript_id: str):
         await pipeline.set_status(transcript_id, "error")
         raise
 
-    # Run post-processing chain: consent cleanup -> zulip -> webhook
-    post_chain = chain(
-        task_cleanup_consent.si(transcript_id=transcript_id),
-        task_pipeline_post_to_zulip.si(transcript_id=transcript_id),
-        task_send_webhook_if_needed.si(transcript_id=transcript_id),
-    )
-    post_chain.delay()
+    # Trigger webhook if this is a room recording with webhook configured
+    if transcript.source_kind == SourceKind.ROOM and transcript.room_id:
+        room = await rooms_controller.get_by_id(transcript.room_id)
+        if room and room.webhook_url:
+            logger.info(
+                "Dispatching webhook task",
+                transcript_id=transcript_id,
+                room_id=room.id,
+                webhook_url=room.webhook_url,
+            )
+            send_transcript_webhook.delay(
+                transcript_id, room.id, event_id=uuid.uuid4().hex
+            )

server/reflector/pipelines/main_live_pipeline.py

@@ -85,20 +85,6 @@ def broadcast_to_sockets(func):
             message=resp.model_dump(mode="json"),
         )
 
-        transcript = await transcripts_controller.get_by_id(self.transcript_id)
-        if transcript and transcript.user_id:
-            # Emit only relevant events to the user room to avoid noisy updates.
-            # Allowed: STATUS, FINAL_TITLE, DURATION. All are prefixed with TRANSCRIPT_
-            allowed_user_events = {"STATUS", "FINAL_TITLE", "DURATION"}
-            if resp.event in allowed_user_events:
-                await self.ws_manager.send_json(
-                    room_id=f"user:{transcript.user_id}",
-                    message={
-                        "event": f"TRANSCRIPT_{resp.event}",
-                        "data": {"id": self.transcript_id, **resp.data},
-                    },
-                )
-
     return wrapper
 
 

server/reflector/processors/file_diarization_modal.py

@@ -47,7 +47,6 @@ class FileDiarizationModalProcessor(FileDiarizationProcessor):
                     "audio_file_url": data.audio_url,
                     "timestamp": 0,
                 },
-                follow_redirects=True,
             )
             response.raise_for_status()
             diarization_data = response.json()["diarization"]

server/reflector/processors/file_transcript_modal.py

@@ -54,7 +54,6 @@ class FileTranscriptModalProcessor(FileTranscriptProcessor):
                     "language": data.language,
                     "batch": True,
                 },
-                follow_redirects=True,
             )
             response.raise_for_status()
             result = response.json()

server/reflector/processors/types.py

@@ -4,8 +4,11 @@ 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"""
@@ -17,6 +20,9 @@ class DiarizationSegment(TypedDict):
 
 PUNC_RE = re.compile(r"[.;:?!…]")
 
+profanity_filter = ProfanityFilter()
+profanity_filter.set_censor("*")
+
 
 class AudioFile(BaseModel):
     name: str
@@ -118,11 +124,21 @@ def words_to_segments(words: list[Word]) -> list[TranscriptSegment]:
 
 class Transcript(BaseModel):
     translation: str | None = None
-    words: list[Word] = []
+    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()
 
     @property
     def text(self):
-        return "".join([word.text for word in self.words])
+        # Censored text
+        return self._get_censored_text(self.raw_text)
 
     @property
     def human_timestamp(self):
@@ -154,6 +170,12 @@ 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,17 +1,10 @@
-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 = {}
 
 
@@ -28,12 +21,6 @@ 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.
@@ -62,87 +49,3 @@ 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

@@ -1,408 +0,0 @@
-"""
-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

@@ -1,8 +1,6 @@
 from pydantic.types import PositiveInt
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
-from reflector.utils.string import NonEmptyString
-
 
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
@@ -122,7 +120,7 @@ class Settings(BaseSettings):
 
     # Whereby integration
     WHEREBY_API_URL: str = "https://api.whereby.dev/v1"
-    WHEREBY_API_KEY: NonEmptyString | None = None
+    WHEREBY_API_KEY: str | None = None
     WHEREBY_WEBHOOK_SECRET: str | None = None
     AWS_WHEREBY_ACCESS_KEY_ID: str | None = None
     AWS_WHEREBY_ACCESS_KEY_SECRET: str | None = None

server/reflector/utils/string.py

@@ -10,11 +10,8 @@ NonEmptyString = Annotated[
 non_empty_string_adapter = TypeAdapter(NonEmptyString)
 
 
-def parse_non_empty_string(s: str, error: str | None = None) -> NonEmptyString:
-    try:
-        return non_empty_string_adapter.validate_python(s)
-    except Exception as e:
-        raise ValueError(f"{e}: {error}" if error else e) from e
+def parse_non_empty_string(s: str) -> NonEmptyString:
+    return non_empty_string_adapter.validate_python(s)
 
 
 def try_parse_non_empty_string(s: str) -> NonEmptyString | None:

server/reflector/views/meetings.py

@@ -10,7 +10,6 @@ from reflector.db.meetings import (
     meeting_consent_controller,
     meetings_controller,
 )
-from reflector.db.rooms import rooms_controller
 
 router = APIRouter()
 
@@ -42,34 +41,3 @@ 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,27 +1,34 @@
 import logging
+import sqlite3
 from datetime import datetime, timedelta, timezone
-from enum import Enum
-from typing import Annotated, Any, Literal, Optional
+from typing import Annotated, Literal, Optional
 
+import asyncpg.exceptions
 from fastapi import APIRouter, Depends, HTTPException
 from fastapi_pagination import Page
 from fastapi_pagination.ext.databases import 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 rooms_controller
-from reflector.redis_cache import RedisAsyncLock
-from reflector.services.ics_sync import ics_sync_service
 from reflector.settings import settings
 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:
+    """Parse ISO datetime string and ensure timezone awareness (defaults to UTC if naive)."""
+    dt = datetime.fromisoformat(iso_string)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
 
 class Room(BaseModel):
     id: str
@@ -36,11 +43,6 @@ class Room(BaseModel):
     recording_type: str
     recording_trigger: str
     is_shared: bool
-    ics_url: Optional[str] = None
-    ics_fetch_interval: int = 300
-    ics_enabled: bool = False
-    ics_last_sync: Optional[datetime] = None
-    ics_last_etag: Optional[str] = None
 
 
 class RoomDetails(Room):
@@ -52,22 +54,10 @@ 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):
@@ -82,30 +72,20 @@ class CreateRoom(BaseModel):
     is_shared: bool
     webhook_url: str
     webhook_secret: str
-    ics_url: Optional[str] = None
-    ics_fetch_interval: int = 300
-    ics_enabled: bool = False
 
 
 class UpdateRoom(BaseModel):
-    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
+    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
 
 
 class DeletionStatus(BaseModel):
@@ -120,59 +100,6 @@ 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)],
@@ -199,41 +126,15 @@ async def rooms_get(
     room = await rooms_controller.get_by_id_for_http(room_id, user_id=user_id)
     if not room:
         raise HTTPException(status_code=404, detail="Room not found")
-    if not room.is_shared and (user_id is None or room.user_id != user_id):
-        raise HTTPException(status_code=403, detail="Room access denied")
     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,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ):
-    user_id = user["sub"]
+    user_id = user["sub"] if user else None
 
     return await rooms_controller.add(
         name=room.name,
@@ -248,9 +149,6 @@ async def rooms_create(
         is_shared=room.is_shared,
         webhook_url=room.webhook_url,
         webhook_secret=room.webhook_secret,
-        ics_url=room.ics_url,
-        ics_fetch_interval=room.ics_fetch_interval,
-        ics_enabled=room.ics_enabled,
     )
 
 
@@ -258,14 +156,12 @@ async def rooms_create(
 async def rooms_update(
     room_id: str,
     info: UpdateRoom,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ):
-    user_id = user["sub"]
+    user_id = user["sub"] if user else None
     room = await rooms_controller.get_by_id_for_http(room_id, user_id=user_id)
     if not room:
         raise HTTPException(status_code=404, detail="Room not found")
-    if room.user_id != user_id:
-        raise HTTPException(status_code=403, detail="Not authorized")
     values = info.dict(exclude_unset=True)
     await rooms_controller.update(room, values)
     return room
@@ -274,14 +170,12 @@ async def rooms_update(
 @router.delete("/rooms/{room_id}", response_model=DeletionStatus)
 async def rooms_delete(
     room_id: str,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ):
-    user_id = user["sub"]
-    room = await rooms_controller.get_by_id(room_id)
+    user_id = user["sub"] if user else None
+    room = await rooms_controller.get_by_id(room_id, user_id=user_id)
     if not room:
         raise HTTPException(status_code=404, detail="Room not found")
-    if room.user_id != user_id:
-        raise HTTPException(status_code=403, detail="Not authorized")
     await rooms_controller.remove_by_id(room.id, user_id=user_id)
     return DeletionStatus(status="ok")
 
@@ -289,7 +183,6 @@ 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
@@ -297,44 +190,53 @@ 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)
+    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)
 
+        whereby_meeting = await create_meeting("", end_date=end_date, room=room)
+
+        await upload_logo(whereby_meeting["roomName"], "./images/logo.png")
+
+        # Now try to save to database
+        try:
+            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=parse_datetime_with_timezone(whereby_meeting["startDate"]),
+                end_date=parse_datetime_with_timezone(whereby_meeting["endDate"]),
+                user_id=user_id,
+                room=room,
+            )
+        except (asyncpg.exceptions.UniqueViolationError, sqlite3.IntegrityError):
+            # Another request already created a meeting for this room
+            # Log this race condition occurrence
+            logger.info(
+                "Race condition detected for room %s - fetching existing meeting",
+                room.name,
+            )
+            logger.warning(
+                "Whereby meeting %s was created but not used (resource leak) for room %s",
+                whereby_meeting["meetingId"],
+                room.name,
+            )
+
+            # Fetch the meeting that was created by the other request
+            meeting = await meetings_controller.get_active(
+                room=room, current_time=current_time
+            )
             if meeting is None:
-                end_date = current_time + timedelta(hours=8)
-
-                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=parse_datetime_with_timezone(
-                        whereby_meeting["startDate"]
-                    ),
-                    end_date=parse_datetime_with_timezone(whereby_meeting["endDate"]),
-                    room=room,
+                # Edge case: meeting was created but expired/deleted between checks
+                logger.error(
+                    "Meeting disappeared after race condition for room %s", room.name
+                )
+                raise HTTPException(
+                    status_code=503, detail="Unable to join meeting - please try again"
                 )
-    except LockError:
-        logger.warning("Failed to acquire lock for room %s within timeout", room_name)
-        raise HTTPException(
-            status_code=503, detail="Meeting creation in progress, please try again"
-        )
 
     if user_id != room.user_id:
         meeting.host_room_url = ""
@@ -345,218 +247,19 @@ async def rooms_create_meeting(
 @router.post("/rooms/{room_id}/webhook/test", response_model=WebhookTestResult)
 async def rooms_test_webhook(
     room_id: str,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ):
     """Test webhook configuration by sending a sample payload."""
-    user_id = user["sub"]
+    user_id = user["sub"] if user else None
 
     room = await rooms_controller.get_by_id(room_id)
     if not room:
         raise HTTPException(status_code=404, detail="Room not found")
 
-    if room.user_id != user_id:
+    if user_id and room.user_id != user_id:
         raise HTTPException(
             status_code=403, detail="Not authorized to test this room's 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/transcripts.py

@@ -9,6 +9,8 @@ from pydantic import BaseModel, Field, constr, field_serializer
 
 import reflector.auth as auth
 from reflector.db import get_database
+from reflector.db.meetings import meetings_controller
+from reflector.db.rooms import rooms_controller
 from reflector.db.search import (
     DEFAULT_SEARCH_LIMIT,
     SearchLimit,
@@ -32,7 +34,6 @@ from reflector.db.transcripts import (
 from reflector.processors.types import Transcript as ProcessorTranscript
 from reflector.processors.types import Word
 from reflector.settings import settings
-from reflector.ws_manager import get_ws_manager
 from reflector.zulip import (
     InvalidMessageError,
     get_zulip_message,
@@ -212,7 +213,7 @@ async def transcripts_create(
     user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ):
     user_id = user["sub"] if user else None
-    transcript = await transcripts_controller.add(
+    return await transcripts_controller.add(
         info.name,
         source_kind=info.source_kind or SourceKind.LIVE,
         source_language=info.source_language,
@@ -220,14 +221,6 @@ async def transcripts_create(
         user_id=user_id,
     )
 
-    if user_id:
-        await get_ws_manager().send_json(
-            room_id=f"user:{user_id}",
-            message={"event": "TRANSCRIPT_CREATED", "data": {"id": transcript.id}},
-        )
-
-    return transcript
-
 
 # ==============================================================
 # Single transcript
@@ -351,14 +344,14 @@ async def transcript_get(
 async def transcript_update(
     transcript_id: str,
     info: UpdateTranscript,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ):
-    user_id = user["sub"]
+    user_id = user["sub"] if user else None
     transcript = await transcripts_controller.get_by_id_for_http(
         transcript_id, user_id=user_id
     )
-    if not transcripts_controller.user_can_mutate(transcript, user_id):
-        raise HTTPException(status_code=403, detail="Not authorized")
+    if not transcript:
+        raise HTTPException(status_code=404, detail="Transcript not found")
     values = info.dict(exclude_unset=True)
     updated_transcript = await transcripts_controller.update(transcript, values)
     return updated_transcript
@@ -367,20 +360,20 @@ async def transcript_update(
 @router.delete("/transcripts/{transcript_id}", response_model=DeletionStatus)
 async def transcript_delete(
     transcript_id: str,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ):
-    user_id = user["sub"]
+    user_id = user["sub"] if user else None
     transcript = await transcripts_controller.get_by_id(transcript_id)
     if not transcript:
         raise HTTPException(status_code=404, detail="Transcript not found")
-    if not transcripts_controller.user_can_mutate(transcript, user_id):
-        raise HTTPException(status_code=403, detail="Not authorized")
+
+    if transcript.meeting_id:
+        meeting = await meetings_controller.get_by_id(transcript.meeting_id)
+        room = await rooms_controller.get_by_id(meeting.room_id)
+        if room.is_shared:
+            user_id = None
 
     await transcripts_controller.remove_by_id(transcript.id, user_id=user_id)
-    await get_ws_manager().send_json(
-        room_id=f"user:{user_id}",
-        message={"event": "TRANSCRIPT_DELETED", "data": {"id": transcript.id}},
-    )
     return DeletionStatus(status="ok")
 
 
@@ -452,16 +445,15 @@ async def transcript_post_to_zulip(
     stream: str,
     topic: str,
     include_topics: bool,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ):
-    user_id = user["sub"]
+    user_id = user["sub"] if user else None
     transcript = await transcripts_controller.get_by_id_for_http(
         transcript_id, user_id=user_id
     )
     if not transcript:
         raise HTTPException(status_code=404, detail="Transcript not found")
-    if not transcripts_controller.user_can_mutate(transcript, user_id):
-        raise HTTPException(status_code=403, detail="Not authorized")
+
     content = get_zulip_message(transcript, include_topics)
 
     message_updated = False

server/reflector/views/transcripts_participants.py

@@ -56,14 +56,12 @@ async def transcript_get_participants(
 async def transcript_add_participant(
     transcript_id: str,
     participant: CreateParticipant,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ) -> Participant:
-    user_id = user["sub"]
+    user_id = user["sub"] if user else None
     transcript = await transcripts_controller.get_by_id_for_http(
         transcript_id, user_id=user_id
     )
-    if transcript.user_id is not None and transcript.user_id != user_id:
-        raise HTTPException(status_code=403, detail="Not authorized")
 
     # ensure the speaker is unique
     if participant.speaker is not None and transcript.participants is not None:
@@ -103,14 +101,12 @@ async def transcript_update_participant(
     transcript_id: str,
     participant_id: str,
     participant: UpdateParticipant,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ) -> Participant:
-    user_id = user["sub"]
+    user_id = user["sub"] if user else None
     transcript = await transcripts_controller.get_by_id_for_http(
         transcript_id, user_id=user_id
     )
-    if transcript.user_id is not None and transcript.user_id != user_id:
-        raise HTTPException(status_code=403, detail="Not authorized")
 
     # ensure the speaker is unique
     for p in transcript.participants:
@@ -142,13 +138,11 @@ async def transcript_update_participant(
 async def transcript_delete_participant(
     transcript_id: str,
     participant_id: str,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ) -> DeletionStatus:
-    user_id = user["sub"]
+    user_id = user["sub"] if user else None
     transcript = await transcripts_controller.get_by_id_for_http(
         transcript_id, user_id=user_id
     )
-    if transcript.user_id is not None and transcript.user_id != user_id:
-        raise HTTPException(status_code=403, detail="Not authorized")
     await transcripts_controller.delete_participant(transcript, participant_id)
     return DeletionStatus(status="ok")

server/reflector/views/transcripts_speaker.py

@@ -35,14 +35,12 @@ class SpeakerMerge(BaseModel):
 async def transcript_assign_speaker(
     transcript_id: str,
     assignment: SpeakerAssignment,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ) -> SpeakerAssignmentStatus:
-    user_id = user["sub"]
+    user_id = user["sub"] if user else None
     transcript = await transcripts_controller.get_by_id_for_http(
         transcript_id, user_id=user_id
     )
-    if transcript.user_id is not None and transcript.user_id != user_id:
-        raise HTTPException(status_code=403, detail="Not authorized")
 
     if not transcript:
         raise HTTPException(status_code=404, detail="Transcript not found")
@@ -115,14 +113,12 @@ async def transcript_assign_speaker(
 async def transcript_merge_speaker(
     transcript_id: str,
     merge: SpeakerMerge,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
+    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ) -> SpeakerAssignmentStatus:
-    user_id = user["sub"]
+    user_id = user["sub"] if user else None
     transcript = await transcripts_controller.get_by_id_for_http(
         transcript_id, user_id=user_id
     )
-    if transcript.user_id is not None and transcript.user_id != user_id:
-        raise HTTPException(status_code=403, detail="Not authorized")
 
     if not transcript:
         raise HTTPException(status_code=404, detail="Transcript not found")

server/reflector/views/transcripts_websocket.py

@@ -4,11 +4,8 @@ Transcripts websocket API
 
 """
 
-from typing import Optional
+from fastapi import APIRouter, HTTPException, WebSocket, WebSocketDisconnect
 
-from fastapi import APIRouter, Depends, HTTPException, WebSocket, WebSocketDisconnect
-
-import reflector.auth as auth
 from reflector.db.transcripts import transcripts_controller
 from reflector.ws_manager import get_ws_manager
 
@@ -24,12 +21,10 @@ async def transcript_get_websocket_events(transcript_id: str):
 async def transcript_events_websocket(
     transcript_id: str,
     websocket: WebSocket,
-    user: Optional[auth.UserInfo] = Depends(auth.current_user_optional),
+    # user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
 ):
-    user_id = user["sub"] if user else None
-    transcript = await transcripts_controller.get_by_id_for_http(
-        transcript_id, user_id=user_id
-    )
+    # user_id = user["sub"] if user else None
+    transcript = await transcripts_controller.get_by_id(transcript_id)
     if not transcript:
         raise HTTPException(status_code=404, detail="Transcript not found")
 

server/reflector/views/user_api_keys.py

@@ -1,62 +0,0 @@
-from datetime import datetime
-from typing import Annotated
-
-import structlog
-from fastapi import APIRouter, Depends, HTTPException
-from pydantic import BaseModel
-
-import reflector.auth as auth
-from reflector.db.user_api_keys import user_api_keys_controller
-from reflector.utils.string import NonEmptyString
-
-router = APIRouter()
-logger = structlog.get_logger(__name__)
-
-
-class CreateApiKeyRequest(BaseModel):
-    name: NonEmptyString | None = None
-
-
-class ApiKeyResponse(BaseModel):
-    id: NonEmptyString
-    user_id: NonEmptyString
-    name: NonEmptyString | None
-    created_at: datetime
-
-
-class CreateApiKeyResponse(ApiKeyResponse):
-    key: NonEmptyString
-
-
-@router.post("/user/api-keys", response_model=CreateApiKeyResponse)
-async def create_api_key(
-    req: CreateApiKeyRequest,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
-):
-    api_key_model, plaintext = await user_api_keys_controller.create_key(
-        user_id=user["sub"],
-        name=req.name,
-    )
-    return CreateApiKeyResponse(
-        **api_key_model.model_dump(),
-        key=plaintext,
-    )
-
-
-@router.get("/user/api-keys", response_model=list[ApiKeyResponse])
-async def list_api_keys(
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
-):
-    api_keys = await user_api_keys_controller.list_by_user_id(user["sub"])
-    return [ApiKeyResponse(**k.model_dump()) for k in api_keys]
-
-
-@router.delete("/user/api-keys/{key_id}")
-async def delete_api_key(
-    key_id: NonEmptyString,
-    user: Annotated[auth.UserInfo, Depends(auth.current_user)],
-):
-    deleted = await user_api_keys_controller.delete_key(key_id, user["sub"])
-    if not deleted:
-        raise HTTPException(status_code=404)
-    return {"status": "ok"}

server/reflector/views/user_websocket.py

@@ -1,53 +0,0 @@
-from typing import Optional
-
-from fastapi import APIRouter, WebSocket
-
-from reflector.auth.auth_jwt import JWTAuth  # type: ignore
-from reflector.ws_manager import get_ws_manager
-
-router = APIRouter()
-
-# Close code for unauthorized WebSocket connections
-UNAUTHORISED = 4401
-
-
-@router.websocket("/events")
-async def user_events_websocket(websocket: WebSocket):
-    # Browser can't send Authorization header for WS; use subprotocol: ["bearer", token]
-    raw_subprotocol = websocket.headers.get("sec-websocket-protocol") or ""
-    parts = [p.strip() for p in raw_subprotocol.split(",") if p.strip()]
-    token: Optional[str] = None
-    negotiated_subprotocol: Optional[str] = None
-    if len(parts) >= 2 and parts[0].lower() == "bearer":
-        negotiated_subprotocol = "bearer"
-        token = parts[1]
-
-    user_id: Optional[str] = None
-    if not token:
-        await websocket.close(code=UNAUTHORISED)
-        return
-
-    try:
-        payload = JWTAuth().verify_token(token)
-        user_id = payload.get("sub")
-    except Exception:
-        await websocket.close(code=UNAUTHORISED)
-        return
-
-    if not user_id:
-        await websocket.close(code=UNAUTHORISED)
-        return
-
-    room_id = f"user:{user_id}"
-    ws_manager = get_ws_manager()
-
-    await ws_manager.add_user_to_room(
-        room_id, websocket, subprotocol=negotiated_subprotocol
-    )
-
-    try:
-        while True:
-            await websocket.receive()
-    finally:
-        if room_id:
-            await ws_manager.remove_user_from_room(room_id, websocket)

server/reflector/views/whereby.py

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

server/reflector/whereby.py

@@ -1,60 +1,18 @@
-import logging
 from datetime import datetime
 
 import httpx
 
 from reflector.db.rooms import Room
 from reflector.settings import settings
-from reflector.utils.string import parse_non_empty_string
-
-logger = logging.getLogger(__name__)
-
-
-def _get_headers():
-    api_key = parse_non_empty_string(
-        settings.WHEREBY_API_KEY, "WHEREBY_API_KEY value is required."
-    )
-    return {
-        "Content-Type": "application/json; charset=utf-8",
-        "Authorization": f"Bearer {api_key}",
-    }
-
 
+HEADERS = {
+    "Content-Type": "application/json; charset=utf-8",
+    "Authorization": f"Bearer {settings.WHEREBY_API_KEY}",
+}
 TIMEOUT = 10  # seconds
 
 
-def _get_whereby_s3_auth():
-    errors = []
-    try:
-        bucket_name = parse_non_empty_string(
-            settings.RECORDING_STORAGE_AWS_BUCKET_NAME,
-            "RECORDING_STORAGE_AWS_BUCKET_NAME value is required.",
-        )
-    except Exception as e:
-        errors.append(e)
-    try:
-        key_id = parse_non_empty_string(
-            settings.AWS_WHEREBY_ACCESS_KEY_ID,
-            "AWS_WHEREBY_ACCESS_KEY_ID value is required.",
-        )
-    except Exception as e:
-        errors.append(e)
-    try:
-        key_secret = parse_non_empty_string(
-            settings.AWS_WHEREBY_ACCESS_KEY_SECRET,
-            "AWS_WHEREBY_ACCESS_KEY_SECRET value is required.",
-        )
-    except Exception as e:
-        errors.append(e)
-    if len(errors) > 0:
-        raise Exception(
-            f"Failed to get Whereby auth settings: {', '.join(str(e) for e in errors)}"
-        )
-    return bucket_name, key_id, key_secret
-
-
 async def create_meeting(room_name_prefix: str, end_date: datetime, room: Room):
-    s3_bucket_name, s3_key_id, s3_key_secret = _get_whereby_s3_auth()
     data = {
         "isLocked": room.is_locked,
         "roomNamePrefix": room_name_prefix,
@@ -65,26 +23,23 @@ async def create_meeting(room_name_prefix: str, end_date: datetime, room: Room):
             "type": room.recording_type,
             "destination": {
                 "provider": "s3",
-                "bucket": s3_bucket_name,
-                "accessKeyId": s3_key_id,
-                "accessKeySecret": s3_key_secret,
+                "bucket": settings.RECORDING_STORAGE_AWS_BUCKET_NAME,
+                "accessKeyId": settings.AWS_WHEREBY_ACCESS_KEY_ID,
+                "accessKeySecret": settings.AWS_WHEREBY_ACCESS_KEY_SECRET,
                 "fileFormat": "mp4",
             },
             "startTrigger": room.recording_trigger,
         },
         "fields": ["hostRoomUrl"],
     }
+
     async with httpx.AsyncClient() as client:
         response = await client.post(
             f"{settings.WHEREBY_API_URL}/meetings",
-            headers=_get_headers(),
+            headers=HEADERS,
             json=data,
             timeout=TIMEOUT,
         )
-        if response.status_code == 403:
-            logger.warning(
-                f"Failed to create meeting: access denied on Whereby: {response.text}"
-            )
         response.raise_for_status()
         return response.json()
 
@@ -93,7 +48,7 @@ async def get_room_sessions(room_name: str):
     async with httpx.AsyncClient() as client:
         response = await client.get(
             f"{settings.WHEREBY_API_URL}/insights/room-sessions?roomName={room_name}",
-            headers=_get_headers(),
+            headers=HEADERS,
             timeout=TIMEOUT,
         )
         response.raise_for_status()

server/reflector/worker/app.py

@@ -20,7 +20,6 @@ else:
             "reflector.worker.healthcheck",
             "reflector.worker.process",
             "reflector.worker.cleanup",
-            "reflector.worker.ics_sync",
         ]
     )
 
@@ -38,14 +37,6 @@ else:
             "task": "reflector.worker.process.reprocess_failed_recordings",
             "schedule": crontab(hour=5, minute=0),  # Midnight EST
         },
-        "sync_all_ics_calendars": {
-            "task": "reflector.worker.ics_sync.sync_all_ics_calendars",
-            "schedule": 60.0,  # Run every minute to check which rooms need sync
-        },
-        "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,6 +5,7 @@ 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
 
@@ -151,5 +152,5 @@ async def cleanup_old_public_data(
     retry_kwargs={"max_retries": 3, "countdown": 300},
 )
 @asynctask
-async def cleanup_old_public_data_task(days: int | None = None):
-    await cleanup_old_public_data(days=days)
+def cleanup_old_public_data_task(days: int | None = None):
+    asyncio.run(cleanup_old_public_data(days=days))

server/reflector/worker/ics_sync.py

@@ -1,175 +0,0 @@
-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/process.py

@@ -9,7 +9,6 @@ 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
@@ -17,7 +16,6 @@ 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.whereby import get_room_sessions
 
@@ -149,93 +147,24 @@ 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:
-        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)
-
-            # This API call could be slow, extend lock if needed
+        is_active = 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):
             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", [])
-            has_active_sessions = room_sessions and any(
+            is_active = not room_sessions or any(
                 rs["endedAt"] is None for rs in room_sessions
             )
-            has_had_sessions = bool(room_sessions)
+        if not is_active:
+            await meetings_controller.update_meeting(meeting.id, is_active=False)
+            logger.info("Meeting %s is deactivated", meeting.id)
 
-            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",
-                )
-            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:
-            logger_.error("Error processing meeting", exc_info=True)
-        finally:
-            try:
-                lock.release()
-            except LockError:
-                pass  # Lock already released or expired
-
-    logger.info(
-        "Processed meetings finished",
-        processed_count=processed_count,
-        skipped_count=skipped_count,
-    )
+    logger.info("Processed meetings")
 
 
 @shared_task

server/reflector/worker/webhook.py

@@ -11,8 +11,6 @@ import structlog
 from celery import shared_task
 from celery.utils.log import get_task_logger
 
-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.db.transcripts import transcripts_controller
 from reflector.pipelines.main_live_pipeline import asynctask
@@ -86,18 +84,6 @@ async def send_transcript_webhook(
                     }
                 )
 
-        # Fetch meeting and calendar event if they exist
-        calendar_event = None
-        try:
-            if transcript.meeting_id:
-                meeting = await meetings_controller.get_by_id(transcript.meeting_id)
-                if meeting and meeting.calendar_event_id:
-                    calendar_event = await calendar_events_controller.get_by_id(
-                        meeting.calendar_event_id
-                    )
-        except Exception as e:
-            logger.error("Error fetching meeting or calendar event", error=str(e))
-
         # Build webhook payload
         frontend_url = f"{settings.UI_BASE_URL}/transcripts/{transcript.id}"
         participants = [
@@ -130,33 +116,6 @@ async def send_transcript_webhook(
             },
         }
 
-        # Always include calendar_event field, even if no event is present
-        payload_data["calendar_event"] = {}
-
-        # Add calendar event data if present
-        if calendar_event:
-            calendar_data = {
-                "id": calendar_event.id,
-                "ics_uid": calendar_event.ics_uid,
-                "title": calendar_event.title,
-                "start_time": calendar_event.start_time.isoformat()
-                if calendar_event.start_time
-                else None,
-                "end_time": calendar_event.end_time.isoformat()
-                if calendar_event.end_time
-                else None,
-            }
-
-            # Add optional fields only if they exist
-            if calendar_event.description:
-                calendar_data["description"] = calendar_event.description
-            if calendar_event.location:
-                calendar_data["location"] = calendar_event.location
-            if calendar_event.attendees:
-                calendar_data["attendees"] = calendar_event.attendees
-
-            payload_data["calendar_event"] = calendar_data
-
         # Convert to JSON
         payload_json = json.dumps(payload_data, separators=(",", ":"))
         payload_bytes = payload_json.encode("utf-8")

server/reflector/ws_manager.py

@@ -65,13 +65,8 @@ class WebsocketManager:
         self.tasks: dict = {}
         self.pubsub_client = pubsub_client
 
-    async def add_user_to_room(
-        self, room_id: str, websocket: WebSocket, subprotocol: str | None = None
-    ) -> None:
-        if subprotocol:
-            await websocket.accept(subprotocol=subprotocol)
-        else:
-            await websocket.accept()
+    async def add_user_to_room(self, room_id: str, websocket: WebSocket) -> None:
+        await websocket.accept()
 
         if room_id in self.rooms:
             self.rooms[room_id].append(websocket)

server/test.ics

@@ -1,29 +0,0 @@
-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/conftest.py

@@ -1,5 +1,4 @@
 import os
-from contextlib import asynccontextmanager
 from tempfile import NamedTemporaryFile
 from unittest.mock import patch
 
@@ -338,166 +337,6 @@ async def client():
         yield ac
 
 
-@pytest.fixture(autouse=True)
-async def ws_manager_in_memory(monkeypatch):
-    """Replace Redis-based WS manager with an in-memory implementation for tests."""
-    import asyncio
-    import json
-
-    from reflector.ws_manager import WebsocketManager
-
-    class _InMemorySubscriber:
-        def __init__(self, queue: asyncio.Queue):
-            self.queue = queue
-
-        async def get_message(self, ignore_subscribe_messages: bool = True):
-            try:
-                return await asyncio.wait_for(self.queue.get(), timeout=0.05)
-            except Exception:
-                return None
-
-    class InMemoryPubSubManager:
-        def __init__(self):
-            self.queues: dict[str, asyncio.Queue] = {}
-            self.connected = False
-
-        async def connect(self) -> None:
-            self.connected = True
-
-        async def disconnect(self) -> None:
-            self.connected = False
-
-        async def send_json(self, room_id: str, message: dict) -> None:
-            if room_id not in self.queues:
-                self.queues[room_id] = asyncio.Queue()
-            payload = json.dumps(message).encode("utf-8")
-            await self.queues[room_id].put(
-                {"channel": room_id.encode("utf-8"), "data": payload}
-            )
-
-        async def subscribe(self, room_id: str):
-            if room_id not in self.queues:
-                self.queues[room_id] = asyncio.Queue()
-            return _InMemorySubscriber(self.queues[room_id])
-
-        async def unsubscribe(self, room_id: str) -> None:
-            # keep queue for potential later resubscribe within same test
-            pass
-
-    pubsub = InMemoryPubSubManager()
-    ws_manager = WebsocketManager(pubsub_client=pubsub)
-
-    def _get_ws_manager():
-        return ws_manager
-
-    # Patch all places that imported get_ws_manager at import time
-    monkeypatch.setattr("reflector.ws_manager.get_ws_manager", _get_ws_manager)
-    monkeypatch.setattr(
-        "reflector.pipelines.main_live_pipeline.get_ws_manager", _get_ws_manager
-    )
-    monkeypatch.setattr(
-        "reflector.views.transcripts_websocket.get_ws_manager", _get_ws_manager
-    )
-    monkeypatch.setattr(
-        "reflector.views.user_websocket.get_ws_manager", _get_ws_manager
-    )
-    monkeypatch.setattr("reflector.views.transcripts.get_ws_manager", _get_ws_manager)
-
-    # Websocket auth: avoid OAuth2 on websocket dependencies; allow anonymous
-    import reflector.auth as auth
-
-    # Ensure FastAPI uses our override for routes that captured the original callable
-    from reflector.app import app as fastapi_app
-
-    try:
-        fastapi_app.dependency_overrides[auth.current_user_optional] = lambda: None
-    except Exception:
-        pass
-
-    # Stub Redis cache used by profanity filter to avoid external Redis
-    from reflector import redis_cache as rc
-
-    class _FakeRedis:
-        def __init__(self):
-            self._data = {}
-
-        def get(self, key):
-            value = self._data.get(key)
-            if value is None:
-                return None
-            if isinstance(value, bytes):
-                return value
-            return str(value).encode("utf-8")
-
-        def setex(self, key, duration, value):
-            # ignore duration for tests
-            if isinstance(value, bytes):
-                self._data[key] = value
-            else:
-                self._data[key] = str(value).encode("utf-8")
-
-    fake_redises: dict[int, _FakeRedis] = {}
-
-    def _get_redis_client(db=0):
-        if db not in fake_redises:
-            fake_redises[db] = _FakeRedis()
-        return fake_redises[db]
-
-    monkeypatch.setattr(rc, "get_redis_client", _get_redis_client)
-
-    yield
-
-
-@pytest.fixture
-@pytest.mark.asyncio
-async def authenticated_client():
-    async with authenticated_client_ctx():
-        yield
-
-
-@pytest.fixture
-@pytest.mark.asyncio
-async def authenticated_client2():
-    async with authenticated_client2_ctx():
-        yield
-
-
-@asynccontextmanager
-async def authenticated_client_ctx():
-    from reflector.app import app
-    from reflector.auth import current_user, current_user_optional
-
-    app.dependency_overrides[current_user] = lambda: {
-        "sub": "randomuserid",
-        "email": "test@mail.com",
-    }
-    app.dependency_overrides[current_user_optional] = lambda: {
-        "sub": "randomuserid",
-        "email": "test@mail.com",
-    }
-    yield
-    del app.dependency_overrides[current_user]
-    del app.dependency_overrides[current_user_optional]
-
-
-@asynccontextmanager
-async def authenticated_client2_ctx():
-    from reflector.app import app
-    from reflector.auth import current_user, current_user_optional
-
-    app.dependency_overrides[current_user] = lambda: {
-        "sub": "randomuserid2",
-        "email": "test@mail.com",
-    }
-    app.dependency_overrides[current_user_optional] = lambda: {
-        "sub": "randomuserid2",
-        "email": "test@mail.com",
-    }
-    yield
-    del app.dependency_overrides[current_user]
-    del app.dependency_overrides[current_user_optional]
-
-
 @pytest.fixture(scope="session")
 def fake_mp3_upload():
     with patch(

server/tests/test_attendee_parsing_bug.ics

@@ -1,18 +0,0 @@
-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

@@ -1,192 +0,0 @@
-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

@@ -1,424 +0,0 @@
-"""
-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_cleanup.py

@@ -105,6 +105,7 @@ async def test_cleanup_deletes_associated_meeting_and_recording():
             host_room_url="https://example.com/meeting-host",
             start_date=old_date,
             end_date=old_date + timedelta(hours=1),
+            user_id=None,
             room_id=None,
         )
     )
@@ -240,6 +241,7 @@ async def test_meeting_consent_cascade_delete():
             host_room_url="https://example.com/cascade-test-host",
             start_date=datetime.now(timezone.utc),
             end_date=datetime.now(timezone.utc) + timedelta(hours=1),
+            user_id="test-user",
             room_id=None,
         )
     )

server/tests/test_gpu_modal_transcript.py

@@ -1,21 +1,21 @@
 """
-Tests for transcription Model API endpoints.
+Tests for GPU Modal transcription endpoints.
 
-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
+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
 
 Required environment variables:
-- TRANSCRIPT_URL: URL to the Model API endpoint (required)
-- TRANSCRIPT_API_KEY: API key for authentication (optional)
+- TRANSCRIPT_URL: URL to the Modal.com endpoint (required)
+- TRANSCRIPT_MODAL_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 model_api tests):
+Example with pytest (override default addopts to run ONLY gpu_modal tests):
     TRANSCRIPT_URL=https://monadical-sas--reflector-transcriber-parakeet-web-dev.modal.run \
-    TRANSCRIPT_API_KEY=your-api-key \
-    uv run -m pytest -m model_api --no-cov tests/test_model_api_transcript.py
+    TRANSCRIPT_MODAL_API_KEY=your-api-key \
+    uv run -m pytest -m gpu_modal --no-cov tests/test_gpu_modal_transcript.py
 
     # Or with completely clean options:
-    uv run -m pytest -m model_api -o addopts="" tests/
+    uv run -m pytest -m gpu_modal -o addopts="" tests/
 
 Running Modal locally for testing:
     modal serve gpu/modal_deployments/reflector_transcriber_parakeet.py
@@ -40,16 +40,14 @@ def get_modal_transcript_url():
     url = os.environ.get("TRANSCRIPT_URL")
     if not url:
         pytest.skip(
-            "TRANSCRIPT_URL environment variable is required for Model API tests"
+            "TRANSCRIPT_URL environment variable is required for GPU Modal tests"
         )
     return url
 
 
 def get_auth_headers():
     """Get authentication headers if API key is available."""
-    api_key = os.environ.get("TRANSCRIPT_API_KEY") or os.environ.get(
-        "REFLECTOR_GPU_APIKEY"
-    )
+    api_key = os.environ.get("TRANSCRIPT_MODAL_API_KEY")
     if api_key:
         return {"Authorization": f"Bearer {api_key}"}
     return {}
@@ -60,8 +58,8 @@ def get_model_name():
     return os.environ.get("TRANSCRIPT_MODEL", "nvidia/parakeet-tdt-0.6b-v2")
 
 
-@pytest.mark.model_api
-class TestModelAPITranscript:
+@pytest.mark.gpu_modal
+class TestGPUModalTranscript:
     """Test suite for GPU Modal transcription endpoints."""
 
     def test_transcriptions_from_url(self):
@@ -274,9 +272,6 @@ class TestModelAPITranscript:
                 for f in temp_files:
                     Path(f).unlink(missing_ok=True)
 
-    @pytest.mark.skipif(
-        not "parakeet" in get_model_name(), reason="Parakeet only supports English"
-    )
     def test_transcriptions_error_handling(self):
         """Test error handling for invalid requests."""
         url = get_modal_transcript_url()

server/tests/test_ics_background_tasks.py

@@ -1,255 +0,0 @@
-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

@@ -1,290 +0,0 @@
-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_model_api_diarization.py

@@ -1,63 +0,0 @@
-"""
-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_translation.py

@@ -1,56 +0,0 @@
-"""
-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

@@ -1,167 +0,0 @@
-"""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

@@ -1,225 +0,0 @@
-"""
-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

@@ -1,397 +0,0 @@
-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, current_user_optional
-
-    app.dependency_overrides[current_user] = lambda: {
-        "sub": "test-user",
-        "email": "test@example.com",
-    }
-    app.dependency_overrides[current_user_optional] = lambda: {
-        "sub": "test-user",
-        "email": "test@example.com",
-    }
-    try:
-        yield client
-    finally:
-        del app.dependency_overrides[current_user]
-        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_search.py

@@ -58,7 +58,7 @@ async def test_empty_transcript_title_only_match():
             "id": test_id,
             "name": "Empty Transcript",
             "title": "Empty Meeting",
-            "status": "ended",
+            "status": "completed",
             "locked": False,
             "duration": 0.0,
             "created_at": datetime.now(timezone.utc),
@@ -109,7 +109,7 @@ async def test_search_with_long_summary():
             "id": test_id,
             "name": "Test Long Summary",
             "title": "Regular Meeting",
-            "status": "ended",
+            "status": "completed",
             "locked": False,
             "duration": 1800.0,
             "created_at": datetime.now(timezone.utc),
@@ -165,7 +165,7 @@ async def test_postgresql_search_with_data():
             "id": test_id,
             "name": "Test Search Transcript",
             "title": "Engineering Planning Meeting Q4 2024",
-            "status": "ended",
+            "status": "completed",
             "locked": False,
             "duration": 1800.0,
             "created_at": datetime.now(timezone.utc),
@@ -221,7 +221,7 @@ We need to implement PostgreSQL tsvector for better performance.""",
         test_result = next((r for r in results if r.id == test_id), None)
         if test_result:
             assert test_result.title == "Engineering Planning Meeting Q4 2024"
-            assert test_result.status == "ended"
+            assert test_result.status == "completed"
             assert test_result.duration == 1800.0
             assert 0 <= test_result.rank <= 1, "Rank should be normalized to 0-1"
 
@@ -268,7 +268,7 @@ def mock_db_result():
         "title": "Test Transcript",
         "created_at": datetime(2024, 6, 15, tzinfo=timezone.utc),
         "duration": 3600.0,
-        "status": "ended",
+        "status": "completed",
         "user_id": "test-user",
         "room_id": "room1",
         "source_kind": SourceKind.LIVE,
@@ -433,7 +433,7 @@ class TestSearchResultModel:
             room_id="room-456",
             source_kind=SourceKind.ROOM,
             created_at=datetime(2024, 6, 15, tzinfo=timezone.utc),
-            status="ended",
+            status="completed",
             rank=0.85,
             duration=1800.5,
             search_snippets=["snippet 1", "snippet 2"],
@@ -443,7 +443,7 @@ class TestSearchResultModel:
         assert result.title == "Test Title"
         assert result.user_id == "user-123"
         assert result.room_id == "room-456"
-        assert result.status == "ended"
+        assert result.status == "completed"
         assert result.rank == 0.85
         assert result.duration == 1800.5
         assert len(result.search_snippets) == 2
@@ -474,7 +474,7 @@ class TestSearchResultModel:
             id="test-id",
             source_kind=SourceKind.LIVE,
             created_at=datetime(2024, 6, 15, 12, 30, 45, tzinfo=timezone.utc),
-            status="ended",
+            status="completed",
             rank=0.9,
             duration=None,
             search_snippets=[],

server/tests/test_search_long_summary.py

@@ -25,7 +25,7 @@ async def test_long_summary_snippet_prioritization():
             "id": test_id,
             "name": "Test Snippet Priority",
             "title": "Meeting About Projects",
-            "status": "ended",
+            "status": "completed",
             "locked": False,
             "duration": 1800.0,
             "created_at": datetime.now(timezone.utc),
@@ -106,7 +106,7 @@ async def test_long_summary_only_search():
             "id": test_id,
             "name": "Test Long Only",
             "title": "Standard Meeting",
-            "status": "ended",
+            "status": "completed",
             "locked": False,
             "duration": 1800.0,
             "created_at": datetime.now(timezone.utc),

server/tests/test_security_permissions.py

@@ -1,384 +0,0 @@
-import asyncio
-import shutil
-import threading
-import time
-from pathlib import Path
-
-import pytest
-from httpx_ws import aconnect_ws
-from uvicorn import Config, Server
-
-from reflector import zulip as zulip_module
-from reflector.app import app
-from reflector.db import get_database
-from reflector.db.meetings import meetings_controller
-from reflector.db.rooms import Room, rooms_controller
-from reflector.db.transcripts import (
-    SourceKind,
-    TranscriptTopic,
-    transcripts_controller,
-)
-from reflector.processors.types import Word
-from reflector.settings import settings
-from reflector.views.transcripts import create_access_token
-
-
-@pytest.mark.asyncio
-async def test_anonymous_cannot_delete_transcript_in_shared_room(client):
-    # Create a shared room with a fake owner id so meeting has a room_id
-    room = await rooms_controller.add(
-        name="shared-room-test",
-        user_id="owner-1",
-        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,
-        webhook_url="",
-        webhook_secret="",
-    )
-
-    # Create a meeting for that room (so transcript.meeting_id links to the shared room)
-    meeting = await meetings_controller.create(
-        id="meeting-sec-test",
-        room_name="room-sec-test",
-        room_url="room-url",
-        host_room_url="host-url",
-        start_date=Room.model_fields["created_at"].default_factory(),
-        end_date=Room.model_fields["created_at"].default_factory(),
-        room=room,
-    )
-
-    # Create a transcript owned by someone else and link it to meeting
-    t = await transcripts_controller.add(
-        name="to-delete",
-        source_kind=SourceKind.LIVE,
-        user_id="owner-2",
-        meeting_id=meeting.id,
-        room_id=room.id,
-        share_mode="private",
-    )
-
-    # Anonymous DELETE should be rejected
-    del_resp = await client.delete(f"/transcripts/{t.id}")
-    assert del_resp.status_code == 401, del_resp.text
-
-
-@pytest.mark.asyncio
-async def test_anonymous_cannot_mutate_participants_on_public_transcript(client):
-    # Create a public transcript with no owner
-    t = await transcripts_controller.add(
-        name="public-transcript",
-        source_kind=SourceKind.LIVE,
-        user_id=None,
-        share_mode="public",
-    )
-
-    # Anonymous POST participant must be rejected
-    resp = await client.post(
-        f"/transcripts/{t.id}/participants",
-        json={"name": "AnonUser", "speaker": 0},
-    )
-    assert resp.status_code == 401, resp.text
-
-
-@pytest.mark.asyncio
-async def test_anonymous_cannot_update_and_delete_room(client):
-    # Create room as owner id "owner-3" via controller
-    room = await rooms_controller.add(
-        name="room-anon-update-delete",
-        user_id="owner-3",
-        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="",
-    )
-
-    # Anonymous PATCH via API (no auth)
-    resp = await client.patch(
-        f"/rooms/{room.id}",
-        json={
-            "name": "room-anon-updated",
-            "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": "",
-        },
-    )
-    # Expect authentication required
-    assert resp.status_code == 401, resp.text
-
-    # Anonymous DELETE via API
-    del_resp = await client.delete(f"/rooms/{room.id}")
-    assert del_resp.status_code == 401, del_resp.text
-
-
-@pytest.mark.asyncio
-async def test_anonymous_cannot_post_transcript_to_zulip(client, monkeypatch):
-    # Create a public transcript with some content
-    t = await transcripts_controller.add(
-        name="zulip-public",
-        source_kind=SourceKind.LIVE,
-        user_id=None,
-        share_mode="public",
-    )
-
-    # Mock send/update calls
-    def _fake_send_message_to_zulip(stream, topic, content):
-        return {"id": 12345}
-
-    async def _fake_update_message(message_id, stream, topic, content):
-        return {"result": "success"}
-
-    monkeypatch.setattr(
-        zulip_module, "send_message_to_zulip", _fake_send_message_to_zulip
-    )
-    monkeypatch.setattr(zulip_module, "update_zulip_message", _fake_update_message)
-
-    # Anonymous POST to Zulip endpoint
-    resp = await client.post(
-        f"/transcripts/{t.id}/zulip",
-        params={"stream": "general", "topic": "Updates", "include_topics": False},
-    )
-    assert resp.status_code == 401, resp.text
-
-
-@pytest.mark.asyncio
-async def test_anonymous_cannot_assign_speaker_on_public_transcript(client):
-    # Create public transcript
-    t = await transcripts_controller.add(
-        name="public-assign",
-        source_kind=SourceKind.LIVE,
-        user_id=None,
-        share_mode="public",
-    )
-
-    # Add a topic with words to be reassigned
-    topic = TranscriptTopic(
-        title="T1",
-        summary="S1",
-        timestamp=0.0,
-        transcript="Hello",
-        words=[Word(start=0.0, end=1.0, text="Hello", speaker=0)],
-    )
-    transcript = await transcripts_controller.get_by_id(t.id)
-    await transcripts_controller.upsert_topic(transcript, topic)
-
-    # Anonymous assign speaker over time range covering the word
-    resp = await client.patch(
-        f"/transcripts/{t.id}/speaker/assign",
-        json={
-            "speaker": 1,
-            "timestamp_from": 0.0,
-            "timestamp_to": 1.0,
-        },
-    )
-    assert resp.status_code == 401, resp.text
-
-
-# Minimal server fixture for websocket tests
-@pytest.fixture
-def appserver_ws_simple(setup_database):
-    host = "127.0.0.1"
-    port = 1256
-    server_started = threading.Event()
-    server_exception = None
-    server_instance = None
-
-    def run_server():
-        nonlocal server_exception, server_instance
-        try:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-            config = Config(app=app, host=host, port=port, loop=loop)
-            server_instance = Server(config)
-
-            async def start_server():
-                database = get_database()
-                await database.connect()
-                try:
-                    await server_instance.serve()
-                finally:
-                    await database.disconnect()
-
-            server_started.set()
-            loop.run_until_complete(start_server())
-        except Exception as e:
-            server_exception = e
-            server_started.set()
-        finally:
-            loop.close()
-
-    server_thread = threading.Thread(target=run_server, daemon=True)
-    server_thread.start()
-
-    server_started.wait(timeout=30)
-    if server_exception:
-        raise server_exception
-
-    time.sleep(0.5)
-
-    yield host, port
-
-    if server_instance:
-        server_instance.should_exit = True
-        server_thread.join(timeout=30)
-
-
-@pytest.mark.asyncio
-async def test_websocket_denies_anonymous_on_private_transcript(appserver_ws_simple):
-    host, port = appserver_ws_simple
-
-    # Create a private transcript owned by someone
-    t = await transcripts_controller.add(
-        name="private-ws",
-        source_kind=SourceKind.LIVE,
-        user_id="owner-x",
-        share_mode="private",
-    )
-
-    base_url = f"http://{host}:{port}/v1"
-    # Anonymous connect should be denied
-    with pytest.raises(Exception):
-        async with aconnect_ws(f"{base_url}/transcripts/{t.id}/events") as ws:
-            await ws.close()
-
-
-@pytest.mark.asyncio
-async def test_anonymous_cannot_update_public_transcript(client):
-    t = await transcripts_controller.add(
-        name="update-me",
-        source_kind=SourceKind.LIVE,
-        user_id=None,
-        share_mode="public",
-    )
-
-    resp = await client.patch(
-        f"/transcripts/{t.id}",
-        json={"title": "New Title From Anonymous"},
-    )
-    assert resp.status_code == 401, resp.text
-
-
-@pytest.mark.asyncio
-async def test_anonymous_cannot_get_nonshared_room_by_id(client):
-    room = await rooms_controller.add(
-        name="private-room-exposed",
-        user_id="owner-z",
-        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="",
-    )
-
-    resp = await client.get(f"/rooms/{room.id}")
-    assert resp.status_code == 403, resp.text
-
-
-@pytest.mark.asyncio
-async def test_anonymous_cannot_call_rooms_webhook_test(client):
-    room = await rooms_controller.add(
-        name="room-webhook-test",
-        user_id="owner-y",
-        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="http://localhost.invalid/webhook",
-        webhook_secret="secret",
-    )
-
-    # Anonymous caller
-    resp = await client.post(f"/rooms/{room.id}/webhook/test")
-    assert resp.status_code == 401, resp.text
-
-
-@pytest.mark.asyncio
-async def test_anonymous_cannot_create_room(client):
-    payload = {
-        "name": "room-create-auth-required",
-        "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": "",
-    }
-    resp = await client.post("/rooms", json=payload)
-    assert resp.status_code == 401, resp.text
-
-
-@pytest.mark.asyncio
-async def test_list_search_401_when_public_mode_false(client, monkeypatch):
-    monkeypatch.setattr(settings, "PUBLIC_MODE", False)
-
-    resp = await client.get("/transcripts")
-    assert resp.status_code == 401
-
-    resp = await client.get("/transcripts/search", params={"q": "hello"})
-    assert resp.status_code == 401
-
-
-@pytest.mark.asyncio
-async def test_audio_mp3_requires_token_for_owned_transcript(
-    client, tmpdir, monkeypatch
-):
-    # Use temp data dir
-    monkeypatch.setattr(settings, "DATA_DIR", Path(tmpdir).as_posix())
-
-    # Create owner transcript and attach a local mp3
-    t = await transcripts_controller.add(
-        name="owned-audio",
-        source_kind=SourceKind.LIVE,
-        user_id="owner-a",
-        share_mode="private",
-    )
-
-    tr = await transcripts_controller.get_by_id(t.id)
-    await transcripts_controller.update(tr, {"status": "ended"})
-
-    # copy fixture audio to transcript path
-    audio_path = Path(__file__).parent / "records" / "test_mathieu_hello.mp3"
-    tr.audio_mp3_filename.parent.mkdir(parents=True, exist_ok=True)
-    shutil.copy(audio_path, tr.audio_mp3_filename)
-
-    # Anonymous GET without token should be 403 or 404 depending on access; we call mp3
-    resp = await client.get(f"/transcripts/{t.id}/audio/mp3")
-    assert resp.status_code == 403
-
-    # With token should succeed
-    token = create_access_token(
-        {"sub": tr.user_id}, expires_delta=__import__("datetime").timedelta(minutes=15)
-    )
-    resp2 = await client.get(f"/transcripts/{t.id}/audio/mp3", params={"token": token})
-    assert resp2.status_code == 200

server/tests/test_transcripts.py

@@ -1,3 +1,5 @@
+from contextlib import asynccontextmanager
+
 import pytest
 
 
@@ -17,7 +19,7 @@ async def test_transcript_create(client):
 
 
 @pytest.mark.asyncio
-async def test_transcript_get_update_name(authenticated_client, client):
+async def test_transcript_get_update_name(client):
     response = await client.post("/transcripts", json={"name": "test"})
     assert response.status_code == 200
     assert response.json()["name"] == "test"
@@ -38,7 +40,7 @@ async def test_transcript_get_update_name(authenticated_client, client):
 
 
 @pytest.mark.asyncio
-async def test_transcript_get_update_locked(authenticated_client, client):
+async def test_transcript_get_update_locked(client):
     response = await client.post("/transcripts", json={"name": "test"})
     assert response.status_code == 200
     assert response.json()["locked"] is False
@@ -59,7 +61,7 @@ async def test_transcript_get_update_locked(authenticated_client, client):
 
 
 @pytest.mark.asyncio
-async def test_transcript_get_update_summary(authenticated_client, client):
+async def test_transcript_get_update_summary(client):
     response = await client.post("/transcripts", json={"name": "test"})
     assert response.status_code == 200
     assert response.json()["long_summary"] is None
@@ -87,7 +89,7 @@ async def test_transcript_get_update_summary(authenticated_client, client):
 
 
 @pytest.mark.asyncio
-async def test_transcript_get_update_title(authenticated_client, client):
+async def test_transcript_get_update_title(client):
     response = await client.post("/transcripts", json={"name": "test"})
     assert response.status_code == 200
     assert response.json()["title"] is None
@@ -125,6 +127,56 @@ async def test_transcripts_list_anonymous(client):
         settings.PUBLIC_MODE = False
 
 
+@asynccontextmanager
+async def authenticated_client_ctx():
+    from reflector.app import app
+    from reflector.auth import current_user, current_user_optional
+
+    app.dependency_overrides[current_user] = lambda: {
+        "sub": "randomuserid",
+        "email": "test@mail.com",
+    }
+    app.dependency_overrides[current_user_optional] = lambda: {
+        "sub": "randomuserid",
+        "email": "test@mail.com",
+    }
+    yield
+    del app.dependency_overrides[current_user]
+    del app.dependency_overrides[current_user_optional]
+
+
+@asynccontextmanager
+async def authenticated_client2_ctx():
+    from reflector.app import app
+    from reflector.auth import current_user, current_user_optional
+
+    app.dependency_overrides[current_user] = lambda: {
+        "sub": "randomuserid2",
+        "email": "test@mail.com",
+    }
+    app.dependency_overrides[current_user_optional] = lambda: {
+        "sub": "randomuserid2",
+        "email": "test@mail.com",
+    }
+    yield
+    del app.dependency_overrides[current_user]
+    del app.dependency_overrides[current_user_optional]
+
+
+@pytest.fixture
+@pytest.mark.asyncio
+async def authenticated_client():
+    async with authenticated_client_ctx():
+        yield
+
+
+@pytest.fixture
+@pytest.mark.asyncio
+async def authenticated_client2():
+    async with authenticated_client2_ctx():
+        yield
+
+
 @pytest.mark.asyncio
 async def test_transcripts_list_authenticated(authenticated_client, client):
     # XXX this test is a bit fragile, as it depends on the storage which
@@ -147,7 +199,7 @@ async def test_transcripts_list_authenticated(authenticated_client, client):
 
 
 @pytest.mark.asyncio
-async def test_transcript_delete(authenticated_client, client):
+async def test_transcript_delete(client):
     response = await client.post("/transcripts", json={"name": "testdel1"})
     assert response.status_code == 200
     assert response.json()["name"] == "testdel1"
@@ -162,7 +214,7 @@ async def test_transcript_delete(authenticated_client, client):
 
 
 @pytest.mark.asyncio
-async def test_transcript_mark_reviewed(authenticated_client, client):
+async def test_transcript_mark_reviewed(client):
     response = await client.post("/transcripts", json={"name": "test"})
     assert response.status_code == 200
     assert response.json()["name"] == "test"

server/tests/test_transcripts_audio_download.py

@@ -111,9 +111,7 @@ async def test_transcript_audio_download_range_with_seek(
 
 
 @pytest.mark.asyncio
-async def test_transcript_delete_with_audio(
-    authenticated_client, fake_transcript, client
-):
+async def test_transcript_delete_with_audio(fake_transcript, client):
     response = await client.delete(f"/transcripts/{fake_transcript.id}")
     assert response.status_code == 200
     assert response.json()["status"] == "ok"

server/tests/test_transcripts_participants.py

@@ -2,7 +2,7 @@ import pytest
 
 
 @pytest.mark.asyncio
-async def test_transcript_participants(authenticated_client, client):
+async def test_transcript_participants(client):
     response = await client.post("/transcripts", json={"name": "test"})
     assert response.status_code == 200
     assert response.json()["participants"] == []
@@ -39,7 +39,7 @@ async def test_transcript_participants(authenticated_client, client):
 
 
 @pytest.mark.asyncio
-async def test_transcript_participants_same_speaker(authenticated_client, client):
+async def test_transcript_participants_same_speaker(client):
     response = await client.post("/transcripts", json={"name": "test"})
     assert response.status_code == 200
     assert response.json()["participants"] == []
@@ -62,7 +62,7 @@ async def test_transcript_participants_same_speaker(authenticated_client, client
 
 
 @pytest.mark.asyncio
-async def test_transcript_participants_update_name(authenticated_client, client):
+async def test_transcript_participants_update_name(client):
     response = await client.post("/transcripts", json={"name": "test"})
     assert response.status_code == 200
     assert response.json()["participants"] == []
@@ -100,7 +100,7 @@ async def test_transcript_participants_update_name(authenticated_client, client)
 
 
 @pytest.mark.asyncio
-async def test_transcript_participants_update_speaker(authenticated_client, client):
+async def test_transcript_participants_update_speaker(client):
     response = await client.post("/transcripts", json={"name": "test"})
     assert response.status_code == 200
     assert response.json()["participants"] == []