wip

Restrict arm64 builds to release tags only, instead of running them on
every build.

The arm64 pipeline was significantly slowing down CI with little
practical usage, degrading developer experience for regular workflows.

Keep arm64 builds for release validation, and handle occasional failures
manually if needed.

.dockerignore

@@ -4,7 +4,7 @@ __pycache__
 **/__pycache__
 **/*.pyc
 venv
-.venv
+**/.venv
 
 # System-specific files
 .DS_Store
@@ -24,13 +24,15 @@ data
 .cache
 .circleci
 .git
-.vscode
 .iml
-.idea
 db.sqlite3
-.mypy_cache
 .pylint.d
-.pytest_cache
+
+**/.idea
+**/.vscode
+**/.pytest_cache
+**/.mypy_cache
+**/.ruff_cache
 
 # Frontend
-node_modules
+**/node_modules

.github/workflows/docker-hub.yml

@@ -12,20 +12,28 @@ on:
     branches:
       - 'main'
 
+permissions:
+  contents: read
+
 env:
   DOCKER_USER: 1001:127
   DOCKER_CONTAINER_REGISTRY_HOSTNAME: docker.io
   DOCKER_CONTAINER_REGISTRY_NAMESPACE: lasuite
+  IS_MULTI_PLATFORM_BUILD: ${{ startsWith(github.ref, 'refs/tags/v') }}
+  BUILD_PLATFORMS: ${{ startsWith(github.ref, 'refs/tags/v') && 'linux/amd64,linux/arm64' || 'linux/amd64' }}
 
 jobs:
   build-and-push-backend:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     steps:
       -
         name: Checkout repository
         uses: actions/checkout@v6
       -
         name: Set up QEMU
+        if: env.IS_MULTI_PLATFORM_BUILD == 'true'
         uses: docker/setup-qemu-action@v3
       -
         name: Set up Docker Buildx
@@ -43,19 +51,19 @@ jobs:
         with:
           username: ${{ secrets.DOCKER_HUB_USER }}
           password: ${{ secrets.DOCKER_HUB_PASSWORD }}
-#      -
-#        name: Run trivy scan
-#        uses: numerique-gouv/action-trivy-cache@main
-#        with:
-#          docker-build-args: '--target backend-production -f Dockerfile'
-#          docker-image-name: '${{ env.DOCKER_CONTAINER_REGISTRY_HOSTNAME }}/${{ env.DOCKER_CONTAINER_REGISTRY_NAMESPACE }}/meet-backend:${{ github.sha }}'
+      -
+        name: Run trivy scan
+        uses: numerique-gouv/action-trivy-cache@main
+        with:
+          docker-build-args: '--target backend-production -f Dockerfile'
+          docker-image-name: '${{ env.DOCKER_CONTAINER_REGISTRY_HOSTNAME }}/${{ env.DOCKER_CONTAINER_REGISTRY_NAMESPACE }}/meet-backend:${{ github.sha }}'
       -
         name: Build and push
         uses: docker/build-push-action@v6
         with:
           context: .
           target: backend-production
-          platforms: linux/amd64,linux/arm64
+          platforms: ${{ env.BUILD_PLATFORMS }}
           build-args: DOCKER_USER=${{ env.DOCKER_USER }}:-1000
           push: ${{ github.event_name != 'pull_request' }}
           tags: ${{ steps.meta.outputs.tags }}
@@ -63,12 +71,15 @@ jobs:
 
   build-and-push-frontend-generic:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     steps:
       -
         name: Checkout repository
         uses: actions/checkout@v6
       -
         name: Set up QEMU
+        if: env.IS_MULTI_PLATFORM_BUILD == 'true'
         uses: docker/setup-qemu-action@v3
       -
         name: Set up Docker Buildx
@@ -86,12 +97,12 @@ jobs:
         with:
           username: ${{ secrets.DOCKER_HUB_USER }}
           password: ${{ secrets.DOCKER_HUB_PASSWORD }}
-#      -
-#        name: Run trivy scan
-#        uses: numerique-gouv/action-trivy-cache@main
-#        with:
-#          docker-build-args: '-f src/frontend/Dockerfile --target frontend-production'
-#          docker-image-name: '${{ env.DOCKER_CONTAINER_REGISTRY_HOSTNAME }}/${{ env.DOCKER_CONTAINER_REGISTRY_NAMESPACE }}/meet-frontend:${{ github.sha }}'
+      -
+        name: Run trivy scan
+        uses: numerique-gouv/action-trivy-cache@main
+        with:
+          docker-build-args: '-f src/frontend/Dockerfile --target frontend-production'
+          docker-image-name: '${{ env.DOCKER_CONTAINER_REGISTRY_HOSTNAME }}/${{ env.DOCKER_CONTAINER_REGISTRY_NAMESPACE }}/meet-frontend:${{ github.sha }}'
       -
         name: Build and push
         uses: docker/build-push-action@v6
@@ -99,7 +110,7 @@ jobs:
           context: .
           file: ./src/frontend/Dockerfile
           target: frontend-production
-          platforms: linux/amd64,linux/arm64
+          platforms: ${{ env.BUILD_PLATFORMS }}
           build-args: DOCKER_USER=${{ env.DOCKER_USER }}:-1000
           push: ${{ github.event_name != 'pull_request' }}
           tags: ${{ steps.meta.outputs.tags }}
@@ -107,12 +118,15 @@ jobs:
 
   build-and-push-frontend-dinum:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     steps:
       -
         name: Checkout repository
         uses: actions/checkout@v6
       -
         name: Set up QEMU
+        if: env.IS_MULTI_PLATFORM_BUILD == 'true'
         uses: docker/setup-qemu-action@v3
       -
         name: Set up Docker Buildx
@@ -130,12 +144,12 @@ jobs:
         with:
           username: ${{ secrets.DOCKER_HUB_USER }}
           password: ${{ secrets.DOCKER_HUB_PASSWORD }}
-#      -
-#        name: Run trivy scan
-#        uses: numerique-gouv/action-trivy-cache@main
-#        with:
-#          docker-build-args: '-f docker/dinum-frontend/Dockerfile --target frontend-production'
-#          docker-image-name: '${{ env.DOCKER_CONTAINER_REGISTRY_HOSTNAME }}/${{ env.DOCKER_CONTAINER_REGISTRY_NAMESPACE }}/meet-frontend-dinum:${{ github.sha }}'
+      -
+        name: Run trivy scan
+        uses: numerique-gouv/action-trivy-cache@main
+        with:
+          docker-build-args: '-f docker/dinum-frontend/Dockerfile --target frontend-production'
+          docker-image-name: '${{ env.DOCKER_CONTAINER_REGISTRY_HOSTNAME }}/${{ env.DOCKER_CONTAINER_REGISTRY_NAMESPACE }}/meet-frontend-dinum:${{ github.sha }}'
       -
         name: Build and push
         uses: docker/build-push-action@v6
@@ -143,7 +157,7 @@ jobs:
           context: .
           file: ./docker/dinum-frontend/Dockerfile
           target: frontend-production
-          platforms: linux/amd64,linux/arm64
+          platforms: ${{ env.BUILD_PLATFORMS }}
           build-args: DOCKER_USER=${{ env.DOCKER_USER }}:-1000
           push: ${{ github.event_name != 'pull_request' }}
           tags: ${{ steps.meta.outputs.tags }}
@@ -151,12 +165,15 @@ jobs:
 
   build-and-push-summary:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     steps:
       -
         name: Checkout repository
         uses: actions/checkout@v6
       -
         name: Set up QEMU
+        if: env.IS_MULTI_PLATFORM_BUILD == 'true'
         uses: docker/setup-qemu-action@v3
       -
         name: Set up Docker Buildx
@@ -174,13 +191,13 @@ jobs:
         with:
           username: ${{ secrets.DOCKER_HUB_USER }}
           password: ${{ secrets.DOCKER_HUB_PASSWORD }}
-#      -
-#        name: Run trivy scan
-#        uses: numerique-gouv/action-trivy-cache@main
-#        continue-on-error: true
-#        with:
-#          docker-build-args: '-f src/summary/Dockerfile --target production'
-#          docker-image-name: '${{ env.DOCKER_CONTAINER_REGISTRY_HOSTNAME }}/${{ env.DOCKER_CONTAINER_REGISTRY_NAMESPACE }}/meet-summary:${{ github.sha }}'
+      -
+        name: Run trivy scan
+        uses: numerique-gouv/action-trivy-cache@main
+        continue-on-error: true
+        with:
+          docker-build-args: '-f src/summary/Dockerfile --target production'
+          docker-image-name: '${{ env.DOCKER_CONTAINER_REGISTRY_HOSTNAME }}/${{ env.DOCKER_CONTAINER_REGISTRY_NAMESPACE }}/meet-summary:${{ github.sha }}'
           docker-context: './src/summary'
       -
         name: Build and push
@@ -189,7 +206,7 @@ jobs:
           context: ./src/summary
           file: ./src/summary/Dockerfile
           target: production
-          platforms: linux/amd64,linux/arm64
+          platforms: ${{ env.BUILD_PLATFORMS }}
           build-args: DOCKER_USER=${{ env.DOCKER_USER }}:-1000
           push: ${{ github.event_name != 'pull_request' }}
           tags: ${{ steps.meta.outputs.tags }}
@@ -197,12 +214,15 @@ jobs:
 
   build-and-push-agents:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     steps:
       -
         name: Checkout repository
         uses: actions/checkout@v6
       -
         name: Set up QEMU
+        if: env.IS_MULTI_PLATFORM_BUILD == 'true'
         uses: docker/setup-qemu-action@v3
       -
         name: Set up Docker Buildx
@@ -220,14 +240,14 @@ jobs:
         with:
           username: ${{ secrets.DOCKER_HUB_USER }}
           password: ${{ secrets.DOCKER_HUB_PASSWORD }}
-#      -
-#        name: Run trivy scan
-#        uses: numerique-gouv/action-trivy-cache@main
-#        continue-on-error: true
-#        with:
-#          docker-build-args: '-f src/agents/Dockerfile --target production'
-#          docker-image-name: '${{ env.DOCKER_CONTAINER_REGISTRY_HOSTNAME }}/${{ env.DOCKER_CONTAINER_REGISTRY_NAMESPACE }}/meet-agents:${{ github.sha }}'
-#          docker-context: './src/agents'
+      -
+        name: Run trivy scan
+        uses: numerique-gouv/action-trivy-cache@main
+        continue-on-error: true
+        with:
+          docker-build-args: '-f src/agents/Dockerfile --target production'
+          docker-image-name: '${{ env.DOCKER_CONTAINER_REGISTRY_HOSTNAME }}/${{ env.DOCKER_CONTAINER_REGISTRY_NAMESPACE }}/meet-agents:${{ github.sha }}'
+          docker-context: './src/agents'
       -
         name: Build and push
         uses: docker/build-push-action@v6
@@ -235,13 +255,15 @@ jobs:
           context: ./src/agents
           file: ./src/agents/Dockerfile
           target: production
-          platforms: linux/amd64,linux/arm64
+          platforms: ${{ env.BUILD_PLATFORMS }}
           build-args: DOCKER_USER=${{ env.DOCKER_USER }}:-1000
           push: ${{ github.event_name != 'pull_request' }}
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
 
   notify-argocd:
+    permissions:
+      contents: read
     needs:
       - build-and-push-frontend-generic
       - build-and-push-frontend-dinum

.github/workflows/meet.yml

@@ -124,15 +124,17 @@ jobs:
         uses: actions/setup-python@v6
         with:
           python-version: "3.13"
-          cache: "pip"
-      - name: Install development dependencies
-        run: pip install --user .[dev]
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+      - name: Install the project
+        run: uv sync --locked --all-extras
+
       - name: Check code formatting with ruff
-        run: ~/.local/bin/ruff format . --diff
+        run: uv run ruff format . --diff
       - name: Lint code with ruff
-        run: ~/.local/bin/ruff check .
+        run: uv run ruff check .
       - name: Lint code with pylint
-        run: ~/.local/bin/pylint meet demo core
+        run: uv run pylint meet demo core
 
   lint-agents:
     runs-on: ubuntu-latest
@@ -148,13 +150,14 @@ jobs:
         uses: actions/setup-python@v6
         with:
           python-version: "3.13"
-          cache: "pip"
-      - name: Install development dependencies
-        run: pip install --user .[dev]
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+      - name: Install the project
+        run: uv sync --locked --all-extras
       - name: Check code formatting with ruff
-        run: ~/.local/bin/ruff format . --diff
+        run: uv run ruff format . --diff
       - name: Lint code with ruff
-        run: ~/.local/bin/ruff check .
+        run: uv run ruff check .
 
   lint-summary:
     runs-on: ubuntu-latest
@@ -221,8 +224,6 @@ jobs:
       DB_PORT: 5432
       REDIS_URL: redis://localhost:6379/1
       STORAGES_STATICFILES_BACKEND: django.contrib.staticfiles.storage.StaticFilesStorage
-      LIVEKIT_API_SECRET: secret
-      LIVEKIT_API_KEY: devkey
       AWS_S3_ENDPOINT_URL: http://localhost:9000
       AWS_S3_ACCESS_KEY_ID: meet
       AWS_S3_SECRET_ACCESS_KEY: password
@@ -230,6 +231,7 @@ jobs:
       OIDC_RS_CLIENT_SECRET: ThisIsAnExampleKeyForDevPurposeOnly
       OIDC_OP_INTROSPECTION_ENDPOINT: https://oidc.example.com/introspect
       OIDC_OP_URL: https://oidc.example.com
+      MEDIA_BASE_URL: http://localhost:8083
 
     steps:
       - name: Checkout repository
@@ -278,10 +280,10 @@ jobs:
         uses: actions/setup-python@v6
         with:
           python-version: "3.13"
-          cache: "pip"
-
-      - name: Install development dependencies
-        run: pip install --user .[dev]
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+      - name: Install the dependencies
+        run: uv sync --locked --all-extras
 
       - name: Install gettext (required to compile messages)
         run: |
@@ -289,10 +291,54 @@ jobs:
           sudo apt-get install -y gettext
 
       - name: Generate a MO file from strings extracted from the project
-        run: python manage.py compilemessages
+        run: uv run python manage.py compilemessages
 
       - name: Run tests
-        run: ~/.local/bin/pytest -n 2
+        run: uv run pytest -n 2
+
+  test-summary:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    defaults:
+      run:
+        working-directory: src/summary
+
+    env:
+      V1_TENANT_ID: 'test-tenant'
+      AUTHORIZED_TENANTS: '[{"id": "test-tenant", "api_key": "test-api-token", "webhook_url": "https://example.com/webhook", "webhook_api_key": "test-webhook-api-key"}]'
+      AWS_STORAGE_BUCKET_NAME: "http://meet-media-storage"
+      AWS_S3_ENDPOINT_URL: "minio:9000"
+      AWS_S3_ACCESS_KEY_ID: "meet"
+      AWS_S3_SECRET_ACCESS_KEY: "password"
+      WHISPERX_BASE_URL: "https://configure-your-url.com"
+      WHISPERX_ASR_MODEL: "large-v2"
+      WHISPERX_API_KEY: "test-whisperx-secret"
+      WHISPERX_DEFAULT_LANGUAGE: "fr"
+      LLM_BASE_URL: "https://configure-your-url.com"
+      LLM_API_KEY: "test-llm-secret"
+      LLM_MODEL: "test-llm-model"
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Install ffmpeg
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y ffmpeg
+
+      - name: Install Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+          cache: "pip"
+
+      - name: Install development dependencies
+        run: pip install --user .[dev]
+
+      - name: Run summary tests
+        run: ~/.local/bin/pytest
 
   lint-front:
     runs-on: ubuntu-latest

.gitignore

@@ -31,6 +31,7 @@ MANIFEST
 
 # Translations	# Translations
 *.pot
+*.mo
 
 # Environments
 .env
@@ -82,3 +83,6 @@ docker/livekit/out
 
 # LiveKit CA configuration
 docker/livekit/rootCA.pem
+
+# Frontend rollup-plugin-visualizer
+/src/frontend/rollup-plugin-visualizer/*

CHANGELOG.md

@@ -8,14 +8,218 @@ and this project adheres to
 
 ## [Unreleased]
 
-## [1.10.0] - 2026-03-05
+### Added
+
+- ✨(backend) add structured audit logging
+
+## [1.19.0] - 2026-06-04
+
+### Added
+
+- ✨(backend) add file specific admin #1387
+
+### Changed
+
+- 🐛(agents) fix bug when closing metadata-collector
+- ⬆️(dependencies) update python dependencies
+- ⬆️(frontend) update js dependencies
+- ♻️(agents) replace deprecated room options API
 
 ### Fixed
 
-- 🩹(frontend) remove incorrect reference to ProConnect on the prejoin #1080
-- ✨(frontend) add Ctrl+Shift+/ to open shortcuts settings #1050
-- ♿(frontend) announce selected state to screen readers #1081
-- 💄(frontend) truncate long names with ellipsis in reaction overlay #1099
+- 🔇(summary) make ffmpeg quiet #1404
+- 🔒️(backend) prevent accessing files if they are not ready #1395
+- ⬆️(backend) upgrade idna to >=3.15 to address CVE-2026-45409
+
+## [1.18.0] - 2026-06-03
+
+### Added
+
+- 🔧(backend) backport logging configuration from docs
+- 🧑‍💻(backend) add management command to merge duplicate users
+- 👷(helm) add Kubernetes job for duplicate user merge command
+
+### Fixed
+
+- 🐛(backend) prevent duplicate pending users on concurrent requests
+- 🔒️(backend) prevent file change post checks #1377
+
+## [1.17.0] - 2026-05-31
+
+### Added
+
+- ✨(fullstack) allow participants to mute others based on room configuration
+- ✨(frontend) add synchronizer for room metadata updates
+- ✨(frontend) make reaction toolbar responsive on small viewports
+- ✨(frontend) enable reactions on mobile devices
+- ✨(frontend) introduce picture-in-picture meeting
+- ✨(backend) add core.recording.event.parsers.S3Parser
+- ✨(summary) extended support for all video / audio files #1358
+
+### Changed
+
+- ♻️(fullstack) simplify source serialization
+- ✨(backend) expose room configuration to all API consumers
+- 🩹(frontend) improve reaction toolbar centering with dynamic positioning
+- 🚀 (paas) remove buildpack requirements.txt to use the new uv.lock #1349
+- ✨(backend) allow room configuration and access level via external api #1260
+- ♻️(backend) prefix Swagger routes with /api
+
+### Fixed
+
+- 🩹(backend) fix swagger and redoc documentation URLs
+
+## [1.16.0] - 2026-05-13
+
+### Added
+
+- 🔒️(backend) add validation of Room.configuration
+- ✨(helm) add support multiple transcribe worker / endpoint #1247
+- ✨(backend) make LiveKit Egress recording encoding configurable #1288
+- ✨(summary) add speaker-to-participant assignment
+
+### Changed
+
+- ♻️(summary) change tasks endpoint signature
+- ⬆️(dependencies) update urllib3 to v2.7.0 [SECURITY]
+- 🧑‍💻(agents) use `uv` for package management
+- ✨(summary) improve speaker-to-participant assignment
+
+### Fixed
+
+- ♻(frontend) standardize role terminology across localizations
+- 🐛(backend) make start-recording atomic and fault-tolerant
+- 🔒️(frontend) room ids are generated with non-cryptographic rand
+- ⬆️(mail) fix dependencies not having resolved or integrity field #1321
+- 🐛(summary) complete webm support #1328
+- 🐛(backend) add link to "Open" text in recording email
+- 🩹(frontend) fix spacing regression in mobile control bar
+
+## [1.15.0] - 2026-04-30
+
+### Added
+
+- ✨(backend) add metadata collection of VAD, connection and chat events
+- ✨(backend) introduce add-ons authentication backend
+- 💬(backend) clarify french transcription audio download link text #1299
+- 🚧(addons) introduce initial Microsoft Outlook add-in support (alpha)
+- 🔧(backend) add setting to toggle application token exchange mechanism
+- ✨(backend) support add-ons authentication in external viewset
+
+### Fixed
+
+- 🐛(summary) support webm #1290
+- ⬆️(backend) bump django-lasuite to v0.0.26
+- 🩹(frontend) use a more standard (quality) rating scale
+- 🩹(frontend) fix access control for screen recording feature flag
+- 🩹(frontend) fix reconnect loop caused by connectionObserverStore updates
+
+## [1.14.0] - 2026-04-16
+
+### Added
+
+- 🔒️(helm) Add pod and container securityContext #1197
+- ✨(summary) add routes v2 for async STT and summary tasks #1171
+- ✅(backend) add unit tests for JwtTokenService #1232
+
+### Changed
+
+- ⬆️(backend) bump lodash from 4.17.23 to 4.18.1 in /src/mail
+- ⬆️(frontend) bump hono from 4.12.8 to 4.12.12 in /src/frontend
+- ⬆️(backend) bump pygments from 2.19.2 to 2.20.0 in /src/backend
+- ♻️(backend) use Authorization header for LiveKit token authentication
+- 🥅(backend) refine Twirp error handling for participant operations
+- ✨(summary) allow more file extensions #1265
+- ♿️(frontend) refocus reactions toolbar with ctrl+shift+e is activated #1262
+- ♿️(frontend) set an explicit document title on recording download page #1261
+- ♿️(frontend) add customizable accessibility fonts #1270
+
+### Fixed
+
+- ⬆️(dependencies) update aiohttp to v3.13.4 [SECURITY]
+- ⬆️(dependencies) update vite to v7.3.2 [SECURITY]
+- ⬆️(dependencies) update django to v5.2.13 [SECURITY]
+- 🔒(backend) rely on backend to allow participant update their metadata
+- 🐛(summary) fix failure webhook notification #1233
+- 🐛(summary) relax whisperX payload format #1233
+- ⬆️(backend) upgrade dependencies to fix Pillow CVE-2026-40192
+- ⬆️(frontend) upgrade frontend image to Alpine 3.23 to address CVEs
+
+## [1.13.0] - 2026-03-31
+
+### Changed
+
+- ⬆️(dependencies) update python dependencies
+- ♿️(frontend) add explicit region for call controls #1216
+- ♿️(frontend) improve accessibility of the reaction toolbar #1216
+- ♿️(frontend) enhance sidepanel navigation accessibility #1216
+
+### Fixed
+
+- 🔒️(backend) fix email disclosure in room invitation endpoint #1200
+- 🐛(backend) fix regression in update-participant endpoint #1204
+
+## [1.12.0] - 2026-03-24
+
+### Changed
+
+- ♻️(backend) configurable SESSION_ENGINE #1038 #1154
+- ♿️(frontend) fix sidepanel accessibility aria-label #1182
+- ♿️(frontend) fix more tools heading hierarchy #1181
+- ♿️(fronted) improve button descriptions for More tools actions #1184
+- 💄(spinner) enforce spinner height #1183
+- 💄(custom-background) add upload indicator with preview #1183
+- ♿️(backend) improve logo accessibility in recording email notification #1092
+- ♿️(summary) improve accessibility of transcription download link #1187
+- 💄(frontend) show OS-specific shortcut in participant tile hint #1193
+- ⬆️(frontend) bump flatted from 3.3.1 to 3.4.2 in /src/frontend #1188
+- ⬆️️️(frontend) bump undici from 6.23.0 to 6.24.1 in /src/frontend
+- ⬆️️️(frontend) bump hono from 4.12.2 to 4.12.7 in /src/frontend
+- ⬆️️️(frontend) bump dompurify from 3.3.1 to 3.3.2 in /src/frontend
+
+### Fixed
+
+- 🐛(frontend) disable personal custom background while deleting #1183
+- 🐛(frontend) auto-select new custom background when not logged in #1183
+- 🐛(frontend) fix device selection not applying during conference #1156
+
+## [1.11.0] - 2026-03-19
+
+### Added
+
+- ✨(helm) support celery with our Django backend #1124
+- ✨(helm) support ingress for custom background image #1124
+- ✨(backend) add authenticated user rate throttling on request-entry #1129
+- ✨(backend) expose `is_active` field for Application in Django admin #1133
+- ✨(file-upload) disable by default & limit count by user #1141
+- ✨(frontend) custom background #1067
+
+### Changed
+
+- ♿️(frontend) Caption text size setting for accessibility #1062
+- ♿️(frontend) sync html lang attribute with i18n for screen readers #1111
+- ♿️(frontend) improve MoreLink a11y and UX on home page #1112
+- ♿️(frontend) improve chat toast a11y for screen readers #1109
+- ♿️(frontend) improve ui and aria labels for help article links #1108
+- 🌐(frontend) improve German translation #1125
+- 🔨(python-env) migrate meet main app to UV #1120
+- ♻️(backend) align Application model field with `is_active` convention #1133
+- 🔐(backend) avoids revealing the inactive status of an application #1135
+- ⚡️(helm) reduce initialDelaySeconds and add periods seconds #1139
+- 🔒️(backend) avoid information exposure through exception messages #1144
+- ⬆️(dependencies) update PyJWT to v2.12.0 [SECURITY] #1151
+- 📌(agents) unpin OpenSSL and related dependencies #1167
+- ♿️(frontend) add caption font and background color customization #1122
+
+### Fixed
+
+- 🐛(frontend) fix hand icon and queue position alignment and position #1119
+- 🩹(backend) add page_size to pagination for room endpoints #1131
+- 🐛(backend) refactor lobby throttling to use participant id #1129
+- 🩹(backend) ignore non-recording uploads in storage webhook handler #1142
+- 🐛(frontend) fix dimension mismatch in BackgroundCustomProcessor #1116
+
+## [1.10.0] - 2026-03-05
 
 ### Changed
 
@@ -23,12 +227,22 @@ and this project adheres to
 - 🦺(backend) strengthen API validation for recording options #1063
 - ⚡️(frontend) optimize few performance caveats #1073
 - 🔒️(helm) introduce a dedicated Kubernetes Ingress for webhook-livekit #1066
+- ⬆️(deps) bump rollup from 4.44.2 to 4.59.0 in /src/frontend #1088
 
 ### Fixed
 
 - 🐛(migrations) use settings in migrations #1058
 - 💄(frontend) truncate pinned participant name with ellipsis on overflow #1056
 - ♿(frontend) prevent focus ring clipping on invite dialog #1078
+- ♿(frontend) dynamic tab title when connected to meeting #1060
+- 🩹(frontend) remove incorrect reference to ProConnect on the prejoin #1080
+- ✨(frontend) add Ctrl+Shift+/ to open shortcuts settings #1050
+- ♿(frontend) announce selected state to screen readers #1081
+- 💄(frontend) truncate long names with ellipsis in reaction overlay #1099
+
+### Added
+
+- ✨(backend) add file upload feature #1030
 
 ## [1.9.0] - 2026-03-02
 

Dockerfile

@@ -13,14 +13,28 @@ RUN apk update && \
 # ---- Back-end builder image ----
 FROM base AS back-builder
 
-WORKDIR /builder
 
-# Copy required python dependencies
-COPY ./src/backend /builder
+ENV UV_COMPILE_BYTECODE=1
+ENV UV_LINK_MODE=copy
 
-RUN mkdir /install && \
-  pip install --prefix=/install .
+# Disable Python downloads, because we want to use the system interpreter
+# across both images. If using a managed Python version, it needs to be
+# copied from the build image into the final image;
+ENV UV_PYTHON_DOWNLOADS=0
 
+# install uv
+COPY --from=ghcr.io/astral-sh/uv:0.10.9 /uv /uvx /bin/
+
+WORKDIR /app
+
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+  --mount=type=bind,source=src/backend/uv.lock,target=uv.lock \
+  --mount=type=bind,source=src/backend/pyproject.toml,target=pyproject.toml \
+  uv sync --locked --no-install-project --no-dev
+COPY src/backend /app
+RUN --mount=type=cache,target=/root/.cache/uv \
+  uv sync --locked --no-dev
 
 # ---- mails ----
 FROM node:20 AS mail-builder
@@ -30,7 +44,7 @@ COPY ./src/mail /mail/app
 WORKDIR /mail/app
 
 RUN yarn install --frozen-lockfile && \
-    yarn build
+  yarn build
 
 
 # ---- static link collector ----
@@ -39,19 +53,20 @@ ARG MEET_STATIC_ROOT=/data/static
 
 RUN apk add \
   pango \
+  libmagic \
   rdfind
 
-# Copy installed python dependencies
-COPY --from=back-builder /install /usr/local
-
-# Copy Meet application (see .dockerignore)
-COPY ./src/backend /app/
-
 WORKDIR /app
 
+# Copy the application from the builder
+COPY --from=back-builder /app /app
+
+ENV PATH="/app/.venv/bin:$PATH"
+
+
 # collectstatic
 RUN DJANGO_CONFIGURATION=Build DJANGO_JWT_PRIVATE_SIGNING_KEY=Dummy \
-    python manage.py collectstatic --noinput
+  python manage.py collectstatic --noinput
 
 # Replace duplicated file by a symlink to decrease the overall size of the
 # final image
@@ -68,6 +83,7 @@ RUN apk --no-cache add \
   gettext \
   libffi-dev \
   pango \
+  libmagic \
   shared-mime-info
 
 
@@ -79,14 +95,17 @@ COPY ./docker/files/usr/local/bin/entrypoint /usr/local/bin/entrypoint
 # docker user (see entrypoint).
 RUN chmod g=u /etc/passwd
 
-# Copy installed python dependencies
-COPY --from=back-builder /install /usr/local
-
-# Copy Meet application (see .dockerignore)
-COPY ./src/backend /app/
+# Copy the application from the builder
+COPY --from=back-builder /app /app
 
 WORKDIR /app
 
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Generate compiled translation messages
+RUN DJANGO_CONFIGURATION=Build \
+  python manage.py compilemessages --ignore=".venv/**/*"
+
 # We wrap commands run in this container by the following entrypoint that
 # creates a user on-the-fly with the container user ID (see USER) and root group
 # ID.
@@ -101,10 +120,9 @@ USER root:root
 # Install psql
 RUN apk add postgresql-client
 
-# Uninstall Meet and re-install it in editable mode along with development
-# dependencies
-RUN pip uninstall -y meet
-RUN pip install -e .[dev]
+# Install development dependencies
+RUN --mount=from=ghcr.io/astral-sh/uv:0.10.9,source=/uv,target=/bin/uv \
+  uv sync --all-extras --locked
 
 # Restore the un-privileged user running the application
 ARG DOCKER_USER
@@ -113,7 +131,7 @@ USER ${DOCKER_USER}
 # Target database host (e.g. database engine following docker compose services
 # name) & port
 ENV DB_HOST=postgresql \
-    DB_PORT=5432
+  DB_PORT=5432
 
 # Run django development server
 CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Makefile

@@ -73,7 +73,9 @@ create-env-files: \
 	env.d/development/crowdin \
 	env.d/development/postgresql \
 	env.d/development/kc_postgresql \
-	env.d/development/summary
+	env.d/development/summary \
+	env.d/development/kube-secret \
+	env.d/development/multi_user_transcriber
 .PHONY: create-env-files
 
 bootstrap: ## Prepare Docker images for the project
@@ -94,6 +96,7 @@ bootstrap: \
 build: ## build the project containers
 	@$(MAKE) build-backend
 	@$(MAKE) build-frontend
+	@$(MAKE) build-agents
 .PHONY: build
 
 build-backend: ## build the app-dev container
@@ -105,6 +108,10 @@ build-frontend: ## build the frontend container
 	@$(COMPOSE) build frontend
 .PHONY: build-frontend
 
+build-agents: ## build the multi-user-transcriber agent container
+	@$(COMPOSE) build multi-user-transcriber-dev
+.PHONY: build-agents
+
 down: ## stop and remove containers, networks, images, and volumes
 	@$(COMPOSE) down
 .PHONY: down
@@ -114,7 +121,8 @@ logs: ## display app-dev logs (follow mode)
 .PHONY: logs
 
 run-backend: ## start only the backend application and all needed services
-	@$(COMPOSE) up --force-recreate -d celery-dev
+	@$(COMPOSE) up --force-recreate -d celery-dev --remove-orphans
+	@$(COMPOSE) up --force-recreate -d nginx
 	@echo "Wait for postgresql to be up..."
 	@$(WAIT_DB)
 .PHONY: run-backend
@@ -124,10 +132,24 @@ run-summary: ## start only the summary application and all needed services
 	@$(COMPOSE) up --force-recreate -d celery-summary-summarize
 .PHONY: run-summary
 
+run-agents: ## start the multi-user-transcriber agent
+	@$(MAKE) run-agent-multi-user-transcriber
+	@$(MAKE) run-agent-metadata-collector
+.PHONY: run-agents
+
+run-agent-multi-user-transcriber: ## start the LiveKit agents (multi users transcriber)
+	@$(COMPOSE) up --force-recreate -d multi-user-transcriber-dev
+.PHONY: run-agent-multi-user-transcriber
+
+run-agent-metadata-collector: ## start the LiveKit agents (metadata collector)
+	@$(COMPOSE) up --force-recreate -d metadata-collector-dev
+.PHONY: run-agent-metadata-collector
+
 run:
 run: ## start the wsgi (production) and development server
 	@$(MAKE) run-backend
 	@$(MAKE) run-summary
+	@$(MAKE) run-agents
 	@$(COMPOSE) up --force-recreate -d frontend
 .PHONY: run
 
@@ -190,6 +212,7 @@ lint-pylint: ## lint back-end python sources with pylint only on changed files f
 
 test: ## run project tests
 	@$(MAKE) test-back-parallel
+	@$(MAKE) test-summary
 .PHONY: test
 
 test-back: ## run back-end tests
@@ -202,6 +225,11 @@ test-back-parallel: ## run all back-end tests in parallel
 	bin/pytest -n auto $${args:-${1}}
 .PHONY: test-back-parallel
 
+test-summary: ## run summary tests
+	@args="$(filter-out $@,$(MAKECMDGOALS))" && \
+	bin/pytest-summary $${args:-${1}}
+.PHONY: test-summary
+
 makemigrations:  ## run django makemigrations for the Meet project.
 	@echo "$(BOLD)Running makemigrations$(RESET)"
 	@$(COMPOSE) up -d postgresql
@@ -222,7 +250,7 @@ superuser: ## Create an admin superuser with password "admin"
 .PHONY: superuser
 
 back-i18n-compile: ## compile the gettext files
-	@$(MANAGE) compilemessages --ignore="venv/**/*"
+	@$(MANAGE) compilemessages --ignore=".venv/**/*"
 .PHONY: back-i18n-compile
 
 back-i18n-generate: ## create the .pot files used for i18n
@@ -258,6 +286,12 @@ env.d/development/kc_postgresql:
 env.d/development/summary:
 	cp -n env.d/development/summary.dist env.d/development/summary
 
+env.d/development/kube-secret:
+	cp -n env.d/development/kube-secret.dist env.d/development/kube-secret
+
+env.d/development/multi_user_transcriber:
+	cp -n env.d/development/multi_user_transcriber.dist env.d/development/multi_user_transcriber
+
 # -- Internationalization
 
 env.d/development/crowdin:
@@ -345,21 +379,15 @@ frontend-i18n-generate: \
 
 # -- K8S
 build-k8s-cluster: ## build the kubernetes cluster using kind
-	./bin/start-kind.sh
-.PHONY: build-k8s-cluster
-
-install-external-secrets: ## install the kubernetes secrets from Vaultwarden
-	./bin/install-external-secrets.sh
-.PHONY: build-k8s-cluster
-
-start-tilt: ## start the kubernetes cluster using kind
-	tilt up -f ./bin/Tiltfile
+build-k8s-cluster: \
+    env.d/development/kube-secret \
+    ./bin/start-kind.sh
 .PHONY: build-k8s-cluster
 
 start-tilt-keycloak: ## start the kubernetes cluster using kind, without Pro Connect for authentication, use keycloak
-	DEV_ENV=dev-keycloak tilt up -f ./bin/Tiltfile
+	DEV_ENV=dev-keycloak tilt up --namespace=meet -f ./bin/Tiltfile
 .PHONY: build-k8s-cluster
 
 start-tilt-dinum: ## start the kubernetes cluster using kind, without Pro Connect for authentication, but with DINUM styles
-	DEV_ENV=dev-dinum tilt up -f ./bin/Tiltfile
+	DEV_ENV=dev-dinum tilt up --namespace=meet -f ./bin/Tiltfile
 .PHONY: build-k8s-cluster

bin/Tiltfile

@@ -2,7 +2,7 @@ load('ext://uibutton', 'cmd_button', 'bool_input', 'location')
 load('ext://namespace', 'namespace_create', 'namespace_inject')
 namespace_create('meet')
 
-DEV_ENV = os.getenv('DEV_ENV', 'dev')
+DEV_ENV = os.getenv('DEV_ENV', 'dev-keycloak')
 
 if DEV_ENV == 'dev-dinum':
     update_settings(suppress_unused_image_warnings=["localhost:5001/meet-frontend-generic:latest"])
@@ -18,14 +18,13 @@ docker_build(
     'localhost:5001/meet-backend:latest',
     context='..',
     dockerfile='../Dockerfile',
-    build_args={'DOCKER_USER': '1001:127'},
     only=['./src/backend', './src/mail', './docker'],
     target = 'backend-production',
     live_update=[
         sync('../src/backend', '/app'),
         run(
-            'pip install -r /app/requirements.txt',
-            trigger=['./api/requirements.txt']
+            'uv sync --locked --no-dev',
+            trigger=['../src/backend/uv.lock', '../src/backend/pyproject.toml']
         )
     ]
 )
@@ -34,12 +33,12 @@ clean_old_images('localhost:5001/meet-backend')
 docker_build(
     'localhost:5001/meet-frontend-dinum:latest',
     context='..',
-    build_args={'DOCKER_USER': '1001:127'},
     dockerfile='../docker/dinum-frontend/Dockerfile',
-    only=['./src/frontend', './docker', './.dockerignore'],
+    only=['./src/frontend', './src/addons', './docker', './.dockerignore'],
     target = 'frontend-production',
     live_update=[
         sync('../src/frontend', '/home/frontend'),
+        sync('../src/addons', '/home/addons'),
     ]
 )
 clean_old_images('localhost:5001/meet-frontend-dinum')
@@ -59,7 +58,6 @@ clean_old_images('localhost:5001/meet-frontend-generic')
 docker_build(
     'localhost:5001/meet-summary:latest',
     context='../src/summary',
-    build_args={'DOCKER_USER': '1001:127'},
     dockerfile='../src/summary/Dockerfile',
     only=['.'],
     target = 'production',
@@ -72,7 +70,6 @@ clean_old_images('localhost:5001/meet-summary')
 docker_build(
     'localhost:5001/meet-agents:latest',
     context='../src/agents',
-    build_args={'DOCKER_USER': '1001:127'},
     dockerfile='../src/agents/Dockerfile',
     only=['.'],
     target = 'production',
@@ -99,14 +96,34 @@ docker_build(
 )
 clean_old_images('localhost:5001/meet-livekit')
 
-k8s_yaml(local('cd ../src/helm && helmfile -n meet -e ${DEV_ENV:-dev} template .'))
+load('ext://secret', 'secret_yaml_generic')
+k8s_yaml(secret_yaml_generic(
+    name="secret-dev",
+    from_env_file="../env.d/development/kube-secret"
+))
+
+k8s_yaml(local('cd ../src/helm && helmfile -n meet -e ${DEV_ENV:-dev-keycloak} template .'))
 
 k8s_resource('minio-bucket', resource_deps=['minio'])
 k8s_resource('meet-backend', resource_deps=['postgresql', 'minio', 'redis', 'livekit-livekit-server'])
-k8s_resource('meet-backend-migrate', resource_deps=['meet-backend'])
+k8s_resource('meet-celery-backend', resource_deps=['redis'])
+k8s_resource('meet-celery-summarize', resource_deps=['redis'])
+k8s_resource('meet-celery-summary-backend', resource_deps=['redis'])
+k8s_resource('meet-celery-transcribe-default', resource_deps=['redis'])
+k8s_resource('livekit-livekit-server', resource_deps=['redis'])
 k8s_resource('livekit-livekit-server-test-connection', resource_deps=['livekit-livekit-server'])
 k8s_resource('keycloak', resource_deps=['kc-postgresql'])
-k8s_resource('meet-backend-createsuperuser', resource_deps=['meet-backend-migrate'])
+# Trigger once on launch
+k8s_resource(
+    'meet-backend-createsuperuser',
+    resource_deps=['meet-backend-migrate'],
+    trigger_mode=TRIGGER_MODE_MANUAL,
+)
+k8s_resource(
+    'meet-backend-migrate',
+    resource_deps=['meet-backend'],
+    trigger_mode=TRIGGER_MODE_MANUAL,
+)
 
 migration = '''
 set -eu

bin/buildpack_postfrontend.sh

@@ -47,4 +47,3 @@ mv src/backend/* ./
 mv deploy/paas/* ./
 
 echo "3.13" > .python-version
-echo "." > requirements.txt

bin/prepare-release.sh

@@ -101,6 +101,12 @@ update_npm_version "mail"
 # Update backend pyproject.toml
 update_python_version "backend"
 
+# Run uv lock in backend
+print_info "Running uv lock in backend..."
+cd "src/backend"
+uv lock
+cd -
+
 # Update summary pyproject.toml
 update_python_version "summary"
 
@@ -149,6 +155,7 @@ echo "      - src/frontend/package.json"
 echo "      - src/sdk/package.json"
 echo "      - src/mail/package.json"
 echo "      - src/backend/pyproject.toml"
+echo "      - src/backend/uv.lock"
 echo "      - src/summary/pyproject.toml"
 echo "      - src/agents/pyproject.toml"
 echo "      - CHANGELOG.md"

bin/pytest-summary

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+source "$(dirname "${BASH_SOURCE[0]}")/_config.sh"
+
+_dc_run \
+    app-summary-dev \
+    python -m pytest "$@"

compose.yml

@@ -58,7 +58,7 @@ services:
       /usr/bin/mc admin config set meet notify_webhook:meet-webhook endpoint='http://app-dev:8000/api/v1.0/recordings/storage-hook/' auth_token='Bearer password' &&
       /usr/bin/mc admin service restart meet --wait --json &&
       sleep 15 &&
-      /usr/bin/mc event add meet/meet-media-storage arn:minio:sqs::meet-webhook:webhook --event put &&
+      /usr/bin/mc event add meet/meet-media-storage arn:minio:sqs::meet-webhook:webhook --event put --prefix "recordings" &&
       exit 0;"
 
   app-dev:
@@ -80,11 +80,11 @@ services:
     volumes:
       - ./src/backend:/app
       - ./data/static:/data/static
+      - /app/.venv
     depends_on:
         - postgresql
         - mailcatcher
         - redis
-        - nginx
         - livekit
         - createbuckets
         - createwebhook
@@ -106,6 +106,7 @@ services:
     volumes:
       - ./src/backend:/app
       - ./data/static:/data/static
+      - /app/.venv
     depends_on:
       - app-dev
 
@@ -148,6 +149,7 @@ services:
       - ./docker/files/etc/nginx/conf.d:/etc/nginx/conf.d:ro
     depends_on:
       - keycloak
+      - app-dev
     networks:
       - resource-server
       - default
@@ -244,6 +246,41 @@ services:
       depends_on:
         - redis
 
+  metadata-collector-dev:
+    build:
+      context: ./src/agents
+      target: development
+    command: ["python", "metadata_collector.py", "dev"]
+    environment:
+      - LIVEKIT_URL=ws://livekit:7880
+      - LIVEKIT_API_KEY=devkey
+      - LIVEKIT_API_SECRET=secret
+      - AWS_S3_ENDPOINT_URL=minio:9000
+      - AWS_S3_ACCESS_KEY_ID=meet
+      - AWS_S3_SECRET_ACCESS_KEY=password
+      - AWS_STORAGE_BUCKET_NAME=meet-media-storage
+      - AWS_S3_SECURE_ACCESS=False
+    volumes:
+      - ./src/agents:/app
+      - /app/.venv
+    depends_on:
+      - livekit
+      - minio
+    develop:
+      watch:
+        - action: rebuild
+          path: ./src/agents
+
+  multi-user-transcriber-dev:
+    build:
+      context: ./src/agents
+      target: development
+    env_file:
+      - env.d/development/multi_user_transcriber
+    volumes:
+      - ./src/agents:/app
+      - /app/.venv
+
   redis-summary:
     image: redis
     ports:

docker/dinum-frontend/Dockerfile

@@ -38,16 +38,32 @@ COPY ./docker/dinum-frontend/assets/ \
 COPY ./docker/dinum-frontend/fonts/ \
     ./dist/assets/fonts/
 
+# ---- Addons builder image ----
+FROM node:20-alpine AS addons-builder
+
+WORKDIR /home/addons/outlook
+
+COPY ./src/addons/outlook/package.json ./package.json
+COPY ./src/addons/outlook/package-lock.json ./package-lock.json
+
+RUN npm ci
+
+COPY ./src/addons/outlook/ .
+
+RUN npx webpack --mode production
+
+
 # ---- Front-end image ----
-FROM nginxinc/nginx-unprivileged:alpine3.21 AS frontend-production
+FROM nginxinc/nginx-unprivileged:alpine3.23 AS frontend-production
 
 USER root
-RUN apk update && apk upgrade libssl3 \
-    libcrypto3 \
-    libxml2>=2.12.7-r2 \
-    libxslt>=1.1.39-r2 \
-    libexpat>=2.7.2-r0 \
-    libpng>=1.6.53-r0
+
+# Security patches for known CVEs
+RUN apk update && apk upgrade  \
+    musl \
+    musl-utils \
+    zlib>=1.3.2-r0 \
+    && apk del curl
 
 USER nginx
 
@@ -59,7 +75,11 @@ COPY --from=meet-builder \
     /home/frontend/dist \
     /usr/share/nginx/html
 
-COPY ./src/frontend/default.conf /etc/nginx/conf.d
+COPY --from=addons-builder \
+    /home/addons/outlook/dist \
+    /usr/share/nginx/html/addons/outlook
+
+COPY ./docker/dinum-frontend/nginx/default.conf /etc/nginx/conf.d
 COPY ./docker/files/usr/local/bin/entrypoint /usr/local/bin/entrypoint
 
 ENTRYPOINT [ "/usr/local/bin/entrypoint" ]

docker/dinum-frontend/nginx/default.conf

@@ -0,0 +1,82 @@
+server {
+  listen 8080;
+  server_name localhost;
+  server_tokens off;
+
+  root /usr/share/nginx/html;
+
+  location = /.well-known/windows-app-web-link {
+      default_type application/json;
+      alias /usr/share/nginx/html/.well-known/windows-app-web-link;
+      add_header Content-Disposition "attachment; filename=windows-app-web-link";
+  }
+
+  # Manifest — fetched, never iframed
+  location = /addons/outlook/manifest.xml {
+      alias /usr/share/nginx/html/addons/outlook/manifest.xml;
+
+      add_header Access-Control-Allow-Origin "*";
+      add_header Cache-Control "no-cache, no-store, must-revalidate";
+      add_header X-Frame-Options "DENY";
+      add_header Content-Security-Policy "frame-ancestors 'none'";
+  }
+
+  location = /addons/outlook/assets/ {
+      return 404;
+  }
+
+  location ~* ^/addons/outlook/assets/(.+\.(?:css|js|json|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot))/?$ {
+      root /usr/share/nginx/html;
+      expires 30d;
+      add_header Cache-Control "public, max-age=2592000, immutable" always;
+      add_header Access-Control-Allow-Origin "*";
+      add_header Vary "Origin" always;
+  }
+
+  location = /addons/outlook/ {
+      return 404;
+  }
+
+  location ~ ^/addons/outlook(/.*)?$ {
+      alias /usr/share/nginx/html/addons/outlook$1;
+      error_page 404 =200 /index.html;
+      add_header Cache-Control "no-cache, no-store, must-revalidate";
+      add_header Pragma "no-cache" always;
+      add_header Expires 0 always;
+
+      set $ms_domains "https://*.live.com https://*.office.com https://*.microsoft.com https://*.office365.com https://*.sharepoint.com";
+
+      set $nonce $request_id;
+
+      set $csp "upgrade-insecure-requests; ";
+      set $csp "${csp}frame-ancestors ${ms_domains}; ";
+      set $csp "${csp}script-src 'nonce-${nonce}' 'strict-dynamic'; ";
+      set $csp "${csp}connect-src 'self' ${ms_domains}; ";
+      set $csp "${csp}frame-src 'none'; ";
+      set $csp "${csp}object-src 'none'; ";
+      set $csp "${csp}base-uri 'none'; ";
+
+      add_header Content-Security-Policy $csp;
+
+      sub_filter 'NONCE_PLACEHOLDER' $nonce;
+      sub_filter_once off;
+  }
+
+  # Serve static files with caching
+  location ~* ^/assets/.*\.(css|js|json|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
+      expires 30d;
+      add_header Cache-Control "public, max-age=2592000";
+  }
+
+  # Serve static files
+  location / {
+      try_files $uri $uri/ /index.html;
+      # Add no-cache headers
+      add_header Cache-Control "no-cache, no-store, must-revalidate";
+      add_header Pragma "no-cache";  # HTTP 1.0 header for backward compatibility
+      add_header Expires 0;
+  }
+
+  # Optionally, handle 404 errors by redirecting to index.html
+  error_page 404 =200 /index.html;
+}

docker/files/etc/nginx/conf.d/default.conf

@@ -4,10 +4,47 @@ server {
     server_name localhost;
     charset utf-8;
 
+    # Proxy auth for media
+    location /media/ {
+        # Auth request configuration
+        auth_request /media-auth;
+        auth_request_set $authHeader $upstream_http_authorization;
+        auth_request_set $authDate $upstream_http_x_amz_date;
+        auth_request_set $authContentSha256 $upstream_http_x_amz_content_sha256;
+
+        # Pass specific headers from the auth response
+        proxy_set_header Authorization $authHeader;
+        proxy_set_header X-Amz-Date $authDate;
+        proxy_set_header X-Amz-Content-SHA256 $authContentSha256;
+
+        # Get resource from Minio
+        proxy_pass http://minio:9000/meet-media-storage/;
+        proxy_set_header Host minio:9000;
+        # To use with ds_proxy
+        # proxy_pass http://ds-proxy:4444/upstream/meet-media-storage/;
+        # proxy_set_header Host ds-proxy:4444;
+        add_header Content-Disposition "attachment";
+    }
+
+    location /media-auth {
+        proxy_pass http://app-dev:8000/api/v1.0/files/media-auth/;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Original-URL $request_uri;
+        
+        # Prevent the body from being passed
+        proxy_pass_request_body off;
+        proxy_set_header Content-Length "";
+        proxy_set_header X-Original-Method $request_method;
+    }
+
     location / {
         proxy_pass http://keycloak:8080;
         proxy_set_header Host $host;
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-Forwarded-Port $server_port;
     }
 }

docs/examples/compose/keycloak/README.md

@@ -61,11 +61,10 @@ services:
 `docker compose up -d`
 ```
 
-Your keycloak instance is now available on https://doc.yourdomain.tld
+Your keycloak instance is now available on https://id.yourdomain.tld
 
 > [!CAUTION]
 > Version of the images are set to latest, you should pin it to the desired version to avoid unwanted upgrades when pulling latest image. You can find available versions on [Keycloak registry](https://quay.io/repository/keycloak/keycloak?tab=tags).
-```
 
 ## Creating an OIDC Client for Meet Application
 
@@ -76,7 +75,7 @@ Your keycloak instance is now available on https://doc.yourdomain.tld
 3. Enter the name of the realm  - `meet`.
 4. Click "Create".
 
-#### Step 2: Create a New Client
+### Step 2: Create a New Client
 
 1. Navigate to the "Clients" tab.
 2. Click on the "Create client" button.
@@ -86,7 +85,7 @@ Your keycloak instance is now available on https://doc.yourdomain.tld
 1. Set the "Web Origins" to the URL of your meet application - e.g. `https://meet.example.com`.
 1. Click "Save".
 
-#### Step 3: Get Client Credentials
+### Step 3: Get Client Credentials
 
 1. Go to the "Credentials" tab.
 2. Copy the client ID (`meet` in this example) and the client secret.

docs/examples/helm/meet.values.yaml

@@ -68,13 +68,13 @@ backend:
         python manage.py createsuperuser --email admin@example.com --password admin
     restartPolicy: Never
 
-  # Exra volume to manage our local custom CA and avoid to set ssl_verify: false
+  # Extra volume to manage our local custom CA and avoid to set ssl_verify: false
   extraVolumeMounts:
     - name: certs
-      mountPath: /usr/local/lib/python3.12/site-packages/certifi/cacert.pem
+      mountPath: /app/.venv/lib/python3.13/site-packages/certifi/cacert.pem
       subPath: cacert.pem
 
-  # Exra volume to manage our local custom CA and avoid to set ssl_verify: false
+  # Extra volume to manage our local custom CA and avoid to set ssl_verify: false
   extraVolumes:
     - name: certs
       configMap:

docs/features/recording.md

@@ -100,6 +100,13 @@ sequenceDiagram
 | **RECORDING_STORAGE_EVENT_TOKEN**       | Secret/File | `None`                                                                                                                                                             | Token used to authenticate storage webhook requests, if `RECORDING_ENABLE_STORAGE_EVENT_AUTH` is enabled.                                                                                                                                                                                          |
 | **RECORDING_EXPIRATION_DAYS**           | Integer     | `None`                                                                                                                                                             | Number of days before recordings expire. Should match bucket lifecycle policy. Set to `None` for no expiration.                                                                                                                                                                                    |
 | **RECORDING_MAX_DURATION**              | Integer     | `None`                                                                                                                                                             | Maximum duration of a recording in milliseconds. Must be synced with the LiveKit Egress configuration. Set to None for unlimited duration. When the maximum duration is reached, the recording is automatically stopped and saved, and the user is prompted in the frontend with an alert message. |
+| **RECORDING_ENCODING_ENABLED**          | Boolean     | `False`                                                                                                                                                            | When `False`, LiveKit Egress uses its built-in `H264_720P_30` preset. When `True`, the `RECORDING_ENCODING_*` values below are sent to LiveKit as advanced `EncodingOptions`. See [Tuning recording encoding](#tuning-recording-encoding).                                                          |
+| **RECORDING_ENCODING_WIDTH**            | Integer     | `1280`                                                                                                                                                             | Recording video width in pixels. Only applied when `RECORDING_ENCODING_ENABLED` is `True`.                                                                                                                                                                                                         |
+| **RECORDING_ENCODING_HEIGHT**           | Integer     | `720`                                                                                                                                                              | Recording video height in pixels. Only applied when `RECORDING_ENCODING_ENABLED` is `True`.                                                                                                                                                                                                        |
+| **RECORDING_ENCODING_FRAMERATE**        | Integer     | `30`                                                                                                                                                               | Recording video framerate (fps). Directly impacts egress worker CPU (roughly linear). Only applied when `RECORDING_ENCODING_ENABLED` is `True`.                                                                                                                                                    |
+| **RECORDING_ENCODING_VIDEO_BITRATE_KBPS** | Integer   | `3000`                                                                                                                                                             | H.264 MAIN video bitrate in kbps. Only applied when `RECORDING_ENCODING_ENABLED` is `True`.                                                                                                                                                                                                        |
+| **RECORDING_ENCODING_AUDIO_BITRATE_KBPS** | Integer   | `128`                                                                                                                                                              | AAC audio bitrate in kbps. Only applied when `RECORDING_ENCODING_ENABLED` is `True`.                                                                                                                                                                                                               |
+| **RECORDING_ENCODING_KEY_FRAME_INTERVAL_S** | Float   | `4.0`                                                                                                                                                              | Keyframe interval in seconds. Drives seek granularity in the recorded MP4 (a player can only seek to keyframe boundaries). Larger values give the encoder slightly more bits for non-keyframe content at a fixed bitrate. `4.0` is a standard VOD value. Only applied when `RECORDING_ENCODING_ENABLED` is `True`. |
 
 
 ### Manual Storage Webhook
@@ -141,3 +148,54 @@ Using default project meet
 
 This allows you to verify which recordings are in progress, troubleshoot egress issues, and confirm that recordings are being processed correctly.
 
+## Tuning recording encoding
+
+By default, LiveKit Egress records with the built-in `H264_720P_30` preset: 1280×720 at 30 fps, 3000 kbps H.264 MAIN video and 128 kbps AAC audio. For a one-hour meeting this produces a file of roughly **1.4 GB**, which is often heavier than necessary for talking-head content and screen sharing.
+
+The `RECORDING_ENCODING_*` settings let operators override this preset without modifying the source. Values are passed straight through LiveKit's `EncodingOptions.advanced` to the GStreamer pipeline (`x264enc` for video, `faac` for audio), so there are no hidden conversions — what you set is what the encoder receives.
+
+### How values map to GStreamer
+
+| Setting                               | GStreamer element | Property                           |
+| ------------------------------------- | ----------------- | ---------------------------------- |
+| `RECORDING_ENCODING_WIDTH/HEIGHT`     | capsfilter        | `video/x-raw,width=W,height=H`     |
+| `RECORDING_ENCODING_FRAMERATE`        | capsfilter        | `framerate=F/1`                    |
+| `RECORDING_ENCODING_VIDEO_BITRATE_KBPS` | `x264enc`       | `bitrate=kbps` (kilobits)          |
+| `RECORDING_ENCODING_KEY_FRAME_INTERVAL_S` | `x264enc`     | `key-int-max = interval × fps`     |
+| `RECORDING_ENCODING_AUDIO_BITRATE_KBPS` | `faac`          | `bitrate = kbps × 1000` (bits)     |
+
+The H.264 profile is fixed to MAIN and the x264 `speed-preset` to `veryfast` by LiveKit (real-time constraint) — lowering the framerate is therefore the main lever to save CPU, while lowering the bitrate is the main lever to shrink the output file.
+
+### Reference profiles
+
+Rough 30-minute file-size estimates assume video + audio bitrate multiplied by duration. Actual sizes vary with content (static talking heads compress better than heavy screen motion). Egress CPU figures are indicative, measured on a single Ryzen laptop core saturated by the default preset (= 100 %); scaling is roughly linear with `framerate × bitrate` but the absolute numbers depend on the host hardware.
+
+| Profile                | Resolution | FPS | Video (kbps) | Audio (kbps) | Keyframe (s) | ~ size / 30 min | Egress CPU (vs. default) | Suitable for                                        |
+| ---------------------- | ---------- | --- | ------------ | ------------ | ------------ | --------------- | ------------------------ | --------------------------------------------------- |
+| Default (preset)       | 1280×720   | 30  | 3000         | 128          | 4            | **~690 MB**     | 100 %                    | Unchanged LiveKit behaviour                         |
+| Balanced               | 1280×720   | 20  | 1000         | 96           | 4            | ~240 MB         | ~67 %                    | Mixed content, moderate motion                      |
+| **Low CPU / small file** | 1280×720 | 15  | 600          | 64           | 4            | **~150 MB**     | ~50 %                    | Talking-head dominant meetings + occasional slides ★ |
+| Slide-heavy            | 1280×720   | 15  | 900          | 64           | 4            | ~210 MB         | ~55 %                    | Frequent dense screen sharing (decks, IDE, docs)    |
+| Minimum CPU            | 960×540    | 15  | 500          | 64           | 4            | ~125 MB         | ~30 %                    | Voice-first meetings, readable text not required    |
+| Audio-heavy fallback   | 1280×720   | 10  | 400          | 96           | 4            | ~110 MB         | ~35 %                    | Long webinars, low motion                           |
+
+★ Recommended starting point for typical LaSuite Meet usage.
+
+Environment variables for the **Low CPU / small file** profile:
+
+```bash
+RECORDING_ENCODING_ENABLED=True
+RECORDING_ENCODING_WIDTH=1280
+RECORDING_ENCODING_HEIGHT=720
+RECORDING_ENCODING_FRAMERATE=15
+RECORDING_ENCODING_VIDEO_BITRATE_KBPS=600
+RECORDING_ENCODING_AUDIO_BITRATE_KBPS=64
+RECORDING_ENCODING_KEY_FRAME_INTERVAL_S=4.0
+```
+
+### Caveats
+
+- **Screen-share readability — think bits/frame, not bitrate**: at 720p, text legibility starts to break down below ~40 kbits/frame (= `bitrate ÷ framerate`). The recommended preset (600 kbps × 15 fps) sits at exactly that threshold, comfortable for talking heads with occasional slide sharing. The same 600 kbps at 30 fps would only deliver 20 kbits/frame and visibly blur dense slides — which is why **lowering framerate is a more screen-share-friendly lever than lowering bitrate**. For deck-heavy or IDE-share meetings, prefer the **Slide-heavy** profile (900 kbps × 15 fps ≈ 60 kbits/frame).
+- **Motion handling**: the `veryfast` x264 preset is set by LiveKit and cannot be overridden here. Low-bitrate settings will therefore show more artefacts on fast motion than an offline re-encode with a slower preset would. This is the other reason FPS reduction is the safer tuning lever for meeting recordings.
+- **Audio**: AAC at 64 kbps stereo is transparent for voice but starts to compress music noticeably. Keep 128 kbps if you expect music playback in meetings.
+- **Codec choice**: H.264 MAIN is hardcoded on purpose. Switching to HEVC or VP9 would increase egress CPU cost 2×–5×, defeating the goal of this tuning.

docs/installation/compose.md

@@ -87,12 +87,12 @@ If you are using an external service, you need to set `REDIS_URL` environment va
 
 Generate a secure key for `LIVEKIT_API_SECRET` in `env.d/common`.
 
-We provide a minimal recommanded config for production environment in `livekit-server.yaml`. Set the previously generated API secret key in the config file.
+We provide a minimal recommended config for production environment in `livekit-server.yaml`. Set the previously generated API secret key in the config file.
 
 To view other customization options, see [config-sample.yaml](https://github.com/livekit/livekit/blob/master/config-sample.yaml)
 
 > [!NOTE]
-> In this example, we configured multiplexing on a single UDP port. For better performances, you can configure a range of UDP ports. 
+> In this example, we configured multiplexing on a single UDP port. For better performance, you can configure a range of UDP ports. 
 
 ### Meet
 

docs/installation/kubernetes.md

@@ -122,11 +122,11 @@ If you haven't run the script **bin/start-kind.sh**, you'll need to manually cre
 $ kubectl create namespace meet
 ```
 
-If you have already run the script, you can skip this step and proceed to the next instruction. NOTE: Before you proceed, and is using the kind method, make sure you download this repo examples/ directory and its contents to the location where you will be executing the helm command. Helm will look for "examples/<name>values.yaml" from based on the path it is being executed.
+If you have already run the script, you can skip this step and proceed to the next instruction. NOTE: Before you proceed, and is using the kind method, make sure you download this repo examples/helm directory and its contents to the location where you will be executing the helm command. Helm will look for "examples/helm/<name>values.yaml" from based on the path it is being executed.
 
 ```
 $ kubectl config set-context --current --namespace=meet
-$ helm install keycloak oci://registry-1.docker.io/bitnamicharts/keycloak -f examples/keycloak.values.yaml
+$ helm install keycloak oci://registry-1.docker.io/bitnamicharts/keycloak -f examples/helm/keycloak.values.yaml
 $ #wait until
 $ kubectl get po
 NAME                    READY   STATUS    RESTARTS   AGE
@@ -150,7 +150,7 @@ OIDC_RP_SIGN_ALGO: RS256
 OIDC_RP_SCOPES: "openid email"
 ```
 
-You can find these values in **examples/keycloak.values.yaml**
+You can find these values in **examples/helm/keycloak.values.yaml**
 
 ### Find livekit server connexion values
 
@@ -159,7 +159,7 @@ LaSuite Meet use livekit for streaming part so if you have a livekit provider, o
 Livekit need a redis (and meet too) so we will start by deploying a redis :
 
 ```
-$ helm install redis oci://registry-1.docker.io/bitnamicharts/redis -f examples/redis.values.yaml
+$ helm install redis oci://registry-1.docker.io/bitnamicharts/redis -f examples/helm/redis.values.yaml
 $ kubectl get po
 NAME                    READY   STATUS    RESTARTS   AGE
 keycloak-0              1/1     Running   0          26m
@@ -172,7 +172,7 @@ When the redis is ready we can deploy livekit-server.
 ```
 $ helm repo add livekit https://helm.livekit.io
 $ helm repo update
-$ helm install livekit livekit/livekit-server -f examples/livekit.values.yaml
+$ helm install livekit livekit/livekit-server -f examples/helm/livekit.values.yaml
 $ kubectl get po
 NAME                                      READY   STATUS    RESTARTS   AGE
 keycloak-0                                1/1     Running   0          30m
@@ -199,7 +199,7 @@ CELERY_RESULT_BACKEND: redis://default:pass@redis-master:6379/1
 LaSuite Meet uses a postgresql db as backend so if you have a provider, obtain the necessary information to use it. If you do not have, you can install a postgresql testing environment as follows:
 
 ```
-$ helm install postgresql oci://registry-1.docker.io/bitnamicharts/postgresql -f examples/postgresql.values.yaml
+$ helm install postgresql oci://registry-1.docker.io/bitnamicharts/postgresql -f examples/helm/postgresql.values.yaml
 $ kubectl get po
 NAME                                      READY   STATUS    RESTARTS   AGE
 keycloak-0                                1/1     Running   0          45m
@@ -226,7 +226,7 @@ Now you are ready to deploy LaSuite Meet without AI. AI required more dependenci
 ```
 $ helm repo add meet https://suitenumerique.github.io/meet/
 $ helm repo update
-$ helm install meet meet/meet -f examples/meet.values.yaml
+$ helm install meet meet/meet -f examples/helm/meet.values.yaml
 ```
 
 ## Test your deployment

docs/openapi.yaml

@@ -185,11 +185,13 @@ paths:
                           pin_code: "123456"
                           phone_number: "+1-555-0100"
                           default_country: "US"
+                        configuration: {}
         '401':
           $ref: '#/components/responses/UnauthorizedError'
         '403':
           $ref: '#/components/responses/ForbiddenError'
 
+  /rooms/:
     post:
       tags:
         - Rooms
@@ -197,10 +199,6 @@ paths:
       description: |
         Creates a new room with secure defaults for external API usage.
         
-        **Restrictions:**
-        - Rooms are always created with `trusted` access (no public rooms via API)
-        - Room access_level can be updated from the webapp interface.
-        
         **Defaults:**
         - Delegated user is set as owner
         - Room slug auto-generated for uniqueness
@@ -217,8 +215,17 @@ paths:
               $ref: '#/components/schemas/RoomCreate'
             examples:
               emptyBody:
-                summary: No parameters (default)
-                value: {}
+                summary: No parameters (use all defaults)
+                value: { }
+              withAccessLevel:
+                summary: Specify access level
+                value:
+                  access_level: "trusted"
+              withConfiguration:
+                summary: Provide room configuration
+                value:
+                  configuration:
+                    everyone_can_mute: true
       responses:
         '201':
           description: Room created successfully
@@ -268,6 +275,7 @@ paths:
                       pin_code: "123456"
                       phone_number: "+1-555-0100"
                       default_country: "US"
+                    configuration: {}
         '401':
           $ref: '#/components/responses/UnauthorizedError'
         '403':
@@ -343,8 +351,56 @@ components:
 
     RoomCreate:
       type: object
-      description: Empty object - all room properties are auto-generated
-      properties: {}
+      description: |
+        Optional fields for room creation. All fields have secure defaults if omitted.
+      properties:
+        access_level:
+          $ref: '#/components/schemas/RoomAccessLevel'
+        configuration:
+          $ref: '#/components/schemas/RoomConfiguration'
+
+    RoomConfiguration:
+      type: object
+      description: |
+        Optional room behaviour settings. Unknown fields are rejected.
+        All fields are optional and default to `null` (server-side defaults apply).
+      properties:
+        can_publish_sources:
+          type: array
+          nullable: true
+          description: |
+            Restricts which media tracks participants are allowed to publish.
+            If `null`, all sources are permitted.
+          items:
+            type: string
+            enum:
+              - camera
+              - microphone
+              - screen_share
+              - screen_share_audio
+          example: [ "camera", "microphone" ]
+        everyone_can_mute:
+          type: boolean
+          nullable: true
+          description: |
+            Whether any participant can mute others, or only the room owner/moderator.
+            If `null`, the server default applies.
+          example: true
+      additionalProperties: false
+
+    RoomAccessLevel:
+      type: string
+      enum:
+        - public
+        - trusted
+        - restricted
+      description: |
+        Controls who can join the room without going through the lobby.
+
+        - `public`: Anyone with the room link can join directly, no authentication required.
+        - `trusted`: Authenticated users join directly. Unauthenticated users wait in the lobby for approval.
+        - `restricted`: Only participants explicitly trusted by the owner bypass the lobby. Everyone else waits for approval regardless of authentication.
+      example: "trusted"
 
     Room:
       type: object
@@ -361,10 +417,7 @@ components:
           description: URL-friendly room identifier (auto-generated)
           example: "aze-eere-zer"
         access_level:
-          type: string
-          readOnly: true
-          description: Room access level (always 'trusted' for API-created rooms)
-          example: "trusted"
+          $ref: '#/components/schemas/RoomAccessLevel'
         url:
           type: string
           format: uri
@@ -392,6 +445,8 @@ components:
               type: string
               description: Default country code
               example: "US"
+        configuration:
+          $ref: '#/components/schemas/RoomConfiguration'
 
     OAuthError:
       type: object

docs/resource_server.yaml

@@ -48,7 +48,7 @@ paths:
       summary: List rooms
       description: |
         Returns a list of rooms accessible to the authenticated user.
-        Only rooms where the delegated user has access will be returned.
+        Only rooms where the user has access will be returned.
       operationId: listRooms
       security:
         - BearerAuth: [rooms:list]
@@ -108,24 +108,22 @@ paths:
                           pin_code: "123456"
                           phone_number: "+1-555-0100"
                           default_country: "US"
+                        configuration: { }
         '401':
           $ref: '#/components/responses/UnauthorizedError'
         '403':
           $ref: '#/components/responses/ForbiddenError'
 
+  /rooms/:
     post:
       tags:
         - Rooms
       summary: Create a room
       description: |
         Creates a new room with secure defaults for external API usage.
-        
-        **Restrictions:**
-        - Rooms are always created with `trusted` access (no public rooms via API)
-        - Room access_level can be updated from the webapp interface.
-        
+
         **Defaults:**
-        - Delegated user is set as owner
+        - user is set as owner
         - Room slug auto-generated for uniqueness
         - Telephony PIN auto-generated when enabled
         - Creation tracked with application client_id for auditing
@@ -140,8 +138,17 @@ paths:
               $ref: '#/components/schemas/RoomCreate'
             examples:
               emptyBody:
-                summary: No parameters (default)
-                value: {}
+                summary: No parameters (use all defaults)
+                value: { }
+              withAccessLevel:
+                summary: Specify access level
+                value:
+                  access_level: "trusted"
+              withConfiguration:
+                summary: Provide room configuration
+                value:
+                  configuration:
+                    everyone_can_mute: true
       responses:
         '201':
           description: Room created successfully
@@ -191,6 +198,7 @@ paths:
                       pin_code: "123456"
                       phone_number: "+1-555-0100"
                       default_country: "US"
+                    configuration: { }
         '401':
           $ref: '#/components/responses/UnauthorizedError'
         '403':
@@ -209,65 +217,58 @@ components:
         Include in requests as: `Authorization: Bearer <token>`
 
   schemas:
-    TokenRequest:
-      type: object
-      required:
-        - client_id
-        - client_secret
-        - grant_type
-        - scope
-      properties:
-        client_id:
-          type: string
-          description: Application client identifier
-          example: "550e8400-e29b-41d4-a716-446655440000"
-        client_secret:
-          type: string
-          format: password
-          writeOnly: true
-          description: Application secret key
-          example: "1234567890abcdefghijklmnopqrstuvwxyz"
-        grant_type:
-          type: string
-          enum:
-            - client_credentials
-          description: OAuth2 grant type (must be 'client_credentials')
-          example: "client_credentials"
-        scope:
-          type: string
-          format: email
-          description: |
-            Email address of the user to delegate.
-            The application will act on behalf of this user.
-            Note: This parameter is named 'scope' to align with OAuth2 conventions,
-            but accepts an email address to identify the user. This design allows
-            for future extensibility.
-          example: "user@example.com"
-
-    TokenResponse:
-      type: object
-      properties:
-        access_token:
-          type: string
-          description: JWT access token
-          example: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJtZWV0LWFwaSIsImF1ZCI6Im1lZXQtY2xpZW50cyIsImlhdCI6MTcwOTQ5MTIwMCwiZXhwIjoxNzA5NDk0ODAwLCJjbGllbnRfaWQiOiI1NTBlODQwMC1lMjliLTQxZDQtYTcxNi00NDY2NTU0NDAwMDAiLCJzY29wZSI6InJvb21zOmxpc3Qgcm9vbXM6cmV0cmlldmUgcm9vbXM6Y3JlYXRlIiwidXNlcl9pZCI6IjdiOGQ5YzQwLTNhMmItNGVkZi04NzFjLTJmM2Q0ZTVmNmE3YiIsImRlbGVnYXRlZCI6dHJ1ZX0.signature"
-        token_type:
-          type: string
-          description: Token type (always 'Bearer')
-          example: "Bearer"
-        expires_in:
-          type: integer
-          description: Token lifetime in seconds
-          example: 3600
-        scope:
-          type: string
-          description: Space-separated list of granted permission scopes
-          example: "rooms:list rooms:retrieve rooms:create"
-
     RoomCreate:
       type: object
-      description: Empty object - all room properties are auto-generated
-      properties: {}
+      description: |
+        Optional fields for room creation. All fields have secure defaults if omitted.
+      properties:
+        access_level:
+          $ref: '#/components/schemas/RoomAccessLevel'
+        configuration:
+          $ref: '#/components/schemas/RoomConfiguration'
+
+    RoomConfiguration:
+      type: object
+      description: |
+        Optional room behaviour settings. Unknown fields are rejected.
+        All fields are optional and default to `null` (server-side defaults apply).
+      properties:
+        can_publish_sources:
+          type: array
+          nullable: true
+          description: |
+            Restricts which media tracks participants are allowed to publish.
+            If `null`, all sources are permitted.
+          items:
+            type: string
+            enum:
+              - camera
+              - microphone
+              - screen_share
+              - screen_share_audio
+          example: [ "camera", "microphone" ]
+        everyone_can_mute:
+          type: boolean
+          nullable: true
+          description: |
+            Whether any participant can mute others, or only the room owner/moderator.
+            If `null`, the server default applies.
+          example: true
+      additionalProperties: false
+
+    RoomAccessLevel:
+      type: string
+      enum:
+        - public
+        - trusted
+        - restricted
+      description: |
+        Controls who can join the room without going through the lobby.
+
+        - `public`: Anyone with the room link can join directly, no authentication required.
+        - `trusted`: Authenticated users join directly. Unauthenticated users wait in the lobby for approval.
+        - `restricted`: Only participants explicitly trusted by the owner bypass the lobby. Everyone else waits for approval regardless of authentication.
+      example: "trusted"
 
     Room:
       type: object
@@ -284,10 +285,7 @@ components:
           description: URL-friendly room identifier (auto-generated)
           example: "aze-eere-zer"
         access_level:
-          type: string
-          readOnly: true
-          description: Room access level (always 'trusted' for API-created rooms)
-          example: "trusted"
+          $ref: '#/components/schemas/RoomAccessLevel'
         url:
           type: string
           format: uri
@@ -315,6 +313,8 @@ components:
               type: string
               description: Default country code
               example: "US"
+        configuration:
+          $ref: '#/components/schemas/RoomConfiguration'
 
     OAuthError:
       type: object

env.d/development/common.dist

@@ -23,9 +23,12 @@ MEET_BASE_URL="http://localhost:8072"
 
 # Media
 STORAGES_STATICFILES_BACKEND=django.contrib.staticfiles.storage.StaticFilesStorage
+AWS_S3_DOMAIN_REPLACE=http://localhost:9000
 AWS_S3_ENDPOINT_URL=http://minio:9000
 AWS_S3_ACCESS_KEY_ID=meet
 AWS_S3_SECRET_ACCESS_KEY=password
+MEDIA_BASE_URL=http://localhost:3000
+FILE_UPLOAD_ENABLED=True
 
 # OIDC
 OIDC_OP_JWKS_ENDPOINT=http://nginx:8083/realms/meet/protocol/openid-connect/certs
@@ -65,9 +68,24 @@ SUMMARY_SERVICE_ENDPOINT=http://app-summary-dev:8000/api/v1/tasks/
 SUMMARY_SERVICE_API_TOKEN=password
 RECORDING_DOWNLOAD_BASE_URL=http://localhost:3000/recording
 
+# Recording encoding (LiveKit Egress advanced options).
+# When RECORDING_ENCODING_ENABLED is False (default), LiveKit uses its built-in
+# H264_720P_30 preset (1280x720, 30fps, 3000 kbps). Enable and tune to reduce
+# file size and CPU load on the egress worker.
+# RECORDING_ENCODING_ENABLED=False
+# RECORDING_ENCODING_WIDTH=1280
+# RECORDING_ENCODING_HEIGHT=720
+# RECORDING_ENCODING_FRAMERATE=30
+# RECORDING_ENCODING_VIDEO_BITRATE_KBPS=3000
+# RECORDING_ENCODING_AUDIO_BITRATE_KBPS=128
+# RECORDING_ENCODING_KEY_FRAME_INTERVAL_S=4.0
+
 # Telephony
 ROOM_TELEPHONY_ENABLED=True
 
+# Metadata
+METADATA_COLLECTOR_ENABLED=True
+
 FRONTEND_USE_FRENCH_GOV_FOOTER=False
 FRONTEND_USE_PROCONNECT_BUTTON=False
 

env.d/development/kube-secret.dist

@@ -0,0 +1,4 @@
+WHISPERX_BASE_URL=https://configure-your-url.com
+WHISPERX_API_KEY=<key>
+LLM_BASE_URL=https://configure-your-url.com
+LLM_API_KEY=<key>

env.d/development/multi_user_transcriber.dist

@@ -0,0 +1,9 @@
+LIVEKIT_URL=ws://livekit:7880
+LIVEKIT_API_KEY=devkey
+LIVEKIT_API_SECRET=secret
+
+STT_PROVIDER=kyutai
+ENABLE_SILERO_VAD=False
+
+KYUTAI_STT_BASE_URL=
+KYUTAI_API_KEY=

renovate.json

@@ -36,6 +36,12 @@
         "matchPackageNames": ["django"],
         "allowedVersions": "<6.0.0"
     },
+    {
+        "groupName": "allowed brevo versions",
+        "matchManagers": ["pep621"],
+        "matchPackageNames": ["brevo-python"],
+        "allowedVersions": "<3.0.0"
+    },
     {
       "enabled": false,
       "groupName": "ignored js dependencies",

src/addons/outlook/.eslintrc.json

@@ -0,0 +1,8 @@
+{
+  "plugins": [
+    "office-addins"
+  ],
+  "extends": [
+    "plugin:office-addins/recommended"
+  ]
+}

src/addons/outlook/babel.config.json

@@ -0,0 +1,12 @@
+{
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "targets": {
+          "esmodules": false
+        }
+      }
+    ],
+  ]
+}

src/addons/outlook/manifest.xml

@@ -0,0 +1,190 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<OfficeApp xmlns="http://schemas.microsoft.com/office/appforoffice/1.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:bt="http://schemas.microsoft.com/office/officeappbasictypes/1.0" xmlns:mailappor="http://schemas.microsoft.com/office/mailappversionoverrides/1.0" xsi:type="MailApp">
+  <Id>a025f0f6-757a-4790-97f3-99c66c4a5795</Id>
+  <Version>0.0.1.0</Version>
+  <ProviderName>__APP_NAME__</ProviderName>
+  <DefaultLocale>fr-FR</DefaultLocale>
+  <DisplayName DefaultValue="__APP_NAME__"/>
+  <Description DefaultValue="Ajoutez facilement un lien de réunion __APP_NAME__ à vos emails et événements Outlook."/>
+  <IconUrl DefaultValue="https://localhost:3000/assets/icon-64.png"/>
+  <HighResolutionIconUrl DefaultValue="https://localhost:3000/assets/icon-128.png"/>
+  <SupportUrl DefaultValue="https://lasuite.crisp.help/fr/category/visio-15sakkg/"/>
+  <AppDomains>
+    <AppDomain>https://localhost:3000/</AppDomain>
+  </AppDomains>
+  <Hosts>
+    <Host Name="Mailbox"/>
+  </Hosts>
+  <Requirements>
+    <Sets>
+      <Set Name="Mailbox" MinVersion="1.1"/>
+    </Sets>
+  </Requirements>
+  <FormSettings>
+    <Form xsi:type="ItemRead">
+      <DesktopSettings>
+        <SourceLocation DefaultValue="https://localhost:3000/taskpane.html"/>
+        <RequestedHeight>250</RequestedHeight>
+      </DesktopSettings>
+    </Form>
+    <Form xsi:type="ItemEdit">
+      <DesktopSettings>
+        <SourceLocation DefaultValue="https://localhost:3000/taskpane.html"/>
+      </DesktopSettings>
+    </Form>
+  </FormSettings>
+  <Permissions>ReadWriteItem</Permissions>
+  <Rule xsi:type="RuleCollection" Mode="Or">
+    <Rule xsi:type="ItemIs" ItemType="Message" FormType="Read"/>
+    <Rule xsi:type="ItemIs" ItemType="Message" FormType="Edit"/>
+    <Rule xsi:type="ItemIs" ItemType="Appointment" FormType="Edit"/>
+  </Rule>
+  <DisableEntityHighlighting>false</DisableEntityHighlighting>
+  <VersionOverrides xmlns="http://schemas.microsoft.com/office/mailappversionoverrides" xsi:type="VersionOverridesV1_0">
+    <Requirements>
+      <bt:Sets DefaultMinVersion="1.3">
+        <bt:Set Name="Mailbox"/>
+      </bt:Sets>
+    </Requirements>
+    <Hosts>
+      <Host xsi:type="MailHost">
+        <DesktopFormFactor>
+          <FunctionFile resid="Commands.Url"/>
+
+          <!-- ─── Mail: Read ─────────────────────────────────────────── -->
+          <ExtensionPoint xsi:type="MessageReadCommandSurface">
+            <OfficeTab id="TabDefault">
+              <Group id="msgReadGroup">
+                <Label resid="GroupLabel"/>
+                <Control xsi:type="Button" id="msgReadOpenPaneButton">
+                  <Label resid="TaskpaneButton.Label"/>
+                  <Supertip>
+                    <Title resid="TaskpaneButton.Label"/>
+                    <Description resid="TaskpaneButton.Tooltip"/>
+                  </Supertip>
+                  <Icon>
+                    <bt:Image size="16" resid="Icon.16x16"/>
+                    <bt:Image size="32" resid="Icon.32x32"/>
+                    <bt:Image size="80" resid="Icon.80x80"/>
+                  </Icon>
+                  <Action xsi:type="ShowTaskpane">
+                    <SourceLocation resid="Taskpane.Url"/>
+                  </Action>
+                </Control>
+              </Group>
+            </OfficeTab>
+          </ExtensionPoint>
+
+          <!-- ─── Mail: Compose ─────────────────────────────────────── -->
+          <ExtensionPoint xsi:type="MessageComposeCommandSurface">
+            <OfficeTab id="TabDefault">
+              <Group id="msgComposeGroup">
+                <Label resid="GroupLabel"/>
+                <Control xsi:type="Button" id="msgComposeGenerateLinkButton">
+                  <Label resid="GenerateLink.Label"/>
+                  <Supertip>
+                    <Title resid="GenerateLink.Label"/>
+                    <Description resid="GenerateLink.Tooltip"/>
+                  </Supertip>
+                  <Icon>
+                    <bt:Image size="16" resid="Add.16x16"/>
+                    <bt:Image size="32" resid="Add.32x32"/>
+                    <bt:Image size="80" resid="Add.80x80"/>
+                  </Icon>
+                  <Action xsi:type="ExecuteFunction">
+                    <FunctionName>generateMeetingLinkFromMail</FunctionName>
+                  </Action>
+                </Control>
+                <Control xsi:type="Button" id="msgComposeOpenPaneButton">
+                  <Label resid="TaskpaneButton.Label"/>
+                  <Supertip>
+                    <Title resid="TaskpaneButton.Label"/>
+                    <Description resid="TaskpaneButton.Tooltip"/>
+                  </Supertip>
+                  <Icon>
+                    <bt:Image size="16" resid="Settings.16x16"/>
+                    <bt:Image size="32" resid="Settings.32x32"/>
+                    <bt:Image size="80" resid="Settings.80x80"/>
+                  </Icon>
+                  <Action xsi:type="ShowTaskpane">
+                    <SourceLocation resid="Taskpane.Url"/>
+                  </Action>
+                </Control>
+              </Group>
+            </OfficeTab>
+          </ExtensionPoint>
+
+          <!-- ─── Calendar: Compose (New/Edit appointment) ──────────── -->
+          <ExtensionPoint xsi:type="AppointmentOrganizerCommandSurface">
+            <OfficeTab id="TabDefault">
+              <Group id="apptComposeGroup">
+                <Label resid="GroupLabel"/>
+                <Control xsi:type="Button" id="apptGenerateLinkButton">
+                  <Label resid="GenerateLink.Label"/>
+                  <Supertip>
+                    <Title resid="GenerateLink.Label"/>
+                    <Description resid="GenerateLink.Tooltip"/>
+                  </Supertip>
+                  <Icon>
+                    <bt:Image size="16" resid="Add.16x16"/>
+                    <bt:Image size="32" resid="Add.32x32"/>
+                    <bt:Image size="80" resid="Add.80x80"/>
+                  </Icon>
+                  <Action xsi:type="ExecuteFunction">
+                    <FunctionName>generateMeetingLinkFromCalendar</FunctionName>
+                  </Action>
+                </Control>
+
+                <Control xsi:type="Button" id="apptOpenSettingsButton">
+                  <Label resid="OpenSettings.Label"/>
+                  <Supertip>
+                    <Title resid="OpenSettings.Label"/>
+                    <Description resid="OpenSettings.Tooltip"/>
+                  </Supertip>
+                  <Icon>
+                    <bt:Image size="16" resid="Settings.16x16"/>
+                    <bt:Image size="32" resid="Settings.32x32"/>
+                    <bt:Image size="80" resid="Settings.80x80"/>
+                  </Icon>
+                  <Action xsi:type="ShowTaskpane">
+                    <SourceLocation resid="Taskpane.Url"/>
+                  </Action>
+                </Control>
+
+              </Group>
+            </OfficeTab>
+          </ExtensionPoint>
+
+        </DesktopFormFactor>
+      </Host>
+    </Hosts>
+    <Resources>
+      <bt:Images>
+        <bt:Image id="Settings.16x16" DefaultValue="https://localhost:3000/assets/settings-16.png"/>
+        <bt:Image id="Settings.32x32" DefaultValue="https://localhost:3000/assets/settings-32.png"/>
+        <bt:Image id="Settings.80x80" DefaultValue="https://localhost:3000/assets/settings-80.png"/>
+        <bt:Image id="Add.16x16" DefaultValue="https://localhost:3000/assets/add-16.png"/>
+        <bt:Image id="Add.32x32" DefaultValue="https://localhost:3000/assets/add-32.png"/>
+        <bt:Image id="Add.80x80" DefaultValue="https://localhost:3000/assets/add-80.png"/>
+        <bt:Image id="Icon.16x16" DefaultValue="https://localhost:3000/assets/icon-16.png"/>
+        <bt:Image id="Icon.32x32" DefaultValue="https://localhost:3000/assets/icon-32.png"/>
+        <bt:Image id="Icon.80x80" DefaultValue="https://localhost:3000/assets/icon-80.png"/>
+      </bt:Images>
+      <bt:Urls>
+        <bt:Url id="Commands.Url" DefaultValue="https://localhost:3000/commands.html"/>
+        <bt:Url id="Taskpane.Url" DefaultValue="https://localhost:3000/taskpane.html"/>
+      </bt:Urls>
+      <bt:ShortStrings>
+        <bt:String id="GroupLabel" DefaultValue="__APP_NAME__"/>
+        <bt:String id="TaskpaneButton.Label" DefaultValue="Ouvrir les paramètres"/>
+        <bt:String id="GenerateLink.Label" DefaultValue="Ajouter un lien __APP_NAME__"/>
+        <bt:String id="OpenSettings.Label" DefaultValue="Paramètres"/>
+      </bt:ShortStrings>
+      <bt:LongStrings>
+        <bt:String id="TaskpaneButton.Tooltip" DefaultValue="Ouvre les paramètres de connexion __APP_NAME__."/>
+        <bt:String id="GenerateLink.Tooltip" DefaultValue="Génère un lien de réunion __APP_NAME__ et l'insère dans l'événement."/>
+        <bt:String id="OpenSettings.Tooltip" DefaultValue="Ouvre les paramètres de connexion __APP_NAME__."/>
+      </bt:LongStrings>
+    </Resources>
+  </VersionOverrides>
+</OfficeApp>

src/addons/outlook/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "office-addin-taskpane-js",
+  "version": "0.0.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/suitenumerique/meet.git"
+  },
+  "license": "MIT",
+  "config": {
+    "app_to_debug": "outlook",
+    "app_type_to_debug": "desktop",
+    "dev_server_port": 3000
+  },
+  "scripts": {
+    "build": "webpack --mode production",
+    "build:dev": "webpack --mode development",
+    "dev-server": "webpack serve --mode development",
+    "lint": "office-addin-lint check",
+    "lint:fix": "office-addin-lint fix",
+    "prettier": "office-addin-lint prettier",
+    "signin": "office-addin-dev-settings m365-account login",
+    "signout": "office-addin-dev-settings m365-account logout",
+    "start": "office-addin-debugging start manifest.xml",
+    "stop": "office-addin-debugging stop manifest.xml",
+    "validate": "office-addin-manifest validate manifest.xml",
+    "watch": "webpack --mode development --watch"
+  },
+  "dependencies": {
+    "core-js": "^3.49.0",
+    "regenerator-runtime": "^0.14.1"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.24.0",
+    "@babel/preset-env": "^7.25.4",
+    "@types/office-js": "^1.0.377",
+    "@types/office-runtime": "^1.0.35",
+    "acorn": "^8.11.3",
+    "babel-loader": "^9.1.3",
+    "copy-webpack-plugin": "^14.0.0",
+    "eslint-plugin-office-addins": "^4.0.3",
+    "file-loader": "^6.2.0",
+    "html-loader": "^5.0.0",
+    "html-webpack-inject-attributes-plugin": "^1.0.6",
+    "html-webpack-plugin": "^5.6.0",
+    "office-addin-cli": "^2.0.3",
+    "office-addin-debugging": "^6.0.3",
+    "office-addin-dev-certs": "^2.0.3",
+    "office-addin-lint": "^3.0.3",
+    "office-addin-manifest": "^2.0.3",
+    "office-addin-prettier-config": "^2.0.1",
+    "os-browserify": "^0.3.0",
+    "process": "^0.11.10",
+    "source-map-loader": "^5.0.0",
+    "webpack": "^5.95.0",
+    "webpack-cli": "^5.1.4",
+    "webpack-dev-server": "5.2.4"
+  },
+  "prettier": "office-addin-prettier-config",
+  "browserslist": [
+    "last 2 versions",
+    "ie 11"
+  ]
+}

src/addons/outlook/src/commands/commands.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8" />
+    <title data-app-name></title>
+    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+    <script nonce="NONCE_PLACEHOLDER" src="https://appsforoffice.microsoft.com/lib/1/hosted/office.js"></script>
+    <script nonce="NONCE_PLACEHOLDER" src="/addons/outlook/config.js"></script>
+</head>
+<body></body>
+</html>

src/addons/outlook/src/commands/commands.js

@@ -0,0 +1,117 @@
+/* global Office */
+const { createRoom, initSession } = require("../common/api");
+const { startPolling } = require("../common/polling");
+const { saveSession, loadSession } = require("../common/session");
+const { openTransitDialog } = require("../common/transitDialog");
+const { buildMeetingMessage } = require("../common/messageBuilder");
+const { applyAppName } = require("../common/helpers");
+
+Office.onReady(function (info) {
+  if (info.host === Office.HostType.Outlook) {
+    applyAppName();
+  }
+});
+
+function notify(message) {
+  Office.context.mailbox.item.notificationMessages.replaceAsync("meetNotif", {
+    type: Office.MailboxEnums.ItemNotificationMessageType.InformationalMessage,
+    message,
+    persistent: false,
+    icon: "Icon.16x16",
+  });
+}
+
+function insertMeetingLink(event, session) {
+  createRoom(session)
+    .then((data) => {
+      const { url, message } = buildMeetingMessage(data);
+      const item = Office.context.mailbox.item;
+
+      return new Promise((resolve, reject) => {
+        item.body.getAsync(Office.CoercionType.Html, (getResult) => {
+          if (getResult.status !== Office.AsyncResultStatus.Succeeded) {
+            notify(`Erreur de lecture : ${getResult.error.message}`);
+            resolve();
+            return;
+          }
+
+          const newBody = getResult.value + message;
+          item.body.setAsync(newBody, { coercionType: Office.CoercionType.Html }, (setResult) => {
+            if (setResult.status !== Office.AsyncResultStatus.Succeeded) {
+              notify(`Erreur d'insertion : ${setResult.error.message}`);
+              resolve();
+              return;
+            }
+
+            if (item.itemType !== Office.MailboxEnums.ItemType.Appointment) {
+              notify("Lien de réunion inséré !");
+              resolve();
+              return;
+            }
+
+            item.location.setAsync(url, (locationResult) => {
+              if (locationResult.status !== Office.AsyncResultStatus.Succeeded) {
+                notify(`Erreur de localisation : ${locationResult.error.message}`);
+              } else {
+                notify("Lien de réunion inséré !");
+              }
+              resolve();
+            });
+          });
+        });
+      });
+    })
+    .catch((err) => {
+      notify(`Erreur : ${err.message}`);
+    })
+    .finally(() => {
+      event.completed();
+    });
+}
+
+function connect(event) {
+  initSession()
+    .then((data) => {
+      const stopPolling = startPolling(data.csrf_token, {
+        onSuccess: (sessionData) => {
+          saveSession(sessionData).then(() => {
+            insertMeetingLink(event, sessionData);
+          });
+        },
+        onTimeout: () => {
+          notify("Connexion expirée, veuillez réessayer.");
+          event.completed();
+        },
+        onError: (err) => {
+          notify("Une erreur est survenue, veuillez ré-essayer");
+          event.completed();
+        },
+      });
+      openTransitDialog(data.transit_token, {
+        onCancel: () => {
+          stopPolling();
+          event.completed();
+        },
+        onError: (err) => {
+          stopPolling();
+          event.completed();
+        },
+      });
+    })
+    .catch((err) => {
+      notify(`Erreur : ${err.message}`);
+      event.completed();
+    });
+}
+
+function generateMeetingLink(event) {
+  const session = loadSession();
+  if (session?.access_token) {
+    insertMeetingLink(event, session);
+  } else {
+    connect(event);
+  }
+}
+
+Office.actions.associate("generateMeetingLinkFromCalendar", generateMeetingLink);
+Office.actions.associate("generateMeetingLinkFromMail", generateMeetingLink);

src/addons/outlook/src/common/api.js

@@ -0,0 +1,82 @@
+const { URLS } = require("./urls");
+
+function getCsrfToken() {
+  return document.cookie
+    .split(";")
+    .filter((cookie) => cookie.trim().startsWith("csrftoken="))
+    .map((cookie) => cookie.split("=")[1])
+    .pop();
+}
+
+function authHeaders(session) {
+  return {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${session.access_token}`,
+  };
+}
+
+/**
+ * Builds headers for CSRF-protected requests.
+ *
+ * Two CSRF flows coexist in this addon:
+ *
+ * 1. Cookie-based (Django default): used by `exchange`, called from the
+ *    OAuth success page in a normal browser context. Django's CSRF
+ *    middleware has already set the `csrftoken` cookie via the auth
+ *    redirect, so we read it from `document.cookie` and echo it back
+ *    as `X-CSRFToken`. The middleware verifies the header matches the
+ *    cookie. No `csrfToken` argument needed — `getCsrfToken()` handles it.
+ *
+ * 2. Body-passed token: used by `poll`, called from the Office dialog /
+ *    taskpane iframe. Cookie access inside Office iframes is unreliable
+ *    across Outlook clients, so we can't depend on `document.cookie`
+ *    being populated. Instead, `init` returns the CSRF token in its JSON
+ *    response body, and callers pass it explicitly to subsequent calls.
+ *    The token still travels as `X-CSRFToken` — only its source differs.
+ *
+ * The `csrfToken` parameter takes precedence when provided; falls back
+ * to the cookie when omitted.
+ */
+function csrfHeaders(csrfToken) {
+  const token = csrfToken || getCsrfToken();
+  return {
+    "Content-Type": "application/json",
+    ...(token && { "X-CSRFToken": token }),
+  };
+}
+
+async function request(path, { session, csrf, csrfToken, ...opts } = {}) {
+  const headers = {
+    ...(session && authHeaders(session)),
+    ...(csrf && csrfHeaders(csrfToken)),
+    ...opts.headers,
+  };
+  const res = await fetch(path, {
+    ...opts,
+    headers,
+    credentials: csrf ? "include" : opts.credentials,
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.json();
+}
+
+module.exports = {
+  initSession: () => request(URLS.init, { method: "POST" }),
+  pollSession: (csrfToken) =>
+    request(URLS.poll, {
+      method: "POST",
+      csrf: true,
+      csrfToken,
+    }),
+  exchangeSession: (transitToken) =>
+    request(URLS.exchange, {
+      method: "POST",
+      csrf: true,
+      body: JSON.stringify({ transit_token: transitToken }),
+    }),
+  createRoom: (session) =>
+    request(URLS.rooms, {
+      method: "POST",
+      session,
+    }),
+};

src/addons/outlook/src/common/helpers.js

@@ -0,0 +1,16 @@
+const { APP_NAME } = require("./index");
+
+function isOfficeReady() {
+  return typeof Office !== "undefined" && Office?.context?.roamingSettings != null;
+}
+
+function applyAppName() {
+  document.querySelectorAll("[data-app-name]").forEach((el) => {
+    el.textContent = APP_NAME;
+  });
+}
+
+module.exports = {
+  isOfficeReady,
+  applyAppName,
+};

src/addons/outlook/src/common/index.js

@@ -0,0 +1,7 @@
+const BASE_URL = window.__APP_CONFIG__?.BASE_URL || "https://meet.127.0.0.1.nip.io";
+const APP_NAME = window.__APP_CONFIG__?.APP_NAME || "LaSuite Meet";
+
+module.exports = {
+  BASE_URL,
+  APP_NAME,
+};

src/addons/outlook/src/common/messageBuilder.js

@@ -0,0 +1,52 @@
+const { APP_NAME } = require("./index");
+
+function _formatPin(pin) {
+  if (!pin) return "";
+  const clean = String(pin).replace(/\s+/g, "");
+  if (!clean) return "";
+  if (/^\d{10}$/.test(clean)) {
+    return clean.replace(/(\d{3})(\d{3})(\d{4})/, "$1 $2 $3") + "#";
+  }
+  return clean + "#";
+}
+
+// todo - support international format
+function _formatPhone(phone) {
+  if (!phone) return "";
+  const clean = String(phone).replace(/\s+/g, "");
+  if (/^\+33\d{9}$/.test(clean)) {
+    return clean.replace(/^\+33(\d)(\d{2})(\d{2})(\d{2})(\d{2})$/, "+33 $1 $2 $3 $4 $5");
+  }
+  return clean;
+}
+
+// todo - escape html / link
+function buildMeetingMessage(data) {
+  if (!data?.url) {
+    throw new Error("buildMeetingMessage: missing url in data");
+  }
+
+  const url = data.url;
+  const phone = _formatPhone(data.telephony?.phone_number);
+  const pin = _formatPin(data.telephony?.pin_code);
+
+  const telephonyBlock =
+    phone && pin
+      ? `
+
+Ou appelez (audio uniquement)
+(FR) ${phone}
+Code : ${pin}`
+      : "";
+
+  const message = `<pre style="font-family:inherit; font-size:inherit; border:none; background:none; margin:16px 0;">
+────────────────────────────────────────
+Rejoindre la réunion ${APP_NAME}
+
+<a href="${url}">${url}</a>${telephonyBlock}
+────────────────────────────────────────</pre>`;
+
+  return { url, message };
+}
+
+module.exports = { buildMeetingMessage };

src/addons/outlook/src/common/polling.js

@@ -0,0 +1,47 @@
+const { pollSession } = require("./api");
+
+const POLLING_INTERVAL_MS = 1000;
+const POLLING_TIMEOUT_MS = 3 * 60 * 1000;
+const POLLING_MAX_ATTEMPTS = POLLING_TIMEOUT_MS / POLLING_INTERVAL_MS;
+
+function isPollAuthenticated(sessionData) {
+  return sessionData.state === "authenticated" && sessionData.access_token;
+}
+
+function startPolling(csrfToken, { onSuccess, onTimeout, onError }) {
+  let pollCount = 0;
+  let timeoutId = null;
+  let cancelled = false;
+
+  const poll = () => {
+    if (pollCount++ >= POLLING_MAX_ATTEMPTS) {
+      onTimeout?.();
+      return;
+    }
+
+    pollSession(csrfToken)
+      .then((sessionData) => {
+        if (cancelled) return;
+        if (isPollAuthenticated(sessionData)) {
+          onSuccess?.(sessionData);
+          return;
+        }
+        timeoutId = setTimeout(poll, POLLING_INTERVAL_MS);
+      })
+      .catch((err) => {
+        if (cancelled) return;
+        onError?.(err);
+      });
+  };
+
+  poll();
+
+  return () => {
+    cancelled = true;
+    if (timeoutId) clearTimeout(timeoutId);
+  };
+}
+
+module.exports = {
+  startPolling,
+};

src/addons/outlook/src/common/session.js

@@ -0,0 +1,104 @@
+const { isOfficeReady } = require("./helpers");
+
+const SESSION_KEY = "meetSession";
+
+// DEV NOTE:
+// Office.context.roamingSettings persists data in the user's mailbox and
+// synchronizes it via Exchange across all Outlook clients (desktop, web, mobile)
+// where the user signs in. This means anything stored here (including tokens)
+// leaves the local device boundary and is replicated across environments.
+//
+// Microsoft guidance explicitly advises NOT storing secrets (e.g., OAuth access
+// tokens, refresh tokens, or other sensitive credentials) in roamingSettings,
+// as it is not a secure storage mechanism and lacks OS-level protections.
+//
+// That said, for the current alpha version we accept this trade-off for simplicity,
+// with the expectation that a more secure approach (e.g., in-memory tokens) will replace this.
+function saveSession(data) {
+  if (!isOfficeReady()) {
+    return Promise.reject(new Error("Office not ready"));
+  }
+
+  if (!data || !data.access_token) {
+    return Promise.reject(new Error("Missing access_token"));
+  }
+
+  const expiresInSeconds = Number(data.expires_in);
+  const expiresAt =
+    Number.isFinite(expiresInSeconds) && expiresInSeconds > 0
+      ? new Date(Date.now() + expiresInSeconds * 1000).toISOString()
+      : null;
+
+  const payload = JSON.stringify({
+    ...data,
+    expiresAt,
+    savedAt: new Date().toISOString(),
+  });
+
+  return new Promise((resolve, reject) => {
+    const rs = Office.context.roamingSettings;
+    rs.set(SESSION_KEY, payload);
+    rs.saveAsync((result) => {
+      if (result.status === Office.AsyncResultStatus.Succeeded) {
+        resolve();
+      } else {
+        reject(new Error(result.error?.message || "saveAsync failed"));
+      }
+    });
+  });
+}
+
+function loadSession() {
+  if (!isOfficeReady()) {
+    return null;
+  }
+
+  let session = null;
+  try {
+    const stored = Office.context.roamingSettings.get(SESSION_KEY);
+    if (stored) session = JSON.parse(stored);
+  } catch (e) {
+    clearSession();
+    return null;
+  }
+
+  if (!session) return null;
+
+  // Fail closed if expiry is missing — backend is expected to send expires_in.
+  if (!session.expiresAt) {
+    clearSession();
+    return null;
+  }
+
+  const expiresTs = Date.parse(session.expiresAt);
+  if (!Number.isFinite(expiresTs) || Date.now() >= expiresTs) {
+    clearSession();
+    return null;
+  }
+
+  return session;
+}
+
+function clearSession() {
+  if (!isOfficeReady()) {
+    return Promise.resolve();
+  }
+
+  return new Promise((resolve) => {
+    try {
+      const rs = Office.context.roamingSettings;
+      rs.remove(SESSION_KEY);
+      rs.saveAsync((result) => {
+        resolve();
+      });
+    } catch (e) {
+      resolve();
+    }
+  });
+}
+
+module.exports = {
+  saveSession,
+  loadSession,
+  clearSession,
+};

src/addons/outlook/src/common/transitDialog.js

@@ -0,0 +1,43 @@
+const { URLS } = require("./urls");
+
+const DIALOG_SIGNALS = {
+  ready: "ready",
+  done: "done",
+};
+
+const DIALOG_HEIGHT = 60;
+const DIALOG_WIDTH = 50;
+
+function openTransitDialog(transitToken, { onCancel, onError }) {
+  Office.context.ui.displayDialogAsync(
+    URLS.transitDialog,
+    { height: DIALOG_HEIGHT, width: DIALOG_WIDTH, displayInIframe: false },
+    (asyncResult) => {
+      if (asyncResult.status === Office.AsyncResultStatus.Failed) {
+        onError?.(asyncResult.error);
+        return;
+      }
+
+      const dialog = asyncResult.value;
+
+      dialog.addEventHandler(Office.EventType.DialogMessageReceived, (arg) => {
+        if (arg.message === DIALOG_SIGNALS.ready) {
+          dialog.messageChild(transitToken);
+          return;
+        }
+        if (arg.message === DIALOG_SIGNALS.done) {
+          return;
+        }
+        onCancel?.();
+        dialog.close();
+      });
+
+      return dialog;
+    }
+  );
+}
+
+module.exports = {
+  openTransitDialog,
+  DIALOG_SIGNALS,
+};

src/addons/outlook/src/common/transitToken.js

@@ -0,0 +1,18 @@
+const TRANSIT_TOKEN_KEY = "transitToken";
+
+function save(token) {
+  sessionStorage.setItem(TRANSIT_TOKEN_KEY, token);
+}
+
+function consume() {
+  try {
+    const token = sessionStorage.getItem(TRANSIT_TOKEN_KEY);
+    sessionStorage.removeItem(TRANSIT_TOKEN_KEY);
+    return token;
+  } catch (err) {
+    console.error("Failed to read transit token:", err);
+    return null;
+  }
+}
+
+module.exports = { save, consume };

src/addons/outlook/src/common/urls.js

@@ -0,0 +1,15 @@
+const { BASE_URL } = require("./index");
+
+const ADDONS_BASE_URL = `${BASE_URL}/api/v1.0/addons/sessions`;
+
+const URLS = {
+  authenticate: `${BASE_URL}/api/v1.0/authenticate/`,
+  successPage: `${BASE_URL}/addons/outlook/success.html`,
+  transitDialog: `${BASE_URL}/addons/outlook/transit.html`,
+  init: `${ADDONS_BASE_URL}/init/`,
+  poll: `${ADDONS_BASE_URL}/poll/`,
+  exchange: `${ADDONS_BASE_URL}/exchange/`,
+  rooms: `${BASE_URL}/external-api/v1.0/rooms/`,
+};
+
+module.exports = { URLS };

src/addons/outlook/src/styles/spinner.css

@@ -0,0 +1,81 @@
+html, body {
+    margin: 0;
+    padding: 0;
+    height: 100%;
+}
+
+body {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+#sideload-msg {
+    display: none;
+}
+
+#status {
+    display: none;
+}
+
+.spinner-container {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 56px;
+    height: 56px;
+}
+
+.spinner-svg {
+    width: 56px;
+    height: 56px;
+}
+
+/* Background arc (light gray ring) */
+.spinner-track {
+    stroke: #E5E7EB; /* primary.100 equivalent */
+    fill: none;
+    stroke-width: 3;
+    stroke-linecap: round;
+}
+
+/* Foreground rotating arc */
+.spinner-arc {
+    stroke: #000091; /* primary.800 equivalent */
+    fill: none;
+    stroke-width: 3;
+    stroke-linecap: round;
+    /* circumference = 2 * PI * r where r = 11 -> ~69.115 */
+    /* show 30% -> dashoffset = c - 0.3 * c = ~48.38 */
+    stroke-dasharray: 69.115 69.115;
+    stroke-dashoffset: 48.38;
+    transform-origin: center;
+    animation: spinner-rotate 1s ease-in-out infinite;
+}
+
+@keyframes spinner-rotate {
+    0% {
+        transform: rotate(0deg);
+    }
+    100% {
+        transform: rotate(360deg);
+    }
+}
+
+/* Hourglass fallback for reduced motion */
+.spinner-fallback {
+    display: none;
+    color: #000091;
+}
+
+@media (prefers-reduced-motion: reduce) {
+    .spinner-svg {
+        display: none;
+    }
+    .spinner-fallback {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+    }
+}

src/addons/outlook/src/success/success.html

@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title data-app-name></title>
+    <link rel="stylesheet" href="../styles/spinner.css" />
+    <script nonce="NONCE_PLACEHOLDER" src="/addons/outlook/config.js"></script>
+</head>
+    <body>
+        <div id="sideload-msg">Veuillez charger le complément.</div>
+        <div class="spinner-container"
+             role="progressbar"
+             aria-label="Chargement..."
+        >
+            <svg class="spinner-svg"
+                 viewBox="0 0 28 28"
+                 fill="none"
+                 xmlns="http://www.w3.org/2000/svg"
+            >
+                <!-- Background track -->
+                <circle class="spinner-track" cx="14" cy="14" r="11"
+                />
+                <!-- Rotating arc -->
+                <circle class="spinner-arc" cx="14" cy="14" r="11"
+                />
+            </svg>
+
+            <!-- Fallback hourglass icon (Remix Icon RiHourglassFill SVG path) -->
+            <span class="spinner-fallback" aria-hidden="true">
+                        <svg width="22"
+                             height="22"
+                             viewBox="0 0 24 24"
+                             fill="currentColor"
+                             xmlns="http://www.w3.org/2000/svg"
+                             style="display: block; transform: translateY(1px);"
+                        >
+                            <path d="M6 2H18V4L13 12L18 20V22H6V20L11 12L6 4V2ZM8.535 4L13 11.143L17.465 4H8.535Z"/>
+                        </svg>
+                    </span>
+        </div>
+    </body>
+</html>

src/addons/outlook/src/success/success.js

@@ -0,0 +1,20 @@
+const { applyAppName } = require("../common/helpers");
+const { exchangeSession } = require("../common/api");
+const { consume } = require("../common/transitToken");
+
+applyAppName();
+
+const transitToken = consume();
+
+if (!transitToken) {
+  console.error("Transit token not found in sessionStorage");
+  window.close();
+} else {
+  exchangeSession(transitToken)
+    .catch((e) => {
+      console.error(`Error occured: ${e}`);
+    })
+    .finally(() => {
+      window.close();
+    });
+}

src/addons/outlook/src/taskpane/taskpane.html

@@ -0,0 +1,56 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title data-app-name></title>
+    <link rel="stylesheet" href="taskpane.css" />
+    <script nonce="NONCE_PLACEHOLDER" src="/addons/outlook/config.js"></script>
+    <script nonce="NONCE_PLACEHOLDER" src="https://appsforoffice.microsoft.com/lib/1/hosted/office.js"></script>
+</head>
+<body>
+<div id="sideload-msg">Veuillez charger le complément.</div>
+
+<div id="app-body">
+
+    <!-- Loading -->
+    <div id="view-loading">
+        <p class="intro-text">Chargement...</p>
+    </div>
+
+    <!-- Unauthenticated -->
+    <div id="view-unauth" style="display:none;">
+        <p class="intro-text">
+            <span>Ajoutez facilement un lien de réunion <span data-app-name></span> à vos événements Outlook.</span>
+        </p>
+        <hr class="divider" />
+        <button class="proconnect-button" id="btn-connect">
+            <span class="proconnect-sr-only">S'identifier avec ProConnect</span>
+        </button>
+        <p>
+            <a
+                    href="https://www.proconnect.gouv.fr/"
+                    target="_blank"
+                    rel="noopener noreferrer"
+                    title="Qu’est-ce que ProConnect ? - nouvelle fenêtre"
+            >
+                Qu’est-ce que ProConnect ?
+            </a>
+        </p>
+    </div>
+
+    <!-- Authenticated -->
+    <div id="view-auth" style="display:none;">
+        <div id="btn-container">
+            <button id="btn-generate">Ajouter une réunion <span data-app-name></span></button>
+            <button id="btn-disconnect">Se déconnecter</button>
+        </div>
+    </div>
+</div>
+<footer id="version-tag">
+    <span class="version-badge">alpha</span>
+    <span class="version-number">0.0.1</span>
+</footer>
+</body>
+</html>

src/addons/outlook/src/taskpane/taskpane.js

@@ -0,0 +1,128 @@
+const { APP_NAME } = require("../common");
+
+const { applyAppName } = require("../common/helpers");
+const { initSession, createRoom } = require("../common/api");
+const { startPolling } = require("../common/polling");
+const { openTransitDialog } = require("../common/transitDialog");
+const { loadSession, saveSession, clearSession } = require("../common/session");
+
+const { buildMeetingMessage } = require("../common/messageBuilder");
+
+// todo - support loading view while polling
+// todo - support error view
+function showView(name) {
+  document.getElementById("view-loading").style.display = "none";
+  document.getElementById("view-unauth").style.display = "none";
+  document.getElementById("view-auth").style.display = "none";
+  document.getElementById(`view-${name}`).style.display = "block";
+}
+
+function connect() {
+  initSession()
+    .then((data) => {
+      const stopPolling = startPolling(data.csrf_token, {
+        onSuccess: (sessionData) => {
+          saveSession(sessionData).then(() => showView("auth"));
+        },
+        onTimeout: () => {
+          showView("unauth");
+        },
+        onError: (err) => {
+          console.error(err);
+        },
+      });
+      openTransitDialog(data.transit_token, {
+        onCancel: () => stopPolling(),
+        onError: (err) => {
+          stopPolling();
+        },
+      });
+    })
+    .catch((err) => {
+      console.error(err);
+    });
+}
+
+function disconnect() {
+  clearSession().finally(() => showView("unauth"));
+}
+
+function _setButtonLoading() {
+  const btn = document.getElementById("btn-generate");
+  btn.disabled = true;
+  btn.textContent = "Génération...";
+}
+
+function _setButtonIdle() {
+  const btn = document.getElementById("btn-generate");
+  btn.disabled = false;
+  btn.textContent = `Ajouter une réunion ${APP_NAME}`;
+}
+
+function generateMeetingLink() {
+  const session = loadSession();
+  if (!session?.access_token) {
+    console.error("Session introuvable. Veuillez vous reconnecter.");
+    showView("unauth");
+    return;
+  }
+
+  _setButtonLoading();
+
+  createRoom(session)
+    .then((data) => {
+      const { url, message } = buildMeetingMessage(data);
+      const item = Office.context.mailbox.item;
+      return new Promise((resolve, reject) => {
+        item.body.getAsync(Office.CoercionType.Html, (getResult) => {
+          if (getResult.status !== Office.AsyncResultStatus.Succeeded) {
+            reject(getResult.error);
+            return;
+          }
+
+          item.body.setAsync(
+            getResult.value + message,
+            { coercionType: Office.CoercionType.Html },
+            (setResult) => {
+              if (setResult.status !== Office.AsyncResultStatus.Succeeded) {
+                reject(setResult.error);
+                return;
+              }
+
+              // ─── If calendar event, also set location ──────────────
+              if (item.itemType === Office.MailboxEnums.ItemType.Appointment) {
+                item.location.setAsync(url, () => resolve());
+                return;
+              }
+
+              resolve();
+            }
+          );
+        });
+      });
+    })
+    .catch((err) => {
+      console.error(err);
+    })
+    .finally(() => {
+      _setButtonIdle();
+    });
+}
+
+Office.onReady((info) => {
+  if (info.host === Office.HostType.Outlook) {
+    applyAppName();
+    document.getElementById("sideload-msg").style.display = "none";
+    document.getElementById("app-body").style.display = "flex";
+    document.getElementById("btn-connect").onclick = connect;
+    document.getElementById("btn-disconnect").onclick = disconnect;
+    document.getElementById("btn-generate").onclick = generateMeetingLink;
+
+    const session = loadSession();
+    if (session?.state === "authenticated" && session?.access_token) {
+      showView("auth");
+    } else {
+      showView("unauth");
+    }
+  }
+});

src/addons/outlook/src/transit/transit.html

@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<html lang="fr">
+    <head>
+        <meta charset="UTF-8" />
+        <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <title data-app-name></title>
+        <link rel="stylesheet" href="../styles/spinner.css" />
+        <script nonce="NONCE_PLACEHOLDER" src="/addons/outlook/config.js"></script>
+        <script nonce="NONCE_PLACEHOLDER" src="https://appsforoffice.microsoft.com/lib/1/hosted/office.js"></script>
+    </head>
+    <body>
+        <div id="sideload-msg">Veuillez charger le complément.</div>
+        <div
+            class="spinner-container"
+            role="progressbar"
+            aria-label="Chargement..."
+        >
+            <svg
+                class="spinner-svg"
+                viewBox="0 0 28 28"
+                fill="none"
+                xmlns="http://www.w3.org/2000/svg"
+            >
+                <!-- Background track -->
+                <circle class="spinner-track" cx="14" cy="14" r="11"
+                />
+                <!-- Rotating arc -->
+                <circle class="spinner-arc" cx="14" cy="14" r="11"
+                />
+            </svg>
+
+            <!-- Fallback hourglass icon (Remix Icon RiHourglassFill SVG path) -->
+            <span class="spinner-fallback" aria-hidden="true">
+                <svg
+                    width="22"
+                    height="22"
+                    viewBox="0 0 24 24"
+                    fill="currentColor"
+                    xmlns="http://www.w3.org/2000/svg"
+                    style="display: block; transform: translateY(1px);"
+                >
+                    <path d="M6 2H18V4L13 12L18 20V22H6V20L11 12L6 4V2ZM8.535 4L13 11.143L17.465 4H8.535Z"/>
+                </svg>
+            </span>
+        </div>
+    </body>
+</html>

src/addons/outlook/src/transit/transit.js

@@ -0,0 +1,53 @@
+const { applyAppName } = require("../common/helpers");
+const { URLS } = require("../common/urls");
+const { save } = require("../common/transitToken");
+const { DIALOG_SIGNALS } = require("../common/transitDialog");
+
+// Initiate the authentication flow, then return to the success page
+function getAuthenticateUrl() {
+  const url = new URL(URLS.authenticate);
+  url.searchParams.set("returnTo", URLS.successPage);
+  return url.toString();
+}
+
+Office.onReady(function (info) {
+  if (info.host === Office.HostType.Outlook) {
+    applyAppName();
+  }
+
+  Office.context.ui.addHandlerAsync(
+    Office.EventType.DialogParentMessageReceived,
+    function (arg) {
+      const transitToken = arg.message;
+
+      if (typeof transitToken !== "string" || transitToken.trim() === "") {
+        console.error("Invalid transit token received from parent dialog.");
+        return;
+      }
+
+      // Runs inside the dialog window.
+      // Flow:
+      // transit.html saves token → navigates to /authenticate → OAuth redirect →
+      // success.html. sessionStorage survives because it's per-window-per-origin
+      // and the dialog window persists across same-origin navigations.
+      // Fragile: if the IdP opens the redirect in a new tab/window, this breaks
+      // silently.
+      // An alternative could be to pass the token via the OAuth `state` param
+      // and read it back from the redirect URL.
+      try {
+        save(transitToken);
+        Office.context.ui.messageParent(DIALOG_SIGNALS.done);
+        window.location.href = getAuthenticateUrl();
+      } catch (err) {
+        console.error("Failed to store transit token:", err);
+      }
+    },
+    function (result) {
+      if (result.status !== Office.AsyncResultStatus.Succeeded) {
+        console.error("Failed to register DialogParentMessageReceived handler.", result.error);
+        return;
+      }
+      Office.context.ui.messageParent(DIALOG_SIGNALS.ready);
+    }
+  );
+});

src/addons/outlook/webpack.config.js

@@ -0,0 +1,128 @@
+/* eslint-disable no-undef */
+
+const devCerts = require("office-addin-dev-certs");
+const CopyWebpackPlugin = require("copy-webpack-plugin");
+const HtmlWebpackPlugin = require("html-webpack-plugin");
+const htmlWebpackInjectAttributesPlugin = require("html-webpack-inject-attributes-plugin");
+
+async function getHttpsOptions() {
+  const httpsOptions = await devCerts.getHttpsServerOptions();
+  return { ca: httpsOptions.ca, key: httpsOptions.key, cert: httpsOptions.cert };
+}
+
+module.exports = async (env, options) => {
+  const config = {
+    devtool: "source-map",
+    entry: {
+      polyfill: ["core-js/stable", "regenerator-runtime/runtime"],
+      taskpane: ["./src/taskpane/taskpane.js", "./src/taskpane/taskpane.html"],
+      commands: "./src/commands/commands.js",
+      transit: ["./src/transit/transit.js", "./src/transit/transit.html"],
+      success: ["./src/success/success.js", "./src/success/success.html"],
+    },
+    output: {
+      clean: true,
+    },
+    resolve: {
+      extensions: [".html", ".js"],
+    },
+    module: {
+      rules: [
+        {
+          test: /\.js$/,
+          exclude: /node_modules/,
+          use: {
+            loader: "babel-loader",
+          },
+        },
+        {
+          test: /\.html$/,
+          exclude: /node_modules/,
+          use: {
+            loader: "html-loader",
+            options: {
+              sources: {
+                urlFilter: (attribute, value) => {
+                  // Don't try to resolve the runtime-injected config
+                  if (value.includes("config.js")) {
+                    return false;
+                  }
+                  return true;
+                },
+              },
+            },
+          },
+        },
+        {
+          test: /\.(png|jpg|jpeg|gif|ico)$/,
+          type: "asset/resource",
+          generator: {
+            filename: "assets/[name][ext][query]",
+          },
+        },
+      ],
+    },
+    plugins: [
+      new HtmlWebpackPlugin({
+        filename: "taskpane.html",
+        template: "./src/taskpane/taskpane.html",
+        chunks: ["polyfill", "taskpane"],
+        scriptLoading: "defer",
+        attributes: {
+          nonce: "NONCE_PLACEHOLDER",
+        },
+      }),
+      new CopyWebpackPlugin({
+        patterns: [
+          {
+            from: "assets/*",
+            to: "assets/[name][ext][query]",
+          }
+        ],
+      }),
+      new HtmlWebpackPlugin({
+        filename: "commands.html",
+        template: "./src/commands/commands.html",
+        chunks: ["polyfill", "commands"],
+        scriptLoading: "defer",
+        attributes: {
+          nonce: "NONCE_PLACEHOLDER",
+        },
+      }),
+      new HtmlWebpackPlugin({
+        filename: "transit.html",
+        template: "./src/transit/transit.html",
+        chunks: ["polyfill", "transit"],
+        scriptLoading: "defer",
+        attributes: {
+          nonce: "NONCE_PLACEHOLDER",
+        },
+      }),
+      new HtmlWebpackPlugin({
+        filename: "success.html",
+        template: "./src/success/success.html",
+        chunks: ["polyfill", "success"],
+        scriptLoading: "defer",
+        attributes: {
+          nonce: "NONCE_PLACEHOLDER",
+        },
+      }),
+      new htmlWebpackInjectAttributesPlugin(),
+    ],
+    devServer: {
+      headers: {
+        "Access-Control-Allow-Origin": "*",
+      },
+      server: {
+        type: "https",
+        options:
+          env.WEBPACK_BUILD || options.https !== undefined
+            ? options.https
+            : await getHttpsOptions(),
+      },
+      port: process.env.npm_package_config_dev_server_port || 3000,
+    },
+  };
+
+  return config;
+};

src/agents/.dockerignore

@@ -0,0 +1,38 @@
+# Python
+__pycache__
+*.pyc
+**/__pycache__
+**/*.pyc
+venv
+**/.venv
+
+# System-specific files
+.DS_Store
+**/.DS_Store
+
+# Docker
+compose.*
+env.d
+
+# Docs
+docs
+*.md
+*.log
+
+# Development/test cache & configurations
+data
+.cache
+.circleci
+.git
+.iml
+db.sqlite3
+.pylint.d
+
+**/.idea
+**/.vscode
+**/.pytest_cache
+**/.mypy_cache
+**/.ruff_cache
+
+# Env
+.env

src/agents/Dockerfile

@@ -1,35 +1,72 @@
-FROM python:3.13-slim AS base
+FROM python:3.13.13-slim AS base
 
 # Install system dependencies required by LiveKit
 RUN apt-get update && apt-get install -y \
     libglib2.0-0 \
     libgobject-2.0-0 \
-    "openssl=3.5.4-1~deb13u2" \
-    "libssl3t64=3.5.4-1~deb13u2" \
     && rm -rf /var/lib/apt/lists/*
 
+
+# ---- Builder image ----
 FROM base AS builder
 
-WORKDIR /builder
+ENV UV_COMPILE_BYTECODE=1 \
+    UV_LINK_MODE=copy \
+    UV_PYTHON_DOWNLOADS=0
 
-COPY pyproject.toml .
+# Install uv
+COPY --from=ghcr.io/astral-sh/uv:0.10.9 /uv /uvx /bin/
 
-RUN mkdir /install && \
-  pip install --prefix=/install .
+WORKDIR /app
 
+# Install production dependencies without the project itself (cacheable layer)
+RUN --mount=type=cache,target=/root/.cache/uv \
+    --mount=type=bind,source=uv.lock,target=uv.lock \
+    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+    uv sync --locked --no-install-project --no-dev
+
+# Install the project
+COPY . /app
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --locked --no-dev
+
+
+# ---- Development image ----
+FROM base AS development
+
+ENV UV_COMPILE_BYTECODE=1 \
+    UV_LINK_MODE=copy \
+    UV_PYTHON_DOWNLOADS=0
+
+COPY --from=ghcr.io/astral-sh/uv:0.10.9 /uv /uvx /bin/
+
+WORKDIR /app
+
+COPY . /app
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --locked --all-extras
+
+ENV PATH="/app/.venv/bin:$PATH"
+
+CMD ["python", "multi_user_transcriber.py", "dev"]
+
+
+# ---- Production image ----
 FROM base AS production
 
 WORKDIR /app
 
+# Copy the pre-built virtualenv and application source
+COPY --from=builder /app /app
+
+ENV PATH="/app/.venv/bin:$PATH"
+
 # Remove pip to reduce attack surface in production
 RUN pip uninstall -y pip
 
+# Un-privileged user running the application
 ARG DOCKER_USER
 USER ${DOCKER_USER}
 
-# Un-privileged user running the application
-COPY --from=builder /install /usr/local
-
-COPY . .
-
-CMD ["python", "multi-user-transcriber.py", "start"]
+CMD ["python", "multi_user_transcriber.py", "start"]

src/agents/exceptions.py

@@ -0,0 +1,5 @@
+"""Storage parsers specific exceptions."""
+
+
+class MissingConfigError(Exception):
+    """Raised when a variable is not set in configuration."""

src/agents/metadata_collector.py

@@ -0,0 +1,380 @@
+"""Metadata agent that extracts metadata from active room."""
+
+import asyncio
+import json
+import logging
+import os
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from io import BytesIO
+from typing import List, Optional
+
+from dotenv import load_dotenv
+from livekit import api, rtc
+from livekit.agents import (
+    Agent,
+    AgentServer,
+    AgentSession,
+    AutoSubscribe,
+    JobContext,
+    JobProcess,
+    JobRequest,
+    RoomIO,
+    WorkerPermissions,
+    cli,
+    utils,
+)
+from livekit.agents import (
+    room_io as lk_room_io,
+)
+from livekit.plugins import silero
+from minio import Minio
+from minio.error import S3Error
+
+from exceptions import MissingConfigError
+
+load_dotenv()
+
+logger = logging.getLogger("metadata-collector")
+
+AGENT_NAME = os.getenv("METADATA_COLLECTOR_AGENT_NAME", "metadata-collector")
+
+
+def prewarm(proc: JobProcess):
+    """Preload voice activity detection model."""
+    proc.userdata["vad"] = silero.VAD.load()
+
+
+server = AgentServer(
+    permissions=WorkerPermissions(
+        can_publish=False,
+        can_publish_data=False,
+        can_subscribe=True,
+        hidden=True,
+    ),
+)
+server.setup_fnc = prewarm
+
+
+@dataclass
+class MetadataEvent:
+    """A single timestamped event recorded during a meeting."""
+
+    participant_id: str
+    type: str
+    timestamp: datetime
+    data: Optional[str] = None
+
+    def serialize(self) -> dict:
+        """Return a JSON-serializable dictionary representation of the event."""
+        data = asdict(self)
+        data["timestamp"] = self.timestamp.isoformat()
+        return data
+
+
+class VADAgent(Agent):
+    """Agent that monitors voice activity for a specific participant."""
+
+    def __init__(self, participant_identity: str, events: List):
+        """Initialize with a participant identity and shared events list."""
+        super().__init__(
+            instructions="not-needed",
+        )
+        self.participant_identity = participant_identity
+        self.events = events
+
+    async def on_enter(self) -> None:
+        """Initialize VAD monitoring for this participant."""
+
+        @self.session.on("user_state_changed")
+        def on_user_state(event):
+            timestamp = datetime.now(timezone.utc)
+
+            if event.new_state == "speaking":
+                event = MetadataEvent(
+                    participant_id=self.participant_identity,
+                    type="speech_start",
+                    timestamp=timestamp,
+                )
+                self.events.append(event)
+
+            elif event.old_state == "speaking":
+                event = MetadataEvent(
+                    participant_id=self.participant_identity,
+                    type="speech_end",
+                    timestamp=timestamp,
+                )
+                self.events.append(event)
+
+
+class MetadataCollector:
+    """Collect meeting events across all participants in a room.
+
+    Creates one AgentSession per participant to capture VAD events
+    (speech start/end), and listens for connection, disconnection,
+    and chat events. Persists all collected events as JSON to S3
+    on shutdown.
+    """
+
+    def __init__(self, ctx: JobContext, recording_id: str):
+        """Initialize metadata agent."""
+        self.minio_client = Minio(
+            endpoint=os.getenv("AWS_S3_ENDPOINT_URL"),
+            access_key=os.getenv("AWS_S3_ACCESS_KEY_ID"),
+            secret_key=os.getenv("AWS_S3_SECRET_ACCESS_KEY"),
+            secure=os.getenv("AWS_S3_SECURE_ACCESS", "False").lower() == "true",
+        )
+
+        if (bucket_name := os.getenv("AWS_STORAGE_BUCKET_NAME")) is not None:
+            self.bucket_name = bucket_name
+        else:
+            raise MissingConfigError
+
+        self.ctx = ctx
+        self._sessions: dict[str, AgentSession] = {}
+        self._tasks: set[asyncio.Task] = set()
+
+        output_folder = os.getenv("AWS_S3_OUTPUT_FOLDER", "metadata")
+        self.output_filename = f"{output_folder}/{recording_id}-metadata.json"
+
+        # Storage for events
+        self.events = []
+        self.participants = {}
+
+        logger.info("MetadataCollector initialized")
+
+    def start(self):
+        """Start listening for room-level events."""
+        self.ctx.room.on("participant_disconnected", self.on_participant_disconnected)
+        self.ctx.room.on("participant_name_changed", self.on_participant_name_changed)
+
+        self.ctx.room.register_text_stream_handler("lk.chat", self.handle_chat_stream)
+
+        logger.info("Started listening for participant events")
+
+    async def on_chat_message_received(
+        self, reader: rtc.TextStreamReader, participant_identity: str
+    ):
+        """Read a complete chat message and record it as an event."""
+        full_text = await reader.read_all()
+        logger.info("Received chat message from %s", participant_identity)
+
+        self.events.append(
+            MetadataEvent(
+                participant_id=participant_identity,
+                type="chat_received",
+                timestamp=datetime.now(timezone.utc),
+                data=full_text,
+            )
+        )
+
+    def handle_chat_stream(self, reader, participant_identity):
+        """Schedule async processing of an incoming chat stream."""
+        task = asyncio.create_task(
+            self.on_chat_message_received(reader, participant_identity)
+        )
+        self._tasks.add(task)
+        task.add_done_callback(lambda _: self._tasks.remove(task))
+
+    def save(self):
+        """Serialize collected events and upload as JSON to S3."""
+        logger.info("Persisting metadata...")
+
+        participants = []
+        for k, v in self.participants.items():
+            participants.append({"participantId": k, "name": v})
+
+        sorted_events = sorted(self.events, key=lambda e: e.timestamp)
+
+        payload = {
+            "events": [event.serialize() for event in sorted_events],
+            "participants": participants,
+        }
+
+        data = json.dumps(payload, indent=2).encode("utf-8")
+        stream = BytesIO(data)
+
+        try:
+            self.minio_client.put_object(
+                self.bucket_name,
+                self.output_filename,
+                stream,
+                length=len(data),
+                content_type="application/json",
+            )
+            logger.info(
+                "Uploaded speaker meeting metadata",
+            )
+        except S3Error:
+            logger.exception(
+                "Failed to upload meeting metadata",
+            )
+
+    async def aclose(self):
+        """Close all sessions and cleanup resources."""
+        logger.info("Closing all VAD monitoring sessions…")
+
+        await utils.aio.cancel_and_wait(*self._tasks)
+
+        await asyncio.gather(
+            *[self._close_session(session) for session in self._sessions.values()],
+            return_exceptions=True,
+        )
+
+        self.ctx.room.off("participant_disconnected", self.on_participant_disconnected)
+        self.ctx.room.off("participant_name_changed", self.on_participant_name_changed)
+
+        logger.info("All VAD sessions closed")
+        self.save()
+
+    async def on_participant_entrypoint(
+        self, ctx: JobContext, participant: rtc.RemoteParticipant
+    ):
+        """Handle new participant by starting a VAD monitoring session."""
+        if participant.identity in self._sessions:
+            logger.debug("Session already exists for %s", participant.identity)
+            return
+
+        self.events.append(
+            MetadataEvent(
+                participant_id=participant.identity,
+                type="participant_connected",
+                timestamp=datetime.now(timezone.utc),
+            )
+        )
+
+        self.participants[participant.identity] = participant.name
+
+        logger.info("New participant connected: %s", participant.identity)
+        try:
+            session = await self._start_session(participant)
+            self._sessions[participant.identity] = session
+        except Exception:
+            logger.exception("Failed to start session for %s", participant.identity)
+
+    def on_participant_disconnected(self, participant: rtc.RemoteParticipant):
+        """Handle participant disconnection by closing VAD monitoring."""
+        self.events.append(
+            MetadataEvent(
+                participant_id=participant.identity,
+                type="participant_disconnected",
+                timestamp=datetime.now(timezone.utc),
+            )
+        )
+
+        session = self._sessions.pop(participant.identity, None)
+        if session is None:
+            logger.debug("No session found for %s", participant.identity)
+            return
+
+        logger.info("Participant disconnected: %s", participant.identity)
+        task = asyncio.create_task(self._close_session(session))
+        self._tasks.add(task)
+
+        def on_close_done(_):
+            self._tasks.discard(task)
+            logger.info(
+                "VAD session closed for %s (remaining sessions: %d)",
+                participant.identity,
+                len(self._sessions),
+            )
+
+        task.add_done_callback(on_close_done)
+
+    def on_participant_name_changed(self, participant: rtc.RemoteParticipant):
+        """Update stored participant name when it changes."""
+        logger.info("Participant's name changed: %s", participant.identity)
+        self.participants[participant.identity] = participant.name
+
+    async def _start_session(self, participant: rtc.RemoteParticipant) -> AgentSession:
+        """Create and start VAD monitoring session for participant."""
+        if participant.identity in self._sessions:
+            return self._sessions[participant.identity]
+
+        # Create session with VAD only - no STT, LLM, or TTS
+        session = AgentSession(
+            vad=self.ctx.proc.userdata["vad"],
+            turn_detection="vad",
+            user_away_timeout=30.0,
+        )
+
+        # Set up room IO to receive audio from this specific participant
+        room_io = RoomIO(
+            agent_session=session,
+            room=self.ctx.room,
+            participant=participant,
+            options=lk_room_io.RoomOptions(
+                audio_input=lk_room_io.AudioInputOptions(),
+                text_input=False,
+                audio_output=False,
+                text_output=False,
+            ),
+        )
+
+        await room_io.start()
+        await session.start(
+            agent=VADAgent(
+                participant_identity=participant.identity, events=self.events
+            )
+        )
+
+        return session
+
+    async def _close_session(self, session: AgentSession) -> None:
+        """Close and cleanup VAD monitoring session."""
+        try:
+            await session.aclose()
+        except Exception:
+            logger.exception("Error closing session")
+
+
+async def handle_job_request(job_req: JobRequest) -> None:
+    """Accept or reject the job request based on agent presence in the room."""
+    room_name = job_req.room.name
+    recording_id = job_req.job.metadata
+    agent_identity = f"{AGENT_NAME}-{room_name}"
+
+    async with api.LiveKitAPI() as lk:
+        try:
+            resp = await lk.room.list_participants(
+                list=api.ListParticipantsRequest(room=room_name)
+            )
+            already_present = any(
+                p.kind == rtc.ParticipantKind.PARTICIPANT_KIND_AGENT
+                and p.identity == agent_identity
+                for p in resp.participants
+            )
+            if already_present:
+                logger.info("Agent already in the room '%s' — reject", room_name)
+                await job_req.reject()
+            else:
+                logger.info(
+                    "Accept job for '%s' — identity=%s", room_name, agent_identity
+                )
+                await job_req.accept(identity=agent_identity, metadata=recording_id)
+        except Exception:
+            logger.exception("Error treating the job for '%s'", room_name)
+            await job_req.reject()
+
+
+@server.rtc_session(agent_name=AGENT_NAME, on_request=handle_job_request)
+async def entrypoint(ctx: JobContext):
+    """Initialize and run the metadata collector."""
+    logger.info("Starting metadata agent in room: %s", ctx.room.name)
+    recording_id = ctx.job.metadata
+    metadata_collector = MetadataCollector(ctx, recording_id)
+    metadata_collector.start()
+
+    ctx.add_participant_entrypoint(metadata_collector.on_participant_entrypoint)
+
+    await ctx.connect(auto_subscribe=AutoSubscribe.AUDIO_ONLY)
+
+    async def cleanup():
+        logger.info("Shutting down metadata collector...")
+        await metadata_collector.aclose()
+
+    ctx.add_shutdown_callback(cleanup)
+
+
+if __name__ == "__main__":
+    cli.run_app(server)

src/agents/pyproject.toml

@@ -1,25 +1,25 @@
 
 [project]
 name = "agents"
-version = "1.10.0"
+version = "1.19.0"
 requires-python = ">=3.12"
 dependencies = [
-    "livekit-agents==1.3.10",
-    "livekit-plugins-deepgram==1.3.10",
-    "livekit-plugins-silero==1.3.10",
+    "livekit-agents==1.5.13",
+    "livekit-plugins-deepgram==1.5.13",
+    "livekit-plugins-silero==1.5.13",
     "livekit-plugins-kyutai-lasuite==0.0.6",
-    "python-dotenv==1.2.1",
-    "protobuf==6.33.5"
+    "python-dotenv==1.2.2",
+    "protobuf==6.33.6",
+    "minio==7.2.20"
 ]
 
 [project.optional-dependencies]
 dev = [
-    "ruff==0.14.4",
+    "ruff==0.15.14",
 ]
 
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
+[tool.uv]
+package = false
 
 [tool.ruff]
 target-version = "py313"

src/backend/core/addons/__init__.py

@@ -0,0 +1 @@
+"""Meet core add-ons module."""

src/backend/core/addons/service.py

@@ -0,0 +1,344 @@
+"""Authentication session management for add-ons using temporary cache-based sessions."""
+
+import hashlib
+import hmac
+import secrets
+from datetime import datetime, timedelta, timezone
+from enum import Enum
+from logging import getLogger
+
+from django.conf import settings
+from django.core.cache import cache
+from django.core.exceptions import ImproperlyConfigured
+
+from core.models import User
+from core.services.jwt_token import JwtTokenService
+
+logger = getLogger(__name__)
+
+_PUBLIC_SESSION_FIELDS = frozenset(
+    {"state", "access_token", "token_type", "expires_in", "scope"}
+)
+
+
+class SessionDataError(Exception):
+    """Raised when session data is invalid or malformed."""
+
+
+class CSRFTokenError(Exception):
+    """Raised when CSRF token verification fails."""
+
+
+class TransitTokenError(Exception):
+    """Raised when a transit token is invalid or expired."""
+
+
+class SessionExpiredError(Exception):
+    """Raised when a session has expired."""
+
+
+class SessionNotFoundError(Exception):
+    """Raised when a session is not found."""
+
+
+class SuspiciousSessionError(Exception):
+    """Raised when session state indicates a possible attack or bug."""
+
+
+class SessionState(str, Enum):
+    """Add-on authentication session lifecycle states."""
+
+    PENDING = "pending"
+    AUTHENTICATED = "authenticated"
+
+
+class TransitTokenState(str, Enum):
+    """Transit token lifecycle states; CONSUMED is retained to detect replay."""
+
+    PENDING = "pending"
+    CONSUMED = "consumed"
+
+
+class TokenExchangeService:
+    """Manage temporary authentication sessions for add-on JWT token exchange."""
+
+    def __init__(self):
+        """Build the underlying JWT service and validate required settings."""
+
+        if not settings.ADDONS_CSRF_SECRET:
+            raise ImproperlyConfigured("CSRF Secret is required.")
+
+        if not settings.ADDONS_TOKEN_SCOPE:
+            raise ImproperlyConfigured("Token scope must be defined.")
+
+        self._token_service = JwtTokenService(
+            secret_key=settings.ADDONS_TOKEN_SECRET_KEY,
+            algorithm=settings.ADDONS_TOKEN_ALG,
+            issuer=settings.ADDONS_TOKEN_ISSUER,
+            audience=settings.ADDONS_TOKEN_AUDIENCE,
+            expiration_seconds=settings.ADDONS_TOKEN_TTL,
+            token_type=settings.ADDONS_TOKEN_TYPE,
+        )
+
+    @staticmethod
+    def _cache_key(prefix: str, token: str) -> str:
+        """Build a namespaced cache key: ``addons_{prefix}_{token}``."""
+        return f"addons_{prefix}_{token}"
+
+    @staticmethod
+    def _derive_csrf_token(session_id: str) -> str:
+        """Derive the CSRF token as HMAC-SHA256(session_id) under ADDONS_CSRF_SECRET."""
+        return hmac.new(
+            settings.ADDONS_CSRF_SECRET.encode("utf-8"),
+            session_id.encode("utf-8"),
+            hashlib.sha256,
+        ).hexdigest()
+
+    @staticmethod
+    def _validate_session_not_expired(session_data: dict) -> int:
+        """Return remaining seconds until expiry, or raise if missing/malformed/expired."""
+        expires_at_str = session_data.get("expires_at")
+        if expires_at_str is None:
+            raise SessionDataError("Invalid session data: missing expiration.")
+
+        try:
+            expires_at = datetime.fromisoformat(expires_at_str)
+        except ValueError as e:
+            raise SessionDataError("Invalid session data: malformed expiration.") from e
+
+        remaining_seconds = int(
+            (expires_at - datetime.now(timezone.utc)).total_seconds()
+        )
+
+        if remaining_seconds <= 0:
+            raise SessionExpiredError("Session expired.")
+
+        return remaining_seconds
+
+    def _generate_session_id(self) -> str:
+        """Generate a high-entropy URL-safe session_id."""
+        return secrets.token_urlsafe(settings.ADDONS_RANDOM_TOKEN_BYTE_LENGTH)
+
+    def _generate_transit_token(self) -> str:
+        """Generate a high-entropy URL-safe transit token."""
+        return secrets.token_urlsafe(settings.ADDONS_RANDOM_TOKEN_BYTE_LENGTH)
+
+    def init_session(self) -> tuple[str, str, str]:
+        """Create a new pending session and its transit binding.
+
+        Returns:
+            (transit_token, session_id, csrf_token)
+        """
+        session_id = self._generate_session_id()
+        transit_token = self._generate_transit_token()
+        csrf_token = self._derive_csrf_token(session_id)
+
+        expires_at = (
+            datetime.now(timezone.utc) + timedelta(seconds=settings.ADDONS_SESSION_TTL)
+        ).isoformat()
+
+        session_data = {
+            "state": SessionState.PENDING,
+            "expires_at": expires_at,
+            "transit_token": transit_token,
+        }
+
+        cache.set(
+            self._cache_key(settings.ADDONS_CACHE_PREFIX_SESSION, session_id),
+            session_data,
+            settings.ADDONS_SESSION_TTL,
+        )
+
+        transit_token_data = {
+            "session_id": session_id,
+            "state": TransitTokenState.PENDING,
+        }
+
+        cache.set(
+            self._cache_key(settings.ADDONS_CACHE_PREFIX_TRANSIT, transit_token),
+            transit_token_data,
+            settings.ADDONS_TRANSIT_TOKEN_TTL,
+        )
+
+        return transit_token, session_id, csrf_token
+
+    def verify_csrf(self, session_id: str, submitted_csrf: str) -> None:
+        """Constant-time verify submitted_csrf against HMAC(session_id). Raise on mismatch."""
+        expected_csrf = self._derive_csrf_token(session_id)
+        if not hmac.compare_digest(expected_csrf, submitted_csrf):
+            raise CSRFTokenError("Invalid CSRF token.")
+
+    def consume_transit_token(self, transit_token: str) -> str:
+        """Mark transit token consumed and return its session_id.
+
+        A replay (second consume) evicts the session as a security cleanup and raises.
+
+        Raises:
+            TransitTokenError: If token is unknown, expired, or already consumed.
+        """
+        cache_key = self._cache_key(settings.ADDONS_CACHE_PREFIX_TRANSIT, transit_token)
+
+        transit_token_data = cache.get(cache_key)
+
+        if transit_token_data is None:
+            # Indistinguishable from here: either the token was never issued (attacker
+            # probing or client bug) or it was issued but expired before consumption.
+            logger.warning(
+                "Transit token not found in cache (unknown or expired).",
+            )
+            raise TransitTokenError("Invalid or expired transit token.")
+
+        state = transit_token_data.get("state", None)
+        session_id = transit_token_data.get("session_id", None)
+
+        if not session_id:
+            logger.warning("Transit token data missing session_id.")
+            raise TransitTokenError("Invalid transit token.")
+
+        if state == TransitTokenState.CONSUMED:
+            logger.warning(
+                "Replay on session %s",
+                session_id,
+            )
+
+            # Security cleanup: a replay attempt means the transit token leaked
+            # (or an attacker is probing). Evict the session so the authenticated
+            # tokens — if they exist — can no longer be polled.
+            cache.delete(
+                self._cache_key(settings.ADDONS_CACHE_PREFIX_SESSION, session_id)
+            )
+
+            raise TransitTokenError("Transit token already consumed.")
+
+        new_transit_token_data = {
+            "state": TransitTokenState.CONSUMED,
+            "session_id": session_id,
+        }
+
+        cache.set(
+            cache_key,
+            new_transit_token_data,
+            settings.ADDONS_SESSION_TTL,
+        )
+
+        return session_id
+
+    @staticmethod
+    def is_session_pending(session_data: dict) -> bool:
+        """Return True if the public session dict is still in the pending state."""
+        return session_data.get("state") == SessionState.PENDING
+
+    def _get_session_data(self, session_id: str) -> dict:
+        """Fetch raw session data from cache, or raise SessionNotFoundError."""
+
+        if not session_id:
+            raise SessionNotFoundError("Session not found.")
+
+        data = cache.get(
+            self._cache_key(settings.ADDONS_CACHE_PREFIX_SESSION, session_id)
+        )
+        if data is None:
+            raise SessionNotFoundError("Session not found.")
+        return data
+
+    def get_session(self, session_id: str) -> dict:
+        """Return the public session view; evict the session on authenticated read.
+
+        Raises:
+            SessionNotFoundError: If session is not found.
+            SessionDataError: If session data is missing the state field.
+        """
+
+        # raises if session is not found
+        session_data = self._get_session_data(session_id)
+
+        if "state" not in session_data:
+            raise SessionDataError("Invalid session data: missing state field.")
+
+        # One-time read: clear both bindings for authenticated sessions
+        if session_data["state"] == SessionState.AUTHENTICATED:
+            cache.delete(
+                self._cache_key(settings.ADDONS_CACHE_PREFIX_SESSION, session_id)
+            )
+
+        # Return public fields only
+        return {k: v for k, v in session_data.items() if k in _PUBLIC_SESSION_FIELDS}
+
+    def _validate_transit_token_state(self, session_data: dict) -> None:
+        """Assert the session's transit token exists in cache and is in CONSUMED state.
+
+        Raises:
+            SessionDataError: session_data is missing the transit_token field.
+            SuspiciousSessionError: transit entry is missing, or still pending (flow skipped).
+        """
+
+        transit_token = session_data.get("transit_token", None)
+        if transit_token is None:
+            raise SessionDataError("Invalid session data: missing transit_token field.")
+
+        transit_token_data = cache.get(
+            self._cache_key(settings.ADDONS_CACHE_PREFIX_TRANSIT, transit_token)
+        )
+
+        if transit_token_data is None:
+            logger.warning("Transit token missing when setting access token.")
+            raise SuspiciousSessionError("Transit token not found.")
+
+        if transit_token_data.get("state") != TransitTokenState.CONSUMED:
+            logger.warning("Access token requested without completing transit flow.")
+            raise SuspiciousSessionError("Transit token not consumed.")
+
+    def set_access_token(self, user: User, session_id: str) -> None:
+        """Authenticate a pending session by minting a JWT and storing it on the session.
+
+        Non-pending sessions are evicted as a security cleanup before raising.
+
+        Raises:
+            SessionNotFoundError: If session doesn't exist.
+            SessionDataError: If session data is malformed.
+            SessionExpiredError: If session has expired.
+            SuspiciousSessionError: If session is not pending or transit wasn't consumed.
+        """
+
+        # raises if session is not found
+        session_data = self._get_session_data(session_id)
+
+        if session_data.get("state") != SessionState.PENDING:
+            logger.warning(
+                "Session's state is not pending. Suspicious.",
+            )
+            # Security cleanup: evict the session so any cached tokens cannot be polled.
+            cache.delete(
+                self._cache_key(settings.ADDONS_CACHE_PREFIX_SESSION, session_id)
+            )
+            raise SuspiciousSessionError("Session is not in pending state.")
+
+        # raises if transit_token is invalid
+        try:
+            self._validate_transit_token_state(session_data)
+        except SuspiciousSessionError:
+            # Security cleanup: evict the session.
+            cache.delete(
+                self._cache_key(settings.ADDONS_CACHE_PREFIX_SESSION, session_id)
+            )
+            raise
+
+        # raises if session is expired
+        remaining_seconds = self._validate_session_not_expired(session_data)
+
+        response = self._token_service.generate_jwt(user, settings.ADDONS_TOKEN_SCOPE)
+
+        new_data = {
+            "access_token": response["access_token"],
+            "token_type": response["token_type"],
+            "expires_in": response["expires_in"],
+            "scope": response["scope"],
+            "expires_at": session_data["expires_at"],
+            "state": SessionState.AUTHENTICATED,
+        }
+
+        cache.set(
+            self._cache_key(settings.ADDONS_CACHE_PREFIX_SESSION, session_id),
+            new_data,
+            remaining_seconds,
+        )

src/backend/core/addons/viewsets.py

@@ -0,0 +1,229 @@
+"""Add-ons API endpoints"""
+
+from logging import getLogger
+
+from django.conf import settings
+from django.core.exceptions import SuspiciousOperation
+
+from rest_framework import decorators, viewsets
+from rest_framework import (
+    response as drf_response,
+)
+from rest_framework import status as drf_status
+
+from core.addons.service import (
+    CSRFTokenError,
+    SessionDataError,
+    SessionExpiredError,
+    SessionNotFoundError,
+    SuspiciousSessionError,
+    TokenExchangeService,
+    TransitTokenError,
+)
+from core.api.feature_flag import FeatureFlag
+from core.api.permissions import IsAuthenticated
+
+logger = getLogger(__name__)
+
+
+class SessionViewSet(viewsets.ViewSet):
+    """ViewSet for managing add-on authentication sessions via token exchange.
+
+    Implements a three-step flow that lets a third-party add-on (running in an
+    embedded iframe) obtain an access token without exposing it to client-side
+    JavaScript:
+
+    1. /init: the add-on opens a session and receives a short-lived transit
+       token (used to bootstrap the OAuth-style exchange in a dialog) and a
+       CSRF token. The opaque session id is stored in an HttpOnly, Secure,
+       SameSite=None cookie so it can accompany cross-origin polls.
+    2. /poll: the add-on polls until the session transitions from pending to
+       authenticated. On the terminal read, the session payload (access
+       token, token type, expiry, etc.) is returned, the session is evicted
+       server-side, and the session cookie is cleared so the tokens can be
+       retrieved exactly once.
+    3. /exchange: called from the post-login callback page on our own domain,
+       after the user has authenticated in a dialog opened by the addon. The
+       transit token (carried client-side via postMessage + sessionStorage)
+       is redeemed here for the authenticated user's access token, which is
+       stored server-side against the session. Requires an authenticated
+       user — that user is whose access token gets bound to the session.
+
+    /init and /poll authenticate the caller through the session cookie +
+    CSRF token pair alone — no user login is required, since the whole point
+    of the flow is to bootstrap one. /exchange, by contrast, requires an
+    authenticated user and does not use the addonsSid cookie.
+    """
+
+    throttle_classes = []
+
+    @decorators.action(
+        detail=False,
+        methods=["POST"],
+        url_path="init",
+        authentication_classes=[],
+        permission_classes=[],
+    )
+    @FeatureFlag.require("addons")
+    def init(self, request):
+        """Open a new add-on authentication session.
+
+        Creates a fresh session server-side and returns the credentials the
+        add-on needs to drive the rest of the flow.
+        """
+
+        transit_token, session_id, csrf_token = TokenExchangeService().init_session()
+
+        response = drf_response.Response(
+            {"transit_token": transit_token, "csrf_token": csrf_token},
+            status=drf_status.HTTP_201_CREATED,
+        )
+
+        # SameSite=None allows the cookie to be sent on cross-origin requests,
+        # which is required because the /poll endpoint is called from an iframe
+        # embedded in a third-party site. Secure=True is mandatory when SameSite=None.
+        # HttpOnly prevents JS access, so the cookie can only be read by the server.
+        response.set_cookie(
+            key=settings.ADDONS_SESSION_ID_COOKIE,
+            value=session_id,
+            max_age=settings.ADDONS_SESSION_TTL,
+            httponly=True,
+            secure=True,
+            samesite="None",
+        )
+
+        return response
+
+    @decorators.action(
+        detail=False,
+        methods=["POST"],
+        url_path="poll",
+        authentication_classes=[],
+        permission_classes=[],
+    )
+    @FeatureFlag.require("addons")
+    def poll(self, request):
+        """Poll a session for its current state and, if terminal, consume it.
+
+        Authenticates the caller using the addonsSid cookie (set by
+        /init) together with the X-CSRFToken header, which must match
+        the CSRF token issued for that session. The session id alone is not
+        sufficient — both must be presented and must correspond.
+
+        Behavior depends on the session's current state:
+
+        - **Pending**: the token exchange has not yet completed. Returns
+          202 Accepted with `{"state": "pending"}`. The cookie is preserved
+          so the add-on can keep polling.
+        - **Authenticated** (or any other terminal state): returns 200 OK
+          with the session payload (access token, token type, expiry, etc.)
+          and clears the `addonsSid` cookie. The session is also evicted
+          server-side on this terminal read, so the tokens can be retrieved
+          exactly once.
+
+        A CSRF mismatch is treated as a `SuspiciousOperation` rather than a
+        normal 4xx, so it is logged by Django's security middleware and
+        surfaced as a 400 without leaking which check failed.
+        """
+
+        session_id = request.COOKIES.get(settings.ADDONS_SESSION_ID_COOKIE)
+        submitted_csrf = request.headers.get("X-CSRFToken")
+
+        if not session_id:
+            return drf_response.Response(
+                {"detail": "Missing credentials."},
+                status=drf_status.HTTP_401_UNAUTHORIZED,
+            )
+
+        if not submitted_csrf:
+            return drf_response.Response(
+                {"detail": "Missing CSRF token."},
+                status=drf_status.HTTP_400_BAD_REQUEST,
+            )
+
+        service = TokenExchangeService()
+
+        try:
+            service.verify_csrf(session_id, submitted_csrf)
+        except CSRFTokenError as e:
+            raise SuspiciousOperation(str(e)) from e
+
+        try:
+            session = service.get_session(session_id)
+        except SessionNotFoundError:
+            return drf_response.Response(
+                {"detail": "Session not found."},
+                status=drf_status.HTTP_404_NOT_FOUND,
+            )
+        except SessionDataError:
+            return drf_response.Response(
+                {"detail": "Invalid or expired session."},
+                status=drf_status.HTTP_400_BAD_REQUEST,
+            )
+
+        if service.is_session_pending(session):
+            return drf_response.Response(
+                {"state": "pending"}, status=drf_status.HTTP_202_ACCEPTED
+            )
+
+        response = drf_response.Response(session, status=drf_status.HTTP_200_OK)
+        response.delete_cookie(
+            key=settings.ADDONS_SESSION_ID_COOKIE,
+            samesite="None",
+        )
+
+        return response
+
+    @decorators.action(
+        detail=False,
+        methods=["POST"],
+        url_path="exchange",
+        permission_classes=[IsAuthenticated],
+    )
+    @FeatureFlag.require("addons")
+    def exchange(self, request):
+        """Redeem a transit token for an access token bound to the current user.
+
+        Called from the post-OIDC callback page on our own domain. The transit
+        token was issued by /init, passed to the authentication dialog via
+        postMessage, stashed in sessionStorage, and read back by this page
+        after login completes.
+
+        The authenticated user (request.user) is whose access token gets stored
+        against the session. On success, the addon's next /poll will transition
+        from pending to authenticated and receive the token payload.
+
+        Transit tokens are single-use: a replayed token is rejected with 400.
+        """
+
+        transit_token = request.data.get("transit_token")
+        if not transit_token:
+            return drf_response.Response(
+                {"detail": "Missing transit_token."},
+                status=drf_status.HTTP_400_BAD_REQUEST,
+            )
+
+        service = TokenExchangeService()
+
+        try:
+            session_id = service.consume_transit_token(transit_token)
+        except TransitTokenError:
+            return drf_response.Response(
+                {"detail": "Invalid or expired transit token."},
+                status=drf_status.HTTP_400_BAD_REQUEST,
+            )
+
+        try:
+            service.set_access_token(request.user, session_id)
+        except SessionNotFoundError:
+            return drf_response.Response(
+                {"detail": "Session not found."},
+                status=drf_status.HTTP_404_NOT_FOUND,
+            )
+        except (SessionDataError, SessionExpiredError, SuspiciousSessionError):
+            return drf_response.Response(
+                {"detail": "Invalid or expired session."},
+                status=drf_status.HTTP_400_BAD_REQUEST,
+            )
+
+        return drf_response.Response({"status": "ok"}, status=drf_status.HTTP_200_OK)

src/backend/core/admin.py

@@ -3,17 +3,55 @@
 from django import forms
 from django.contrib import admin, messages
 from django.contrib.auth import admin as auth_admin
+from django.db import transaction
+from django.utils.html import format_html
 from django.utils.translation import gettext_lazy as _
 
 from core.recording.event import notification
 
 from . import models
+from .tasks.file import process_file_deletion
+from .utils import generate_download_file_url
+
+
+def hard_delete_file(file):
+    """Hard delete a file, soft deleting it first when needed."""
+    if file.deleted_at is None:
+        file.soft_delete()
+    file.hard_delete()
+    transaction.on_commit(lambda: process_file_deletion.delay(file.id))
+
+
+class FileInlineFormSet(forms.BaseInlineFormSet):
+    """Inline formset overriding delete behavior for files."""
+
+    def delete_existing(self, obj, commit=True):
+        """Hard delete files instead of calling model.delete()."""
+        hard_delete_file(obj)
+
+
+class FileInline(admin.TabularInline):
+    """Inline class for the File model."""
+
+    model = models.File
+    formset = FileInlineFormSet
+    fk_name = "creator"
+    extra = 0
+    fields = ("id", "title", "type", "upload_state", "created_at")
+    readonly_fields = ("id", "created_at", "upload_state", "type")
+    show_change_link = True
+
+    def get_queryset(self, request):
+        """Hide hard deleted files in the inline."""
+        return super().get_queryset(request).filter(hard_deleted_at__isnull=True)
 
 
 @admin.register(models.User)
 class UserAdmin(auth_admin.UserAdmin):
     """Admin class for the User model"""
 
+    inlines = (FileInline,)
+
     fieldsets = (
         (
             None,
@@ -97,6 +135,136 @@ class UserAdmin(auth_admin.UserAdmin):
     search_fields = ("id", "sub", "admin_email", "email", "full_name")
 
 
+@admin.register(models.File)
+class FileAdmin(admin.ModelAdmin):
+    """Admin class for the File model."""
+
+    list_display = (
+        "id",
+        "title",
+        "type",
+        "creator",
+        "upload_state",
+        "deleted_at",
+        "hard_deleted_at",
+        "created_at",
+        "updated_at",
+    )
+    list_filter = (
+        "type",
+        "upload_state",
+        "created_at",
+        "updated_at",
+        "deleted_at",
+        "hard_deleted_at",
+    )
+    search_fields = (
+        "id",
+        "title",
+        "filename",
+        "mimetype",
+        "description",
+        "creator__email",
+        "creator__admin_email",
+        "creator__full_name",
+    )
+    ordering = ("-created_at",)
+    readonly_fields = (
+        "id",
+        "created_at",
+        "updated_at",
+        "deleted_at",
+        "hard_deleted_at",
+        "description",
+        "malware_detection_info",
+        "is_ready",
+        "preview_url",
+        "extension",
+        "key_base",
+        "file_key",
+        "upload_state",
+        "type",
+        "mimetype",
+        "size",
+    )
+    autocomplete_fields = ("creator",)
+    fieldsets = (
+        (
+            None,
+            {
+                "fields": (
+                    "id",
+                    "title",
+                    "type",
+                    "creator",
+                    "filename",
+                    "upload_state",
+                )
+            },
+        ),
+        (
+            _("Content"),
+            {
+                "fields": (
+                    "mimetype",
+                    "size",
+                    "description",
+                    "malware_detection_info",
+                )
+            },
+        ),
+        (
+            _("Deletion"),
+            {
+                "fields": (
+                    "deleted_at",
+                    "hard_deleted_at",
+                )
+            },
+        ),
+        (
+            _("Derived info"),
+            {
+                "fields": (
+                    "is_ready",
+                    "extension",
+                    "key_base",
+                    "file_key",
+                    "preview_url",
+                )
+            },
+        ),
+        (_("Timestamps"), {"fields": ("created_at", "updated_at")}),
+    )
+
+    @admin.display(description=_("File preview"))
+    def preview_url(self, obj):
+        """Return a clickable preview URL for the file."""
+        if not obj.is_ready:
+            return "-"
+        url = generate_download_file_url(obj, expires_in=60 * 60)
+
+        return format_html(
+            '<a href="{}" target="_blank" rel="noopener noreferrer">Open File</a>', url
+        )
+
+    def get_queryset(self, request):
+        """Hide hard deleted files in admin listing and lookups."""
+        return super().get_queryset(request).filter(hard_deleted_at__isnull=True)
+
+    def delete_model(self, request, obj):
+        """Hard delete instead of calling model.delete()."""
+        hard_delete_file(obj)
+
+    def delete_queryset(self, request, queryset):
+        """Hard delete all selected files."""
+        for file in queryset:
+            hard_delete_file(file)
+
+    def has_add_permission(self, request):
+        return False
+
+
 class ResourceAccessInline(admin.TabularInline):
     """Admin class for the room user access model"""
 
@@ -197,6 +365,38 @@ def resend_notification(modeladmin, request, queryset):  # pylint: disable=unuse
         )
 
 
+@admin.action(description=_("Mark selected recordings as 'Failed to Stop'"))
+def mark_as_failed_to_stop(modeladmin, request, queryset):
+    """Force selected recordings status to failed_to_stop."""
+
+    eligible_statuses = [
+        models.RecordingStatusChoices.ACTIVE,
+        models.RecordingStatusChoices.INITIATED,
+        models.RecordingStatusChoices.STOPPED,
+    ]
+
+    eligible = queryset.filter(status__in=eligible_statuses)
+    skipped = queryset.exclude(status__in=eligible_statuses).count()
+
+    updated = eligible.update(status=models.RecordingStatusChoices.FAILED_TO_STOP)
+
+    if updated > 0:
+        modeladmin.message_user(
+            request,
+            _("%(count)s recording(s) successfully marked as 'Failed to Stop'.")
+            % {"count": updated},
+            level=messages.SUCCESS,
+        )
+
+    if skipped > 0:
+        modeladmin.message_user(
+            request,
+            _("Skipped %(count)s recording(s) with an ineligible status.")
+            % {"count": skipped},
+            level=messages.WARNING,
+        )
+
+
 @admin.register(models.Recording)
 class RecordingAdmin(admin.ModelAdmin):
     """Recording admin interface declaration."""
@@ -224,7 +424,7 @@ class RecordingAdmin(admin.ModelAdmin):
         "updated_at",
         "worker_id",
     )
-    actions = [resend_notification]
+    actions = [resend_notification, mark_as_failed_to_stop]
 
     def get_queryset(self, request):
         """Optimize queries by prefetching related access and user data to avoid N+1 queries."""
@@ -276,7 +476,7 @@ class ApplicationAdmin(admin.ModelAdmin):
 
     form = ApplicationAdminForm
 
-    list_display = ("id", "name", "client_id", "get_scopes_display")
+    list_display = ("id", "name", "client_id", "get_scopes_display", "is_active")
     fields = [
         "name",
         "id",
@@ -285,6 +485,7 @@ class ApplicationAdmin(admin.ModelAdmin):
         "scopes",
         "client_id",
         "client_secret",
+        "is_active",
     ]
     readonly_fields = ["id", "created_at", "updated_at"]
     inlines = [ApplicationDomainInline]

src/backend/core/api/__init__.py

@@ -8,6 +8,8 @@ from rest_framework import views as drf_views
 from rest_framework.decorators import api_view
 from rest_framework.response import Response
 
+from core.utils import build_telephony_config
+
 
 def exception_handler(exc, context):
     """Handle Django ValidationError as an accepted exception.
@@ -43,13 +45,22 @@ def get_frontend_configuration(request):
             "expiration_days": settings.RECORDING_EXPIRATION_DAYS,
             "max_duration": settings.RECORDING_MAX_DURATION,
         },
-        "telephony": {
-            "enabled": settings.ROOM_TELEPHONY_ENABLED,
-            "phone_number": settings.ROOM_TELEPHONY_PHONE_NUMBER
-            if settings.ROOM_TELEPHONY_ENABLED
-            else None,
-            "default_country": settings.ROOM_TELEPHONY_DEFAULT_COUNTRY,
+        "background_image": {
+            "upload_is_enabled": settings.FILE_UPLOAD_ENABLED,
+            "max_count_by_user": settings.FILE_UPLOAD_RESTRICTIONS["background_image"][
+                "max_count_by_user"
+            ],
+            "max_size": settings.FILE_UPLOAD_RESTRICTIONS["background_image"][
+                "max_size"
+            ],
+            "allowed_extensions": settings.FILE_UPLOAD_RESTRICTIONS["background_image"][
+                "allowed_extensions"
+            ],
+            "allowed_mimetypes": settings.FILE_UPLOAD_RESTRICTIONS["background_image"][
+                "allowed_mimetypes"
+            ],
         },
+        "telephony": build_telephony_config(),
         "subtitle": {"enabled": settings.ROOM_SUBTITLE_ENABLED},
         "livekit": {
             "url": settings.LIVEKIT_CONFIGURATION["url"],

src/backend/core/api/feature_flag.py

@@ -13,6 +13,9 @@ class FeatureFlag:
         "recording": "RECORDING_ENABLE",
         "storage_event": "RECORDING_STORAGE_EVENT_ENABLE",
         "subtitle": "ROOM_SUBTITLE_ENABLED",
+        "file_upload": "FILE_UPLOAD_ENABLED",
+        "addons": "ADDONS_ENABLED",
+        "application": "APPLICATION_ENABLED",
     }
 
     @classmethod

src/backend/core/api/filters.py

@@ -0,0 +1,67 @@
+"""API filters for meet' core application."""
+
+from django.utils.translation import gettext_lazy as _
+
+import django_filters
+from django_filters import BooleanFilter
+
+from core import models
+
+
+class FileFilter(django_filters.FilterSet):
+    """
+    Custom filter for filtering files.
+    """
+
+    class Meta:
+        model = models.File
+        fields = ["type"]
+
+
+class ListFileFilter(FileFilter):
+    """Filter class dedicated to the file viewset list method."""
+
+    is_creator_me = django_filters.BooleanFilter(
+        method="filter_is_creator_me", label=_("Creator is me")
+    )
+
+    is_deleted = BooleanFilter(field_name="deleted_at", method="filter_is_deleted")
+
+    class Meta:
+        model = models.File
+        fields = ["is_creator_me", "type", "upload_state", "is_deleted"]
+
+    def filter_is_deleted(self, queryset, name, value):
+        """
+        Filter files based on whether they are deleted or not.
+
+        Example:
+            - /api/v1.0/files/?is_deleted=false
+                → Filters files that were not deleted
+        """
+        if value is None:
+            return queryset
+
+        lookup = "__".join([name, "isnull"])
+        return queryset.filter(**{lookup: not value})
+
+    # pylint: disable=unused-argument
+    def filter_is_creator_me(self, queryset, name, value):
+        """
+        Filter files based on the `creator` being the current user.
+
+        Example:
+            - /api/v1.0/files/?is_creator_me=true
+                → Filters files created by the logged-in user
+            - /api/v1.0/files/?is_creator_me=false
+                → Filters files created by other users
+        """
+        user = self.request.user
+
+        if not user.is_authenticated:
+            return queryset
+
+        if value:
+            return queryset.filter(creator=user)
+
+        return queryset.exclude(creator=user)

src/backend/core/api/permissions.py

@@ -1,5 +1,8 @@
 """Permission handlers for the Meet core app."""
 
+from django.conf import settings
+from django.http import Http404
+
 from rest_framework import permissions
 
 from ..models import RoleChoices
@@ -106,3 +109,60 @@ class HasLiveKitRoomAccess(permissions.BasePermission):
         if not request.auth or not hasattr(request.auth, "video"):
             return False
         return request.auth.video.room == str(obj.id)
+
+
+class FilePermission(IsAuthenticated):
+    """
+    Permissions applying to the file API endpoint.
+    Handling soft deletions specificities
+    """
+
+    def has_permission(self, request, view):
+        """Allow access only to authenticated users."""
+        if not settings.FILE_UPLOAD_ENABLED:
+            raise Http404
+
+        return super().has_permission(request, view)
+
+    def has_object_permission(self, request, view, obj):
+        """
+        Return a 404 on deleted files or if the user is not the owner
+        """
+
+        if obj.deleted_at is not None or obj.hard_deleted_at is not None:
+            raise Http404
+
+        if obj.creator != request.user:
+            raise Http404
+
+        return obj.get_abilities(request.user).get(view.action, False)
+
+
+class CanMuteParticipant(permissions.BasePermission):
+    """
+    Grant muting rights based on role or room configuration.
+
+    - Admins and owners can always mute.
+    - When `everyone_can_mute` is enabled on the room, any participant
+      currently in the room (proven by a valid LiveKit token for that room)
+      can mute.
+    """
+
+    def has_object_permission(self, request, view, obj):
+        """Check if the requesting user is allowed to mute a participant in the given room."""
+
+        is_livekit_token_auth = request.auth and hasattr(request.auth, "video")
+
+        # Always allow admins/owners when authenticated with session cookie
+        if not is_livekit_token_auth and obj.is_administrator_or_owner(request.user):
+            return True
+
+        everyone_can_mute = obj.configuration.get("everyone_can_mute", True)
+        if not everyone_can_mute:
+            return False
+
+        if not is_livekit_token_auth:
+            return False
+
+        # LiveKit token scoped to this room
+        return request.auth.video.room == str(obj.id)

src/backend/core/api/serializers.py

@@ -1,20 +1,28 @@
 """Client serializers for the Meet core app."""
 
 # pylint: disable=abstract-method,no-name-in-module
+import logging
+from os.path import splitext
 from typing import Literal
+from urllib.parse import quote
 
 from django.conf import settings
 from django.core.exceptions import SuspiciousOperation
+
+# pylint: disable=abstract-method,no-name-in-module
 from django.utils.translation import gettext_lazy as _
 
 from django_pydantic_field.rest_framework import SchemaField
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_serializer
+from pydantic import ValidationError as PydanticValidationError
 from rest_framework import serializers
 from rest_framework.exceptions import PermissionDenied
 from timezone_field.rest_framework import TimeZoneSerializerField
 
 from core import models, utils
 
+logger = logging.getLogger(__name__)
+
 
 class UserSerializer(serializers.ModelSerializer):
     """Serialize users."""
@@ -27,6 +35,15 @@ class UserSerializer(serializers.ModelSerializer):
         read_only_fields = ["id", "email", "full_name", "short_name"]
 
 
+class UserLightSerializer(serializers.ModelSerializer):
+    """Serialize users with limited fields."""
+
+    class Meta:
+        model = models.User
+        fields = ["id", "full_name", "short_name"]
+        read_only_fields = ["id", "full_name", "short_name"]
+
+
 class ResourceAccessSerializerMixin:
     """
     A serializer mixin to share controlling that the logged-in user submitting a room access object
@@ -115,6 +132,16 @@ class RoomSerializer(serializers.ModelSerializer):
         fields = ["id", "name", "slug", "configuration", "access_level", "pin_code"]
         read_only_fields = ["id", "slug", "pin_code"]
 
+    def validate_configuration(self, value):
+        """Validate room configuration against the RoomConfiguration schema."""
+        if value is None or value == {}:
+            return value
+        try:
+            RoomConfiguration.model_validate(value)
+        except PydanticValidationError as e:
+            raise serializers.ValidationError(e.errors()) from e
+        return value
+
     def to_representation(self, instance):
         """
         Add users only for administrator users.
@@ -139,11 +166,6 @@ class RoomSerializer(serializers.ModelSerializer):
             )
             output["accesses"] = access_serializer.data
 
-        configuration = output["configuration"]
-
-        if not is_admin_or_owner:
-            del output["configuration"]
-
         should_access_room = (
             (
                 instance.access_level == models.RoomAccessLevel.TRUSTED
@@ -160,7 +182,7 @@ class RoomSerializer(serializers.ModelSerializer):
                 room_id=room_id,
                 user=request.user,
                 username=username,
-                configuration=configuration,
+                configuration=output["configuration"],
                 is_admin_or_owner=is_admin_or_owner,
             )
         else:
@@ -216,11 +238,14 @@ class RecordingOptions(BaseModel):
             When `None`, falls back to the application default.
         original_mode: The original recording mode before any override.
             Must be one of the valid RecordingModeChoices values when provided.
+        collect_metadata: Whether to collect additional metadata during recording.
+            When `None`, no metadata are collected.
 
     """
 
     language: str | None = None
     transcribe: bool | None = None
+    collect_metadata: bool | None = None
     original_mode: Literal["screen_recording", "transcript"] | None = None
 
     model_config = {"extra": "forbid"}
@@ -287,6 +312,21 @@ class MuteParticipantSerializer(BaseParticipantsManagementSerializer):
     )
 
 
+TrackSource = Literal["camera", "microphone", "screen_share", "screen_share_audio"]
+
+
+class RoomConfiguration(BaseModel):
+    """Validate room configuration structure.
+
+    Unknown fields are rejected.
+    """
+
+    can_publish_sources: list[TrackSource] | None = None
+    everyone_can_mute: bool | None = None
+
+    model_config = {"extra": "forbid"}
+
+
 class ParticipantPermission(BaseModel):
     """Mirror the LiveKit ParticipantPermission protobuf.
 
@@ -297,9 +337,7 @@ class ParticipantPermission(BaseModel):
     can_subscribe: bool | None = None
     can_publish: bool | None = None
     can_publish_data: bool | None = None
-    can_publish_sources: list[int] = Field(
-        default_factory=list
-    )  # TrackSource enum values
+    can_publish_sources: list[TrackSource] = Field(default_factory=list)
     hidden: bool | None = None
     recorder: bool | None = None
     can_update_metadata: bool | None = None
@@ -308,6 +346,10 @@ class ParticipantPermission(BaseModel):
 
     model_config = {"extra": "forbid"}
 
+    @field_serializer("can_publish_sources")
+    def _serialize_sources(self, sources: list[str]) -> list[str]:
+        return [s.upper() for s in sources]
+
 
 class UpdateParticipantSerializer(BaseParticipantsManagementSerializer):
     """Validate participant update data."""
@@ -350,14 +392,6 @@ class UpdateParticipantSerializer(BaseParticipantsManagementSerializer):
                 f"Setting the following participant permissions is not allowed: "
                 f"{', '.join(suspicious_fields)}."
             )
-        if permission.can_subscribe_metrics is not None:
-            raise serializers.ValidationError(
-                {
-                    "permission": {
-                        "can_subscribe_metrics": "This permission is not implemented."
-                    }
-                }
-            )
 
         return permission
 
@@ -377,3 +411,155 @@ class UpdateParticipantSerializer(BaseParticipantsManagementSerializer):
             )
 
         return attrs
+
+
+class ListFileSerializer(serializers.ModelSerializer):
+    """Serialize File model for the API."""
+
+    url = serializers.SerializerMethodField(read_only=True)
+    creator = UserLightSerializer(read_only=True)
+    abilities = serializers.SerializerMethodField(read_only=True)
+
+    class Meta:
+        model = models.File
+        fields = [
+            "id",
+            "created_at",
+            "updated_at",
+            "title",
+            "type",
+            "creator",
+            "deleted_at",
+            "hard_deleted_at",
+            "filename",
+            "upload_state",
+            "mimetype",
+            "size",
+            "description",
+            "url",
+            "abilities",
+        ]
+        read_only_fields = [
+            "id",
+            "created_at",
+            "updated_at",
+            "creator",
+            "deleted_at",
+            "hard_deleted_at",
+            "filename",
+            "upload_state",
+            "mimetype",
+            "size",
+            "url",
+            "abilities",
+        ]
+
+    def get_url(self, obj):
+        """Return the URL of the file."""
+        if not obj.is_ready:
+            return None
+
+        return f"{settings.MEDIA_BASE_URL}{settings.MEDIA_URL}{quote(obj.file_key)}"
+
+    def get_abilities(self, file) -> dict:
+        """Return abilities of the logged-in user on the instance."""
+        request = self.context.get("request")
+        if not request:
+            return {}
+
+        return file.get_abilities(request.user)
+
+
+class FileSerializer(ListFileSerializer):
+    """Default serializer File model for the API."""
+
+    def create(self, validated_data):
+        raise NotImplementedError("Create method can not be used.")
+
+
+class CreateFileSerializer(ListFileSerializer):
+    """Serializer used to create a new file"""
+
+    title = serializers.CharField(max_length=255, required=False)
+    policy = serializers.SerializerMethodField()
+
+    class Meta:
+        model = models.File
+        fields = [*ListFileSerializer.Meta.fields, "policy"]
+        read_only_fields = [
+            *(
+                field
+                for field in ListFileSerializer.Meta.read_only_fields
+                if field != "filename"
+            ),
+            "policy",
+        ]
+
+    def get_fields(self):
+        """Force the id field to be writable."""
+        fields = super().get_fields()
+        fields["id"].read_only = False
+
+        return fields
+
+    def validate_id(self, value):
+        """Ensure the provided ID does not already exist when creating a new file."""
+        request = self.context.get("request")
+
+        # Only check this on POST (creation)
+        if request and models.File.objects.filter(id=value).exists():
+            raise serializers.ValidationError(
+                "A file with this ID already exists. You cannot override it.",
+                code="file_create_existing_id",
+            )
+
+        return value
+
+    def validate(self, attrs):
+        """Validate extension and fill title."""
+        # we run the default validation first to make sure the base data in attrs is ok
+        attrs = super().validate(attrs)
+
+        filename_root, ext = splitext(attrs["filename"])
+
+        if settings.FILE_UPLOAD_APPLY_RESTRICTIONS:
+            config_for_file_type = settings.FILE_UPLOAD_RESTRICTIONS[attrs["type"]]
+            if ext.lower() not in config_for_file_type["allowed_extensions"]:
+                logger.info(
+                    "create_item: file extension not allowed %s for filename %s",
+                    ext,
+                    attrs["filename"],
+                )
+                raise serializers.ValidationError(
+                    {"filename": _("This file extension is not allowed.")},
+                    code="item_create_file_extension_not_allowed",
+                )
+
+        # The title will be the filename if not provided
+        if not attrs.get("title", None):
+            attrs["title"] = filename_root
+
+        return attrs
+
+    def get_policy(self, file):
+        """Return the policy to use if the item is a file."""
+
+        if file.upload_state == models.FileUploadStateChoices.READY:
+            return None
+
+        return utils.generate_upload_policy(file)
+
+    def update(self, instance, validated_data):
+        raise NotImplementedError("Update method can not be used.")
+
+
+class RaiseHandSerializer(BaseValidationOnlySerializer):
+    """Serializer for raising or lowering a participant's hand in a room."""
+
+    raised = serializers.BooleanField()
+
+
+class RenameParticipantSerializer(BaseValidationOnlySerializer):
+    """Serializer for renaming a participant in a room."""
+
+    name = serializers.CharField(min_length=1, max_length=255, allow_blank=False)

src/backend/core/api/throttling.py

@@ -1,7 +1,9 @@
 """Throttling modules for the API."""
 
+from django.conf import settings
+
 from lasuite.drf.throttling import MonitoredThrottleMixin
-from rest_framework.throttling import AnonRateThrottle
+from rest_framework.throttling import AnonRateThrottle, UserRateThrottle
 from sentry_sdk import capture_message
 
 
@@ -14,11 +16,58 @@ class MonitoredAnonRateThrottle(MonitoredThrottleMixin, AnonRateThrottle):
     """Throttle for the monitored scoped rate throttle."""
 
 
+class MonitoredUserRateThrottle(MonitoredThrottleMixin, UserRateThrottle):
+    """Throttle for the monitored scoped rate throttle."""
+
+
+class RequestEntryAuthenticatedUserRateThrottle(MonitoredUserRateThrottle):
+    """Throttle authenticated user requesting room entry"""
+
+    scope = "request_entry"
+
+    def get_cache_key(self, request, view):
+        """Use the authenticated user ID as the throttle cache key."""
+
+        if request.user and not request.user.is_authenticated:
+            return None  # Defer to RequestEntryAnonRateThrottle for anonymous users.
+
+        return super().get_cache_key(request, view)
+
+
 class RequestEntryAnonRateThrottle(MonitoredAnonRateThrottle):
     """Throttle Anonymous user requesting room entry"""
 
     scope = "request_entry"
 
+    def get_cache_key(self, request, view):
+        """Use the lobby participant cookie ID as the throttle cache key.
+
+        Only throttle if a cookie is already set. If no cookie exists yet,
+        return None to skip throttling — the cookie will be set on the first
+        response, and throttling will apply from the second request onward.
+
+        Keying on the cookie rather than the IP address prevents penalising
+        multiple users behind the same NAT/proxy, and is consistent with how
+        LobbyService identifies participants.
+
+        Note: as per DRF documentation, application-level throttling is not a
+        security measure against brute-force or DoS attacks. This throttle exists
+        solely to guard against accidental hammering from buggy clients.
+        """
+
+        if request.user and request.user.is_authenticated:
+            return None  # Only throttle unauthenticated requests.
+
+        participant_id = request.COOKIES.get(settings.LOBBY_COOKIE_NAME)
+
+        if participant_id is None:
+            return None  # No throttling for cookieless requests
+
+        return self.cache_format % {
+            "scope": self.scope,
+            "ident": participant_id,
+        }
+
 
 class CreationCallbackAnonRateThrottle(MonitoredAnonRateThrottle):
     """Throttle Anonymous user requesting room generation callback"""

src/backend/core/api/viewsets.py

@@ -1,16 +1,29 @@
 """API endpoints"""
+# pylint: disable=too-many-lines
 
 import uuid
 from logging import getLogger
-from urllib.parse import urlparse
+from urllib.parse import unquote, urlparse
 
 from django.conf import settings
+from django.core.exceptions import ValidationError as DjangoValidationError
+from django.core.files.storage import default_storage
+from django.db import IntegrityError, transaction
 from django.db.models import Q
 from django.http import Http404
 from django.shortcuts import get_object_or_404
+from django.utils import timezone
 from django.utils.text import slugify
+from django.utils.translation import gettext_lazy as _
 
-from rest_framework import decorators, mixins, pagination, viewsets
+from django_filters import rest_framework as django_filters
+from rest_framework import (
+    decorators,
+    filters,
+    mixins,
+    pagination,
+    viewsets,
+)
 from rest_framework import (
     exceptions as drf_exceptions,
 )
@@ -20,17 +33,25 @@ from rest_framework import (
 from rest_framework import (
     status as drf_status,
 )
+from rest_framework.settings import api_settings
 
 from core import enums, models, utils
+from core.api.filters import ListFileFilter
+from core.enums import MEDIA_STORAGE_URL_PATTERN
 from core.recording.enums import FileExtension
 from core.recording.event.authentication import StorageEventAuthentication
 from core.recording.event.exceptions import (
     InvalidBucketError,
+    InvalidFilepathError,
     InvalidFileTypeError,
     ParsingEventDataError,
 )
 from core.recording.event.notification import notification_service
 from core.recording.event.parsers import get_parser
+from core.recording.services.metadata_collector import (
+    MetadataCollectorException,
+    MetadataCollectorService,
+)
 from core.recording.worker.exceptions import (
     RecordingStartError,
     RecordingStopError,
@@ -51,11 +72,18 @@ from core.services.lobby import (
     LobbyService,
 )
 from core.services.participants_management import (
+    ParticipantNotFoundException,
     ParticipantsManagement,
     ParticipantsManagementException,
 )
 from core.services.room_creation import RoomCreation
+from core.services.room_management import (
+    RoomManagement,
+    RoomManagementException,
+    RoomNotFoundException,
+)
 from core.services.subtitle import SubtitleException, SubtitleService
+from core.tasks.file import process_file_deletion
 
 from ..authentication.livekit import LiveKitTokenAuthentication
 from . import permissions, serializers, throttling
@@ -77,20 +105,20 @@ class NestedGenericViewSet(viewsets.GenericViewSet):
     lookup_fields: list[str] = ["pk"]
     lookup_url_kwargs: list[str] = []
 
-    def __getattribute__(self, item):
+    def __getattribute__(self, file):
         """
         This method is overridden to allow to get the last lookup field or lookup url kwarg
         when accessing the `lookup_field` or `lookup_url_kwarg` attribute. This is useful
         to keep compatibility with all methods used by the parent class `GenericViewSet`.
         """
-        if item in ["lookup_field", "lookup_url_kwarg"]:
-            return getattr(self, item + "s", [None])[-1]
+        if file in ["lookup_field", "lookup_url_kwarg"]:
+            return getattr(self, file + "s", [None])[-1]
 
-        return super().__getattribute__(item)
+        return super().__getattribute__(file)
 
     def get_queryset(self):
         """
-        Get the list of items for this view.
+        Get the list of files for this view.
 
         `lookup_fields` attribute is enumerated here to perform the nested lookup.
         """
@@ -201,6 +229,7 @@ class RoomViewSet(
     API endpoints to access and perform actions on rooms.
     """
 
+    pagination_class = Pagination
     permission_classes = [permissions.RoomPermissions]
     queryset = models.Room.objects.all()
     serializer_class = serializers.RoomSerializer
@@ -276,6 +305,41 @@ class RoomViewSet(
         if callback_id := self.request.data.get("callback_id"):
             RoomCreation().persist_callback_state(callback_id, room)
 
+    def perform_update(self, serializer):
+        """Persist the room update, then sync metadata to LiveKit."""
+
+        old_configuration = serializer.instance.configuration
+        old_access_level = serializer.instance.access_level
+
+        room = serializer.save()
+
+        if (
+            room.configuration == old_configuration
+            and room.access_level == old_access_level
+        ):
+            return
+
+        metadata = {
+            "configuration": room.configuration,
+            "access_level": room.access_level,
+        }
+
+        try:
+            RoomManagement().update_metadata(
+                room_name=str(room.id),
+                metadata=metadata,
+            )
+        except RoomNotFoundException:
+            logger.info(
+                "LiveKit room %s does not exist yet, skipping metadata sync",
+                room.id,
+            )
+        except RoomManagementException:
+            logger.warning(
+                "Failed to sync metadata to LiveKit for room %s",
+                room.id,
+            )
+
     @decorators.action(
         detail=True,
         methods=["post"],
@@ -299,16 +363,27 @@ class RoomViewSet(
         options = serializer.validated_data.get("options")
         room = self.get_object()
 
-        # May raise exception if an active or initiated recording already exist for the room
-        recording = models.Recording.objects.create(
-            room=room,
-            mode=mode,
-            options=options.model_dump(exclude_none=True) if options else {},
-        )
+        try:
+            with transaction.atomic():
+                recording = models.Recording.objects.create(
+                    room=room,
+                    mode=mode,
+                    options=options.model_dump(exclude_none=True) if options else {},
+                )
+                models.RecordingAccess.objects.create(
+                    user=self.request.user,
+                    role=models.RoleChoices.OWNER,
+                    recording=recording,
+                )
 
-        models.RecordingAccess.objects.create(
-            user=self.request.user, role=models.RoleChoices.OWNER, recording=recording
-        )
+        except (DjangoValidationError, IntegrityError):
+            # DjangoValidationError covers the Python-level check (full_clean);
+            # IntegrityError covers the race where two concurrent requests both
+            # pass that check and the DB-level UNIQUE constraint catches the loser.
+            return drf_response.Response(
+                {"error": f"A recording is already in progress for room {room.slug}"},
+                status=drf_status.HTTP_409_CONFLICT,
+            )
 
         worker_service = get_worker_service(mode=recording.mode)
         worker_manager = WorkerServiceMediator(worker_service=worker_service)
@@ -316,11 +391,23 @@ class RoomViewSet(
         try:
             worker_manager.start(recording)
         except RecordingStartError:
+            models.Recording.objects.filter(pk=recording.pk).update(
+                status=models.RecordingStatusChoices.FAILED_TO_START
+            )
             return drf_response.Response(
                 {"error": f"Recording failed to start for room {room.slug}"},
-                status=drf_status.HTTP_500_INTERNAL_SERVER_ERROR,
+                status=drf_status.HTTP_502_BAD_GATEWAY,
             )
 
+        if settings.METADATA_COLLECTOR_ENABLED and (
+            recording.options.get("collect_metadata", False)
+        ):
+            try:
+                MetadataCollectorService().start(recording)
+                logger.debug("Started MetadataCollectorService")
+            except MetadataCollectorException:
+                logger.warning("Failed to start MetadataCollectorService")
+
         return drf_response.Response(
             {"message": f"Recording successfully started for room {room.slug}"},
             status=drf_status.HTTP_201_CREATED,
@@ -369,7 +456,10 @@ class RoomViewSet(
         methods=["post"],
         url_path="request-entry",
         permission_classes=[],
-        throttle_classes=[throttling.RequestEntryAnonRateThrottle],
+        throttle_classes=[
+            throttling.RequestEntryAuthenticatedUserRateThrottle,
+            throttling.RequestEntryAnonRateThrottle,
+        ],
     )
     def request_entry(self, request, pk=None):  # pylint: disable=unused-argument
         """Request entry to a room"""
@@ -470,9 +560,7 @@ class RoomViewSet(
             if status_code == drf_status.HTTP_500_INTERNAL_SERVER_ERROR:
                 raise e
 
-            return drf_response.Response(
-                {"status": "error", "message": str(e)}, status=status_code
-            )
+            return drf_response.Response({"status": "error"}, status=status_code)
 
     @decorators.action(
         detail=False,
@@ -567,7 +655,11 @@ class RoomViewSet(
         methods=["post"],
         url_path="mute-participant",
         url_name="mute-participant",
-        permission_classes=[permissions.HasPrivilegesOnRoom],
+        permission_classes=[permissions.CanMuteParticipant],
+        authentication_classes=[
+            LiveKitTokenAuthentication,
+            *api_settings.DEFAULT_AUTHENTICATION_CLASSES,
+        ],
     )
     def mute_participant(self, request, pk=None):  # pylint: disable=unused-argument
         """Mute a specific track for a participant in the room."""
@@ -576,12 +668,37 @@ class RoomViewSet(
         serializer = serializers.MuteParticipantSerializer(data=request.data)
         serializer.is_valid(raise_exception=True)
 
+        # TEMPORARY: a LiveKit token proves access was granted, not that the caller
+        # joined. Cross-check identity against the live participant list until auth
+        # is hardened. Skipped for non-LiveKit auth backends.
+        caller_identity = getattr(request.auth, "identity", None)
+        if caller_identity is not None:
+            try:
+                ParticipantsManagement().check_if_in_meeting(
+                    room_name=str(room.pk),
+                    identity=caller_identity,
+                )
+            except (ParticipantNotFoundException, ParticipantsManagementException):
+                logger.warning(
+                    "Failed to verify caller presence for mute in room %s; denying",
+                    room.pk,
+                )
+                return drf_response.Response(
+                    {"error": "Could not verify caller presence"},
+                    status=drf_status.HTTP_403_FORBIDDEN,
+                )
+
         try:
             ParticipantsManagement().mute(
                 room_name=str(room.pk),
                 identity=str(serializer.validated_data["participant_identity"]),
                 track_sid=serializer.validated_data["track_sid"],
             )
+        except ParticipantNotFoundException:
+            return drf_response.Response(
+                {"error": "Participant not found"},
+                status=drf_status.HTTP_404_NOT_FOUND,
+            )
         except ParticipantsManagementException:
             return drf_response.Response(
                 {"error": "Failed to mute participant"},
@@ -620,6 +737,11 @@ class RoomViewSet(
                 permission=permission.model_dump() if permission else None,
                 name=serializer.validated_data.get("name"),
             )
+        except ParticipantNotFoundException:
+            return drf_response.Response(
+                {"error": "Participant not found"},
+                status=drf_status.HTTP_404_NOT_FOUND,
+            )
         except ParticipantsManagementException:
             return drf_response.Response(
                 {"error": "Failed to update participant"},
@@ -652,6 +774,11 @@ class RoomViewSet(
                 room_name=str(room.pk),
                 identity=str(serializer.validated_data["participant_identity"]),
             )
+        except ParticipantNotFoundException:
+            return drf_response.Response(
+                {"error": "Participant not found"},
+                status=drf_status.HTTP_404_NOT_FOUND,
+            )
         except ParticipantsManagementException:
             return drf_response.Response(
                 {"error": "Failed to remove participant"},
@@ -662,6 +789,92 @@ class RoomViewSet(
             {"status": "success"}, status=drf_status.HTTP_200_OK
         )
 
+    @decorators.action(
+        detail=True,
+        methods=["post"],
+        url_path="toggle-hand",
+        url_name="toggle-hand",
+        permission_classes=[permissions.HasLiveKitRoomAccess],
+        authentication_classes=[LiveKitTokenAuthentication],
+    )
+    def toggle_hand(self, request, pk=None):  # pylint: disable=unused-argument
+        """Raise or lower the current participant's hand in the room."""
+        room = self.get_object()
+
+        serializer = serializers.RaiseHandSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        identity = request.auth.identity
+
+        # LiveKit uses the handRaisedAt participant attribute to signal hand state.
+        # An empty string means the hand is lowered; a non-empty ISO 8601 timestamp
+        # means the hand is raised. The timestamp is used by clients to determine
+        # the order in which participants raised their hands.
+        hand_raised_at = (
+            timezone.now().isoformat() if serializer.validated_data["raised"] else ""
+        )
+
+        try:
+            ParticipantsManagement().update(
+                room_name=str(room.pk),
+                identity=identity,
+                attributes={"handRaisedAt": hand_raised_at},
+            )
+        except ParticipantNotFoundException:
+            return drf_response.Response(
+                {"error": "Participant not found"},
+                status=drf_status.HTTP_404_NOT_FOUND,
+            )
+        except ParticipantsManagementException:
+            return drf_response.Response(
+                {"error": "Failed to update participant hand state"},
+                status=drf_status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+        return drf_response.Response(
+            {"status": "success"},
+            status=drf_status.HTTP_200_OK,
+        )
+
+    @decorators.action(
+        detail=True,
+        methods=["post"],
+        url_path="rename",
+        url_name="rename",
+        permission_classes=[permissions.HasLiveKitRoomAccess],
+        authentication_classes=[LiveKitTokenAuthentication],
+    )
+    def rename(self, request, pk=None):  # pylint: disable=unused-argument
+        """Rename the current participant in the room."""
+        room = self.get_object()
+
+        serializer = serializers.RenameParticipantSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        identity = request.auth.identity
+
+        try:
+            ParticipantsManagement().update(
+                room_name=str(room.pk),
+                identity=identity,
+                name=serializer.validated_data["name"],
+            )
+        except ParticipantNotFoundException:
+            return drf_response.Response(
+                {"error": "Participant not found"},
+                status=drf_status.HTTP_404_NOT_FOUND,
+            )
+        except ParticipantsManagementException:
+            return drf_response.Response(
+                {"error": "Failed to rename participant"},
+                status=drf_status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+        return drf_response.Response(
+            {"status": "success"},
+            status=drf_status.HTTP_200_OK,
+        )
+
 
 class ResourceAccessViewSet(
     mixins.CreateModelMixin,
@@ -739,14 +952,19 @@ class RecordingViewSet(
             recording_id = parser.get_recording_id(request.data)
 
         except ParsingEventDataError as e:
-            raise drf_exceptions.PermissionDenied(f"Invalid request data: {e}") from e
+            raise drf_exceptions.PermissionDenied("Invalid request data.") from e
 
         except InvalidBucketError as e:
-            raise drf_exceptions.PermissionDenied("Invalid bucket specified") from e
+            raise drf_exceptions.PermissionDenied("Invalid bucket specified.") from e
 
-        except InvalidFileTypeError as e:
+        except InvalidFilepathError:
             return drf_response.Response(
-                {"message": f"Ignore this file type, {e}"},
+                {"message": "Notification ignored."},
+            )
+
+        except InvalidFileTypeError:
+            return drf_response.Response(
+                {"message": "Notification ignored."},
             )
 
         try:
@@ -793,7 +1011,7 @@ class RecordingViewSet(
         # Extract the original URL from the request header
         original_url = request.META.get("HTTP_X_ORIGINAL_URL")
         if not original_url:
-            logger.debug("Missing HTTP_X_ORIGINAL_URL header in subrequest")
+            logger.warning("Missing HTTP_X_ORIGINAL_URL header in subrequest")
             raise drf_exceptions.PermissionDenied()
 
         logger.debug("Original url: '%s'", original_url)
@@ -810,7 +1028,7 @@ class RecordingViewSet(
         try:
             return match.groupdict()
         except (ValueError, AttributeError) as exc:
-            logger.debug("Failed to extract parameters from subrequest URL: %s", exc)
+            logger.warning("Failed to extract parameters from subrequest URL: %s", exc)
             raise drf_exceptions.PermissionDenied() from exc
 
     @decorators.action(detail=False, methods=["get"], url_path="media-auth")
@@ -834,7 +1052,7 @@ class RecordingViewSet(
         recording_id = url_params["recording_id"]
 
         extension = url_params["extension"]
-        if extension not in [item.value for item in FileExtension]:
+        if extension not in [file.value for file in FileExtension]:
             raise drf_exceptions.ValidationError({"detail": "Unsupported extension."})
 
         try:
@@ -858,3 +1076,352 @@ class RecordingViewSet(
         request = utils.generate_s3_authorization_headers(recording.key)
 
         return drf_response.Response("authorized", headers=request.headers, status=200)
+
+
+# pylint: disable=too-many-public-methods
+class FileViewSet(
+    SerializerPerActionMixin,
+    mixins.CreateModelMixin,
+    mixins.DestroyModelMixin,
+    mixins.UpdateModelMixin,
+    mixins.ListModelMixin,
+    viewsets.GenericViewSet,
+):
+    """
+    FileViewSet API.
+
+    This viewset provides CRUD operations and additional actions for managing files.
+
+    ### API Endpoints:
+    1. **List**: Retrieve a paginated list of files.
+       Example: GET /files/?page=2
+    2. **Retrieve**: Get a specific file by its ID.
+       Example: GET /files/{id}/
+    3. **Create**: Create a new file.
+       Example: POST /files/
+    4. **Update**: Update a file by its ID.
+       Example: PUT /files/{id}/
+    5. **Delete**: Soft delete a file by its ID.
+       Example: DELETE /files/{id}/
+
+
+    ### Ordering: created_at, updated_at, title
+
+        Example:
+        - Ascending: GET /api/v1.0/files/?ordering=created_at
+
+    ### Filtering:
+        - `is_creator_me=true`: Returns files created by the current user.
+        - `is_creator_me=false`: Returns files created by other users.
+        - `is_deleted=false`: Returns files that are not (soft) deleted
+
+        Example:
+        - GET /api/v1.0/files/?is_creator_me=true
+        - GET /api/v1.0/files/?is_creator_me=false&is_deleted=false
+
+    ### Notes:
+    - Implements soft delete logic to retain file
+    """
+
+    ordering = ["-updated_at"]
+    ordering_fields = ["created_at", "updated_at", "title"]
+    pagination_class = Pagination
+    permission_classes = [
+        permissions.FilePermission,
+    ]
+    queryset = models.File.objects.filter(hard_deleted_at__isnull=True)
+    default_serializer_class = serializers.FileSerializer
+    serializer_classes = {
+        "list": serializers.ListFileSerializer,
+        "create": serializers.CreateFileSerializer,
+    }
+    filter_backends = (django_filters.DjangoFilterBackend, filters.OrderingFilter)
+    filterset_class = ListFileFilter
+
+    def get_queryset(self):
+        """Get queryset that defaults to the current request user."""
+        user = self.request.user
+        queryset = super().get_queryset().select_related("creator")
+
+        if not user.is_authenticated:
+            return queryset.none()
+
+        # For now, we force the filtering on the current user in all cases, might evolve later
+        queryset = queryset.filter(creator=user)
+        return queryset
+
+    def get_response_for_queryset(self, queryset, context=None):
+        """Return paginated response for the queryset if requested."""
+        context = context or self.get_serializer_context()
+        page = self.paginate_queryset(queryset)
+        if page is not None:
+            serializer = self.get_serializer(page, many=True, context=context)
+            result = self.get_paginated_response(serializer.data)
+            return result
+
+        serializer = self.get_serializer(queryset, many=True, context=context)
+        return drf_response.Response(serializer.data)
+
+    def perform_create(self, serializer):
+        """Set the current user as creator of the newly created file."""
+
+        if settings.FILE_UPLOAD_APPLY_RESTRICTIONS:
+            file_type = serializer.validated_data["type"]
+            config_for_file_type = settings.FILE_UPLOAD_RESTRICTIONS[file_type]
+
+            count = models.File.objects.filter(
+                creator=self.request.user,
+                deleted_at__isnull=True,
+                type=file_type,
+            ).count()
+
+            if count >= config_for_file_type["max_count_by_user"]:
+                logger.info(
+                    "create_item: user reached max files per user for type %s",
+                    file_type,
+                )
+                raise serializers.PermissionDenied(
+                    _("You have reached the maximum number of files for this type.")
+                )
+
+        serializer.save(creator=self.request.user)
+
+    def perform_destroy(self, instance):
+        """Override to implement a soft delete instead of dumping the record in database."""
+        instance.soft_delete()
+
+    @decorators.action(detail=True, methods=["post"], url_path="upload-ended")
+    @FeatureFlag.require("file_upload")
+    def upload_ended(self, request, *args, **kwargs):
+        """
+        Check the actual uploaded file and mark it as ready.
+        """
+        # Ensures we go through authorization checks
+        file = self.get_object()
+
+        # Try to update the file with the new state. If the file is already in this state
+        # we are in a concurrent request, and we should reject that request
+        updated_rows = models.File.objects.filter(
+            upload_state=models.FileUploadStateChoices.PENDING,
+            pk=kwargs["pk"],
+        ).update(upload_state=models.FileUploadStateChoices.ANALYZING)
+        if updated_rows != 1:
+            raise drf_exceptions.ValidationError(
+                {"file": "This action is only available for files in PENDING state."},
+                code="file_upload_state_not_pending",
+            )
+        file.refresh_from_db()
+
+        s3_client = default_storage.connection.meta.client
+        validation_error = None
+
+        try:
+            # We copy the file to its final destination, we will run the checks on that
+            # final file and ignore any updates to the temporary file. (We cannot revoke the policy,
+            # so the temporary file might still be updated after that.)
+            # The temporary folders will need to be cleaned periodically
+            s3_client.copy_object(
+                Bucket=default_storage.bucket_name,
+                Key=file.file_key,
+                CopySource={
+                    "Bucket": default_storage.bucket_name,
+                    "Key": file.temporary_file_key,
+                },
+            )
+
+            head_response = s3_client.head_object(
+                Bucket=default_storage.bucket_name, Key=file.file_key
+            )
+            file_size = head_response["ContentLength"]
+            # python-magic recommends using at least the first 2048 bytes
+            # to reduce incorrect identification.
+            # This is a tradeoff between pulling in the whole file and
+            # the most likely relevant bytes
+            # of the file for mime type identification.
+            if file_size > 2048:
+                range_response = s3_client.get_object(
+                    Bucket=default_storage.bucket_name,
+                    Key=file.file_key,
+                    Range="bytes=0-2047",
+                )
+                file_head = range_response["Body"].read()
+            else:
+                file_head = s3_client.get_object(
+                    Bucket=default_storage.bucket_name, Key=file.file_key
+                )["Body"].read()
+
+            logger.info("upload_ended: detecting mimetype for file: %s", file.file_key)
+            mimetype = utils.detect_mimetype(file_head, filename=file.filename)
+
+            if settings.FILE_UPLOAD_APPLY_RESTRICTIONS:
+                config_for_file_type = settings.FILE_UPLOAD_RESTRICTIONS[file.type]
+                if file_size > config_for_file_type["max_size"]:
+                    logger.info(
+                        "upload_ended: file size (%s) for file %s higher than the allowed max size",
+                        file_size,
+                        file.file_key,
+                    )
+                    validation_error = drf_exceptions.ValidationError(
+                        detail="The file size is higher than the allowed max size.",
+                        code="file_size_exceeded",
+                    )
+                else:
+                    # Use improved MIME type detection combining magic bytes and file extension
+                    allowed_file_mimetypes = config_for_file_type["allowed_mimetypes"]
+                    if mimetype not in allowed_file_mimetypes:
+                        logger.warning(
+                            "upload_ended: mimetype not allowed %s for file %s",
+                            mimetype,
+                            file.file_key,
+                        )
+                        validation_error = drf_exceptions.ValidationError(
+                            detail="The file type is not allowed.",
+                            code="file_type_not_allowed",
+                        )
+
+            if validation_error is not None:
+                self._complete_file_deletion(file)
+            else:
+                file.upload_state = models.FileUploadStateChoices.READY
+                file.mimetype = mimetype
+                file.size = file_size
+                file.save(update_fields=["upload_state", "mimetype", "size"])
+
+                if head_response["ContentType"] != mimetype:
+                    logger.info(
+                        "upload_ended: content type mismatch between object storage and file,"
+                        " updating from %s to %s",
+                        head_response["ContentType"],
+                        mimetype,
+                    )
+                    s3_client.copy_object(
+                        Bucket=default_storage.bucket_name,
+                        Key=file.file_key,
+                        CopySource={
+                            "Bucket": default_storage.bucket_name,
+                            "Key": file.file_key,
+                        },
+                        ContentType=mimetype,
+                        Metadata=head_response["Metadata"],
+                        MetadataDirective="REPLACE",
+                    )
+        except Exception as e:
+            logger.exception("Failed to analyze file, reverting to pending state")
+            file.upload_state = models.FileUploadStateChoices.PENDING
+            file.save()
+            raise e
+
+        if validation_error:
+            raise validation_error
+
+        # Not yet implemented
+        # Change the file.upload_state when this will be done
+        # malware_detection.analyse_file(file.file_key, file_id=file.id)
+
+        serializer = self.get_serializer(file)
+
+        return drf_response.Response(serializer.data, status=drf_status.HTTP_200_OK)
+
+    def _complete_file_deletion(self, file):
+        """Delete a file completely."""
+        file.soft_delete()
+        file.hard_delete()
+        transaction.on_commit(lambda: process_file_deletion.delay(file.id))
+
+    def _authorize_subrequest(self, request, pattern):
+        """
+        Authorize access based on the original URL of an Nginx subrequest
+        and user permissions. Returns a dictionary of URL parameters if authorized.
+
+        The original url is passed by nginx in the "HTTP_X_ORIGINAL_URL" header.
+        See corresponding ingress configuration in Helm chart and read about the
+        nginx.ingress.kubernetes.io/auth-url annotation to understand how the Nginx ingress
+        is configured to do this.
+
+        Based on the original url and the logged in user, we must decide if we authorize Nginx
+        to let this request go through (by returning a 200 code) or if we block it (by returning
+        a 403 error). Note that we return 403 errors without any further details for security
+        reasons.
+
+        Parameters:
+        - pattern: The regex pattern to extract identifiers from the URL.
+
+        Returns:
+        - A dictionary of URL parameters if the request is authorized.
+        Raises:
+        - PermissionDenied if authorization fails.
+        """
+        # Extract the original URL from the request header
+        original_url = request.META.get("HTTP_X_ORIGINAL_URL")
+        if not original_url:
+            logger.warning("Missing HTTP_X_ORIGINAL_URL header in subrequest")
+            raise drf_exceptions.PermissionDenied()
+
+        parsed_url = urlparse(original_url)
+        match = pattern.search(unquote(parsed_url.path))
+
+        if not match:
+            logger.warning(
+                "Subrequest URL '%s' did not match pattern '%s'",
+                parsed_url.path,
+                pattern,
+            )
+            raise drf_exceptions.PermissionDenied()
+
+        try:
+            url_params = match.groupdict()
+        except (ValueError, AttributeError) as exc:
+            logger.warning("Failed to extract parameters from subrequest URL: %s", exc)
+            raise drf_exceptions.PermissionDenied() from exc
+
+        pk = url_params.get("pk")
+        if not pk:
+            logger.warning("File ID (pk) not found in URL parameters: %s", url_params)
+            raise drf_exceptions.PermissionDenied()
+
+        # Fetch the file and check if the user has access
+        queryset = models.File.objects.all()
+        # No suspicious analysis implemented yet
+        # queryset = self._filter_suspicious_files(queryset, request.user)
+        try:
+            file = queryset.get(pk=pk)
+        except models.File.DoesNotExist as exc:
+            logger.warning("File with ID '%s' does not exist", pk)
+            raise drf_exceptions.PermissionDenied() from exc
+
+        user_abilities = file.get_abilities(request.user)
+        if not user_abilities.get(self.action, False):
+            logger.warning(
+                "User '%s' lacks permission for file '%s'", request.user.id, pk
+            )
+            raise drf_exceptions.PermissionDenied()
+
+        logger.debug(
+            "Subrequest authorization successful. Extracted parameters: %s", url_params
+        )
+        return url_params, request.user.id, file
+
+    @decorators.action(detail=False, methods=["get"], url_path="media-auth")
+    @FeatureFlag.require("file_upload")
+    def media_auth(self, request, *args, **kwargs):
+        """
+        This view is used by an Nginx subrequest to control access to an file's
+        attachment file.
+
+        When we let the request go through, we compute authorization headers that will be added to
+        the request going through thanks to the nginx.ingress.kubernetes.io/auth-response-headers
+        annotation. The request will then be proxied to the object storage backend who will
+        respond with the file after checking the signature included in headers.
+        """
+        url_params, _, file = self._authorize_subrequest(
+            request, MEDIA_STORAGE_URL_PATTERN
+        )
+
+        if not file.is_ready:
+            logger.warning("File '%s' is not ready", file.id)
+            raise drf_exceptions.PermissionDenied()
+
+        # Generate S3 authorization headers using the extracted URL parameters
+        request = utils.generate_s3_authorization_headers(f"{url_params.get('key'):s}")
+
+        return drf_response.Response("authorized", headers=request.headers, status=200)

src/backend/core/audit.py

@@ -0,0 +1,194 @@
+"""Structured audit logging."""
+
+# Audit helpers intentionally expose many optional keyword fields.
+# pylint: disable=R0913,R0917
+# ruff: noqa: PLR0913
+
+import json
+import logging
+from datetime import datetime, timezone
+from functools import partialmethod
+from typing import TYPE_CHECKING, Any, Protocol
+
+from django.http import HttpRequest
+
+AUDIT_LOGGER_NAME = "audit"
+
+
+def resolve_source_ip(request: HttpRequest):
+    """Return the best-effort client IP for ``request``.
+
+    Reads the original client from ``X-Forwarded-For`` when present,
+    falling back to ``REMOTE_ADDR``.
+
+    NB: behind a proxy/load-balancer chain, correctness depends on the ingress
+    being configured to set and trust ``X-Forwarded-For``. Confirm the
+    trusted-proxy chain before relying on this value for security decisions.
+    """
+    forwarded = request.META.get("HTTP_X_FORWARDED_FOR")
+    if forwarded:
+        return forwarded.split(",")[0].strip()
+    return request.META.get("REMOTE_ADDR")
+
+
+def extract_request_fields(request: HttpRequest) -> dict[str, Any]:
+    """Return the audit fields derivable from ``request``."""
+    meta = request.META
+    return {
+        "source_ip": resolve_source_ip(request),
+        "source_port": meta.get("REMOTE_PORT"),
+        "request_path": request.path,
+        "request_url": request.build_absolute_uri(),
+        "request_method": request.method,
+        "request_body_bytes": meta.get("CONTENT_LENGTH"),
+        "http_version": meta.get("SERVER_PROTOCOL"),
+        "user_agent": meta.get("HTTP_USER_AGENT"),
+        "referer": meta.get("HTTP_REFERER"),
+        "server_user": meta.get("REMOTE_USER"),
+    }
+
+
+class AuditJsonFormatter(logging.Formatter):
+    """Render audit records as single-line JSON.
+
+    Read the structured payload attached to the record under ``audit`` and
+    wrap it in a small envelope.
+    """
+
+    def format(self, record):
+        payload = {"log_type": "audit"}
+
+        audit = getattr(record, "audit", None)
+        if isinstance(audit, dict):
+            payload.update(audit)
+        else:
+            payload["event_type"] = record.getMessage()
+
+        payload.setdefault(
+            "timestamp",
+            datetime.fromtimestamp(record.created, tz=timezone.utc).isoformat(),
+        )
+        payload["level"] = record.levelname
+        payload["logger"] = record.name
+
+        # ``default=str`` serialises UUIDs, datetimes, etc.; ``ensure_ascii``
+        # off keeps emails and non-ASCII identifiers readable.
+        return json.dumps(payload, default=str, ensure_ascii=False)
+
+
+class _AuditEmit(Protocol):
+    """Public signature shared by the per-level audit methods.
+
+    Declared so editors and type checkers see the real keyword fields despite using `partialwrapper`.
+    """
+
+    def __call__(
+        self,
+        event_type: str,
+        *,
+        auth_type: str | None = ...,
+        actor: dict[str, Any] | None = ...,
+        source_ip: str | None = ...,
+        target: dict[str, Any] | None = ...,
+        request: HttpRequest | None = ...,
+        **extra: Any,
+    ) -> None:
+        pass
+
+
+class AuditLogger:
+    """Wrapper around the named ``audit`` logger."""
+
+    def __init__(
+        self,
+        logger_name=AUDIT_LOGGER_NAME,
+        custom_serializers: list[tuple] | None = None,
+    ):
+        self._logger = logging.getLogger(logger_name)
+        self._serializers = []
+        if custom_serializers is not None:
+            self._serializers = custom_serializers
+
+    def _emit(
+        self,
+        level,
+        event_type,
+        request: HttpRequest | None,  # Intentionnaly mandatory
+        *,
+        exc_info: bool = False,
+        **extra,
+    ):
+        """Assemble the structured payload and emit it on the audit logger.
+
+        ``exc_info`` is forwarded to the stdlib logger (set by ``exception``) so
+        the active traceback is captured; it is a logging concern and never
+        enters the audit payload.
+        """
+
+        request_fields = extract_request_fields(request) if request is not None else {}
+
+        # Create fields from custom serializers
+        new_extra = {}
+        for key, value in extra.items():
+            for cls, serializer in self._serializers:
+                if isinstance(value, cls):
+                    new_extra = new_extra | {
+                        f"{key}.{ser_key}": ser_field
+                        for ser_key, ser_field in serializer(value).items()
+                    }
+                    break
+            else:
+                new_extra[key] = value
+
+        audit = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "event_type": event_type,
+            **request_fields,
+            **new_extra,
+        }
+        audit = {key: value for key, value in audit.items() if value is not None}
+
+        self._logger.log(level, event_type, extra={"audit": audit}, exc_info=exc_info)
+
+    # One public method per standard logging level, all sharing ``_emit``.
+    # The ``TYPE_CHECKING`` declarations expose the real signature to editors;
+    # the ``else`` branch is what runs, binding the level via ``partialmethod``.
+    if TYPE_CHECKING:
+        debug: _AuditEmit
+        info: _AuditEmit
+        warning: _AuditEmit
+        error: _AuditEmit
+        critical: _AuditEmit
+        # ``exception`` mirrors stdlib: ERROR level with the active traceback.
+        exception: _AuditEmit
+    else:
+        debug = partialmethod(_emit, logging.DEBUG)
+        info = partialmethod(_emit, logging.INFO)
+        warning = partialmethod(_emit, logging.WARNING)
+        error = partialmethod(_emit, logging.ERROR)
+        critical = partialmethod(_emit, logging.CRITICAL)
+        exception = partialmethod(_emit, logging.ERROR, exc_info=True)
+
+
+def getLogger(
+    name: str | None = None, custom_serializers: list[tuple | None] = None
+) -> AuditLogger:
+    """Return an :class:`AuditLogger`, mirroring :func:`logging.getLogger`.
+
+    Pass ``__name__`` to tag audit records with the calling module while still
+    emitting on the dedicated ``audit`` handler::
+
+        from core import audit
+
+        logger = audit.getLogger(__name__)
+        logger.info("external_api.token.issued", ...)
+
+    Names are nested under ``AUDIT_LOGGER_NAME`` (e.g. ``audit.core.foo``) so
+    they inherit its handlers through the standard logging hierarchy, keeping
+    the module visible in the ``logger`` field of the emitted JSON.
+    """
+    if not name or name == AUDIT_LOGGER_NAME:
+        return AuditLogger(AUDIT_LOGGER_NAME, custom_serializers=custom_serializers)
+    return AuditLogger(
+        f"{AUDIT_LOGGER_NAME}.{name}", custom_serializers=custom_serializers
+    )

src/backend/core/audit_meet.py

@@ -0,0 +1,19 @@
+"""Audit logging with custom serializers."""
+
+from core.audit import getLogger as get_logger_base
+from core.models import Room
+
+
+def serialize_room(room: Room):
+    return {
+        "name": room.name,
+        "slug": room.slug,
+        "access_level": room.access_level,
+    }
+
+
+custom_serializers = [(Room, serialize_room)]
+
+
+def getLogger(name: str | None = None):
+    return get_logger_base(name=name, custom_serializers=custom_serializers)

src/backend/core/authentication/livekit.py

@@ -14,10 +14,19 @@ class LiveKitTokenAuthentication(authentication.BaseAuthentication):
     """Authenticate using LiveKit token and load the associated Django user."""
 
     def authenticate(self, request):
-        token = request.data.get("token")
-        if not token:
+        auth_header = request.headers.get("Authorization")
+
+        if not auth_header:
             return None  # No authentication attempted
 
+        parts = auth_header.split()
+        if len(parts) != 2 or parts[0].lower() != "bearer":
+            raise exceptions.AuthenticationFailed(
+                "Authorization header must be: Bearer <token>"
+            )
+
+        token = parts[1]
+
         try:
             verifier = TokenVerifier(
                 api_key=settings.LIVEKIT_CONFIGURATION["api_key"],

src/backend/core/enums.py

@@ -14,9 +14,15 @@ FILE_EXT_REGEX = r"[a-zA-Z0-9]{1,10}"
 
 # pylint: disable=line-too-long
 RECORDING_STORAGE_URL_PATTERN = re.compile(
-    f"/media/{settings.RECORDING_OUTPUT_FOLDER}/(?P<recording_id>{UUID_REGEX:s}).(?P<extension>{FILE_EXT_REGEX:s})"
+    rf"{settings.MEDIA_URL:s}{settings.RECORDING_OUTPUT_FOLDER}/(?P<recording_id>{UUID_REGEX:s})\.(?P<extension>{FILE_EXT_REGEX:s})"
 )
 
+MEDIA_STORAGE_URL_PATTERN = re.compile(
+    f"{settings.MEDIA_URL:s}"
+    rf"(?P<key>{settings.FILE_UPLOAD_PATH:s}/(?P<pk>{UUID_REGEX:s})\.{FILE_EXT_REGEX:s})$"
+)
+
+
 # Django sets `LANGUAGES` by default with all supported languages. We can use it for
 # the choice of languages which should not be limited to the few languages active in
 # the app.

src/backend/core/external_api/authentication.py

@@ -23,7 +23,14 @@ class BaseJWTAuthentication(authentication.BaseAuthentication):
     """Base JWT authentication class."""
 
     def __init__(
-        self, secret_key, algorithm, issuer, audience, expiration_seconds, token_type
+        self,
+        secret_key,
+        algorithm,
+        issuer,
+        audience,
+        expiration_seconds,
+        token_type,
+        is_enabled,
     ):
         """Initialize the JWT authentication backend with the given token service configuration.
 
@@ -34,10 +41,17 @@ class BaseJWTAuthentication(authentication.BaseAuthentication):
             audience: Expected token audience identifier
             expiration_seconds: Token expiration time in seconds
             token_type: Token type (e.g. Bearer)
+            is_enabled: Whether this authentication backend is active
         """
 
         super().__init__()
 
+        self.is_enabled = is_enabled
+        self._token_service = None
+
+        if not self.is_enabled:
+            return
+
         self._token_service = jwt_token.JwtTokenService(
             secret_key=secret_key,
             algorithm=algorithm,
@@ -54,6 +68,9 @@ class BaseJWTAuthentication(authentication.BaseAuthentication):
             Tuple of (user, payload) if authentication successful, None otherwise
         """
 
+        if not self.is_enabled:
+            return None
+
         auth_header = authentication.get_authorization_header(request).split()
 
         if not auth_header or auth_header[0].lower() != b"bearer":
@@ -186,6 +203,7 @@ class ApplicationJWTAuthentication(BaseJWTAuthentication):
             audience=settings.APPLICATION_JWT_AUDIENCE,
             expiration_seconds=settings.APPLICATION_JWT_EXPIRATION_SECONDS,
             token_type=settings.APPLICATION_JWT_TOKEN_TYPE,
+            is_enabled=settings.APPLICATION_ENABLED,
         )
 
     def validate_payload(self, payload):
@@ -203,7 +221,7 @@ class ApplicationJWTAuthentication(BaseJWTAuthentication):
             logger.warning("Application not found: %s", client_id)
             raise exceptions.AuthenticationFailed("Application not found.") from e
 
-        if not application.active:
+        if not application.is_active:
             logger.warning(
                 "Inactive application attempted authentication: %s", client_id
             )
@@ -214,6 +232,26 @@ class ApplicationJWTAuthentication(BaseJWTAuthentication):
             raise exceptions.AuthenticationFailed("Invalid token type.")
 
 
+class AddonsJWTAuthentication(BaseJWTAuthentication):
+    """JWT authentication for addons API access.
+
+    Validates JWT tokens issued to addons.
+    """
+
+    def __init__(self):
+        """Initialize authentication backend with addons JWT settings from Django settings."""
+
+        super().__init__(
+            secret_key=settings.ADDONS_TOKEN_SECRET_KEY,
+            algorithm=settings.ADDONS_TOKEN_ALG,
+            issuer=settings.ADDONS_TOKEN_ISSUER,
+            audience=settings.ADDONS_TOKEN_AUDIENCE,
+            expiration_seconds=settings.ADDONS_TOKEN_TTL,
+            token_type=settings.ADDONS_TOKEN_TYPE,
+            is_enabled=settings.ADDONS_ENABLED,
+        )
+
+
 class ResourceServerBackend(LaSuiteBackend):
     """OIDC Resource Server backend for user creation and retrieval."""
 

src/backend/core/external_api/serializers.py

@@ -4,10 +4,11 @@
 
 from django.conf import settings
 
+from pydantic import ValidationError
 from rest_framework import serializers
 
 from core import models, utils
-from core.api.serializers import BaseValidationOnlySerializer
+from core.api.serializers import BaseValidationOnlySerializer, RoomConfiguration
 
 OAUTH2_GRANT_TYPE_CLIENT_CREDENTIALS = "client_credentials"
 
@@ -34,10 +35,37 @@ class RoomSerializer(serializers.ModelSerializer):
     following the principle of least privilege.
     """
 
+    configuration = serializers.JSONField(required=False)
+
     class Meta:
         model = models.Room
-        fields = ["id", "name", "slug", "pin_code", "access_level"]
-        read_only_fields = ["id", "name", "slug", "pin_code", "access_level"]
+        fields = ["id", "name", "slug", "pin_code", "access_level", "configuration"]
+        read_only_fields = ["id", "name", "slug", "pin_code"]
+
+    def validate_configuration(self, value):
+        """Validate room configuration against the RoomConfiguration schema."""
+        if value is None or value == {}:
+            return value
+        try:
+            RoomConfiguration.model_validate(value)
+        except ValidationError as e:
+            raise serializers.ValidationError(e.errors()) from e
+        return value
+
+    def validate_access_level(self, access_level):
+        """Reject public access_level unless explicitly allowed or the default is already public."""
+
+        if settings.EXTERNAL_API_DEFAULT_ACCESS_LEVEL == models.RoomAccessLevel.PUBLIC:
+            return access_level
+
+        if (
+            access_level == models.RoomAccessLevel.PUBLIC
+            and not settings.EXTERNAL_API_ALLOW_PUBLIC_ACCESS
+        ):
+            raise serializers.ValidationError(
+                "Public rooms are disabled for the external API."
+            )
+        return access_level
 
     def to_representation(self, instance):
         """Enrich response with application-specific computed fields."""
@@ -68,6 +96,9 @@ class RoomSerializer(serializers.ModelSerializer):
 
         # Set secure defaults
         validated_data["name"] = utils.generate_room_slug()
-        validated_data["access_level"] = models.RoomAccessLevel.TRUSTED
+        validated_data.setdefault(
+            "access_level", settings.EXTERNAL_API_DEFAULT_ACCESS_LEVEL
+        )
+        validated_data.setdefault("configuration", {})
 
         return super().create(validated_data)

src/backend/core/external_api/viewsets.py

@@ -1,10 +1,8 @@
 """External API endpoints"""
 
-from logging import getLogger
-
 from django.conf import settings
 from django.contrib.auth.hashers import check_password
-from django.core.exceptions import SuspiciousOperation, ValidationError
+from django.core.exceptions import ValidationError
 from django.core.validators import validate_email
 
 from lasuite.oidc_resource_server.authentication import ResourceServerAuthentication
@@ -20,11 +18,18 @@ from rest_framework import (
 )
 
 from core import api, models
+from core.api.feature_flag import FeatureFlag
+from core.audit_meet import getLogger
 from core.services.jwt_token import JwtTokenService
 
+from ..services.provisional_user_service import (
+    ProvisionalUserCreationDisabledError,
+    ProvisionalUserIntegrityError,
+    ProvisionalUserService,
+)
 from . import authentication, permissions, serializers
 
-logger = getLogger(__name__)
+audit_logger = getLogger(__name__)
 
 
 class ApplicationViewSet(viewsets.ViewSet):
@@ -36,6 +41,7 @@ class ApplicationViewSet(viewsets.ViewSet):
         url_path="token",
         url_name="token",
     )
+    @FeatureFlag.require("application")
     def generate_jwt_access_token(self, request, *args, **kwargs):
         """Generate JWT access token for application delegation.
 
@@ -61,12 +67,12 @@ class ApplicationViewSet(viewsets.ViewSet):
         except models.Application.DoesNotExist as e:
             raise drf_exceptions.AuthenticationFailed("Invalid credentials") from e
 
-        if not application.active:
-            raise drf_exceptions.AuthenticationFailed("Application is inactive")
-
         if not check_password(client_secret, application.client_secret):
             raise drf_exceptions.AuthenticationFailed("Invalid credentials")
 
+        if not application.is_active:
+            raise drf_exceptions.AuthenticationFailed("Application is inactive")
+
         email = serializer.validated_data["scope"]
         try:
             validate_email(email)
@@ -79,10 +85,11 @@ class ApplicationViewSet(viewsets.ViewSet):
             )
 
         if not application.can_delegate_email(email):
-            logger.warning(
-                "Application %s denied delegation for %s",
-                application.client_id,
-                email,
+            audit_logger.warning(
+                "Application denied delegation",
+                request=request,
+                application_client_id=application.client_id,
+                email=email,
             )
             return drf_response.Response(
                 {
@@ -92,40 +99,14 @@ class ApplicationViewSet(viewsets.ViewSet):
             )
 
         try:
-            user = models.User.objects.get(email__iexact=email)
-        except models.User.DoesNotExist as e:
-            if (
-                settings.APPLICATION_ALLOW_USER_CREATION
-                and settings.OIDC_FALLBACK_TO_EMAIL_FOR_IDENTIFICATION
-                and not settings.OIDC_USER_SUB_FIELD_IMMUTABLE
-            ):
-                # Create a provisional user without `sub`, identified by email only.
-                #
-                # This relies on Django LaSuite implicitly updating the `sub` field on the
-                # user's first successful OIDC authentication. If this stops working,
-                # check for behavior changes in Django LaSuite.
-                #
-                # `OIDC_USER_SUB_FIELD_IMMUTABLE` comes from Django LaSuite and prevents `sub`
-                # updates. We override its default value to allow setting `sub` for
-                # provisional users.
-                user = models.User(
-                    sub=None,
-                    email=email,
-                )
-                user.set_unusable_password()
-                user.save()
-                logger.info(
-                    "Provisional user created via application: user_id=%s, email=%s, client_id=%s",
-                    user.id,
-                    email,
-                    application.client_id,
-                )
-            else:
-                raise drf_exceptions.NotFound("User not found.") from e
-        except models.User.MultipleObjectsReturned as e:
-            raise SuspiciousOperation(
-                "Multiple user accounts share a common email."
-            ) from e
+            user, _ = ProvisionalUserService().get_or_create(email, client_id)
+        except ProvisionalUserCreationDisabledError as not_found_error:
+            raise drf_exceptions.NotFound("User not found.") from not_found_error
+        except ProvisionalUserIntegrityError:
+            return drf_response.Response(
+                {"error": "Failed to create or retrieve provisional user."},
+                status=drf_status.HTTP_409_CONFLICT,
+            )
 
         scope = " ".join(application.scopes or [])
 
@@ -173,6 +154,7 @@ class RoomViewSet(
 
     authentication_classes = [
         authentication.ApplicationJWTAuthentication,
+        authentication.AddonsJWTAuthentication,
         ResourceServerAuthentication,
     ]
     permission_classes = [
@@ -213,9 +195,10 @@ class RoomViewSet(
         )
 
         # Log for auditing
-        logger.info(
-            "Room created via application: room_id=%s, user_id=%s, client_id=%s",
-            room.id,
-            self.request.user.id,
-            getattr(self.request.auth, "client_id", "unknown"),
+        audit_logger.info(
+            "room_created_via_application",
+            request=self.request,
+            # Extra
+            room=room,
+            client_id=getattr(self.request.auth, "client_id", "unknown"),
         )

src/backend/core/factories.py

@@ -2,8 +2,11 @@
 Core application factories
 """
 
+from io import BytesIO
+
 from django.conf import settings
 from django.contrib.auth.hashers import make_password
+from django.core.files.storage import default_storage
 from django.utils.text import slugify
 
 import factory.fuzzy
@@ -126,7 +129,7 @@ class ApplicationFactory(factory.django.DjangoModelFactory):
         model = models.Application
 
     name = factory.Faker("company")
-    active = True
+    is_active = True
     client_id = factory.LazyFunction(utils.generate_client_id)
     client_secret = factory.LazyFunction(utils.generate_client_secret)
     scopes = []
@@ -153,3 +156,42 @@ class ApplicationDomainFactory(factory.django.DjangoModelFactory):
 
     domain = factory.Faker("domain_name")
     application = factory.SubFactory(ApplicationFactory)
+
+
+class FileFactory(factory.django.DjangoModelFactory):
+    """A factory to create files"""
+
+    class Meta:
+        model = models.File
+        skip_postgeneration_save = True
+
+    title = factory.Sequence(lambda n: f"file{n}")
+    creator = factory.SubFactory(UserFactory)
+    deleted_at = None
+    type = factory.fuzzy.FuzzyChoice([t[0] for t in models.FileTypeChoices.choices])
+    filename = factory.lazy_attribute(lambda o: fake.file_name())
+    upload_state = None
+    size = None
+
+    @factory.post_generation
+    def update_upload_state(self, create, extracted, **kwargs):
+        """Change the upload state of a file."""
+        if create and extracted:
+            self.upload_state = extracted
+            self.save()
+
+    @factory.post_generation
+    def upload_bytes(self, create, extracted, **kwargs):
+        """Save content of the file into the storage"""
+        if create and extracted is not None:
+            content = (
+                extracted
+                if isinstance(extracted, bytes)
+                else str(extracted).encode("utf-8")
+            )
+
+            self.filename = kwargs.get("filename", self.filename or "content.txt")
+            self.size = len(content)
+            self.save()
+
+            default_storage.save(self.file_key, BytesIO(content))

src/backend/core/management/commands/merge_duplicate_users.py

@@ -0,0 +1,168 @@
+"""Management command to merge duplicate users based on their email address."""
+
+# pylint: disable=too-many-locals
+
+from django.contrib.auth import get_user_model
+from django.core.management.base import BaseCommand, CommandError
+from django.db import transaction
+from django.db.models import Count
+
+from core.models import File, RecordingAccess, ResourceAccess, RoleChoices
+
+User = get_user_model()
+
+ROLE_PRIORITY = {
+    RoleChoices.OWNER: 3,
+    RoleChoices.ADMIN: 2,
+    RoleChoices.MEMBER: 1,
+}
+
+
+class Command(BaseCommand):
+    """
+    Merge duplicate users sharing the same email into the most recently created one.
+
+    The KEPT user is the most recently created. All room memberships, recording
+    accesses and files are transferred to it. When a conflict exists, the
+    higher-privilege role wins. Stale users are then deleted.
+    Each email group is processed inside a single database transaction.
+    """
+
+    help = __doc__
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Simulate the merge without writing any changes to the database.",
+        )
+        parser.add_argument(
+            "--email-filter",
+            type=str,
+            default=None,
+            help="Only merge users whose email contains this string (e.g. '@example.com').",
+        )
+
+    def handle(self, *args, **options):
+        """Execute the management command."""
+        dry_run = options["dry_run"]
+        email_filter = options["email_filter"]
+
+        if dry_run:
+            self.stdout.write("[DRY-RUN] No changes will be written.\n")
+
+        users_qs = User.objects.all()
+        if email_filter:
+            users_qs = users_qs.filter(email__icontains=email_filter)
+            self.stdout.write(f"[INFO] Filtering emails containing '{email_filter}'.\n")
+
+        duplicate_emails = (
+            users_qs.exclude(email__isnull=True)
+            .exclude(email="")
+            .values("email")
+            .annotate(cnt=Count("id"))
+            .filter(cnt__gt=1)
+            .values_list("email", flat=True)
+        )
+
+        if not duplicate_emails:
+            self.stdout.write("[INFO] No duplicate users found. Nothing to do.")
+            return
+
+        self.stdout.write(
+            f"[INFO] Found {len(duplicate_emails)} email(s) with duplicate users."
+        )
+
+        total_merged = 0
+        total_deleted = 0
+        failed_emails = []
+
+        for email in duplicate_emails:
+            # Secondary sort by id ensures a stable, deterministic order when
+            # created_at timestamps are equal (common in tests and bulk imports).
+            users = list(User.objects.filter(email=email).order_by("created_at", "id"))
+            kept_user = users[-1]
+            stale_users = users[:-1]
+
+            self.stdout.write(
+                f"\n[INFO] Email '{email}': {len(users)} users — "
+                f"keeping {kept_user.id} (created {kept_user.created_at.date()})."
+            )
+            for u in stale_users:
+                self.stdout.write(
+                    f"       stale: {u.id} (created {u.created_at.date()})"
+                )
+
+            if dry_run:
+                ra_count = ResourceAccess.objects.filter(user__in=stale_users).count()
+                rca_count = RecordingAccess.objects.filter(user__in=stale_users).count()
+                f_count = File.objects.filter(creator__in=stale_users).count()
+                self.stdout.write(
+                    f"       [DRY-RUN] Would migrate: {ra_count} ResourceAccess, "
+                    f"{rca_count} RecordingAccess, {f_count} File(s)."
+                )
+                continue
+
+            try:
+                group_deleted = 0
+                with transaction.atomic():
+                    for stale_user in stale_users:
+                        self._merge_resource_accesses(stale_user, kept_user)
+                        self._merge_recording_accesses(stale_user, kept_user)
+                        self._merge_files(stale_user, kept_user)
+                        stale_user.delete()
+                        group_deleted += 1
+
+                total_deleted += group_deleted
+                total_merged += 1
+
+            except Exception as exc:  # noqa: BLE001 #pylint: disable=broad-exception-caught
+                failed_emails.append(email)
+                self.stderr.write(f"[ERROR] Failed to merge '{email}': {exc}")
+
+        if failed_emails:
+            raise CommandError(
+                f"Failed to merge {len(failed_emails)} email group(s): {', '.join(failed_emails)}"
+            )
+
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"\n[DONE] Merged {total_merged} group(s), deleted {total_deleted} user(s)."
+            )
+        )
+
+    def _merge_resource_accesses(self, stale_user, kept_user):
+        """Transfer room memberships from stale_user to kept_user."""
+        for ra in ResourceAccess.objects.filter(user=stale_user):
+            existing = ResourceAccess.objects.filter(
+                user=kept_user, resource=ra.resource
+            ).first()
+
+            if existing is None:
+                ra.user = kept_user
+                ra.save(update_fields=["user"])
+            else:
+                if ROLE_PRIORITY.get(ra.role, 0) > ROLE_PRIORITY.get(existing.role, 0):
+                    existing.role = ra.role
+                    existing.save(update_fields=["role"])
+                ra.delete()
+
+    def _merge_recording_accesses(self, stale_user, kept_user):
+        """Transfer recording accesses from stale_user to kept_user."""
+        for rca in RecordingAccess.objects.filter(user=stale_user):
+            existing = RecordingAccess.objects.filter(
+                user=kept_user, recording=rca.recording
+            ).first()
+
+            if existing is None:
+                rca.user = kept_user
+                rca.save(update_fields=["user"])
+            else:
+                if ROLE_PRIORITY.get(rca.role, 0) > ROLE_PRIORITY.get(existing.role, 0):
+                    existing.role = rca.role
+                    existing.save(update_fields=["role"])
+                rca.delete()
+
+    def _merge_files(self, stale_user, kept_user):
+        """Re-assign files created by stale_user to kept_user."""
+        File.objects.filter(creator=stale_user).update(creator=kept_user)

src/backend/core/migrations/0017_file.py

@@ -0,0 +1,42 @@
+# Generated by Django 5.2.11 on 2026-03-03 15:22
+
+import django.db.models.deletion
+import uuid
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0016_recording_options'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='File',
+            fields=[
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, help_text='primary key for the record as UUID', primary_key=True, serialize=False, verbose_name='id')),
+                ('created_at', models.DateTimeField(auto_now_add=True, help_text='date and time at which a record was created', verbose_name='created on')),
+                ('updated_at', models.DateTimeField(auto_now=True, help_text='date and time at which a record was last updated', verbose_name='updated on')),
+                ('type', models.CharField(choices=[('background_image', 'Background image')], max_length=25)),
+                ('title', models.CharField(max_length=255, verbose_name='title')),
+                ('deleted_at', models.DateTimeField(blank=True, null=True)),
+                ('hard_deleted_at', models.DateTimeField(blank=True, null=True)),
+                ('filename', models.CharField(max_length=255)),
+                ('upload_state', models.CharField(choices=[('pending', 'Pending'), ('ready', 'Ready')], max_length=25)),
+                ('mimetype', models.CharField(blank=True, max_length=255, null=True)),
+                ('size', models.BigIntegerField(blank=True, null=True)),
+                ('description', models.TextField(blank=True, null=True)),
+                ('malware_detection_info', models.JSONField(blank=True, default=dict, help_text='Malware detection info when the analysis status is unsafe.', null=True)),
+                ('creator', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.RESTRICT, related_name='files_created', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'verbose_name': 'File',
+                'verbose_name_plural': 'Files',
+                'db_table': 'file',
+                'ordering': ('created_at',),
+                'indexes': [models.Index(fields=['creator', 'type', '-created_at'], name='file_creator_730cce_idx')],
+            },
+        ),
+    ]

src/backend/core/migrations/0018_rename_active_application_is_active.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.2.12 on 2026-03-11 14:39
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0017_file'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='application',
+            old_name='active',
+            new_name='is_active',
+        ),
+    ]

src/backend/core/migrations/0019_user_unique_email_when_sub_is_null.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.2.14 on 2026-06-02 17:31
+
+import django.db.models.functions.text
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('auth', '0012_alter_user_first_name_max_length'),
+        ('core', '0018_rename_active_application_is_active'),
+    ]
+
+    operations = [
+        migrations.AddConstraint(
+            model_name='user',
+            constraint=models.UniqueConstraint(django.db.models.functions.text.Lower('email'), condition=models.Q(('sub__isnull', True)), name='unique_email_when_sub_is_null'),
+        ),
+    ]

src/backend/core/migrations/0020_alter_file_upload_state.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.2.14 on 2026-06-03 12:14
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0019_user_unique_email_when_sub_is_null'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='file',
+            name='upload_state',
+            field=models.CharField(choices=[('pending', 'Pending'), ('analyzing', 'Analyzing'), ('ready', 'Ready')], max_length=25),
+        ),
+    ]

src/backend/core/models.py

@@ -1,11 +1,14 @@
 """
 Declare and configure the models for the Meet core application
+# pylint: disable=too-many-lines
 """
+# pylint: disable=too-many-lines
 
 import secrets
 import uuid
 from datetime import datetime, timedelta
 from logging import getLogger
+from os.path import splitext
 from typing import List, Optional
 
 from django.conf import settings
@@ -14,7 +17,7 @@ from django.contrib.auth.base_user import AbstractBaseUser
 from django.contrib.postgres.fields import ArrayField
 from django.core import mail, validators
 from django.core.exceptions import PermissionDenied, ValidationError
-from django.db import models
+from django.db import models, transaction
 from django.utils import timezone
 from django.utils.text import capfirst, slugify
 from django.utils.translation import gettext_lazy as _
@@ -208,6 +211,13 @@ class User(AbstractBaseUser, BaseModel, auth_models.PermissionsMixin):
         ordering = ("-created_at",)
         verbose_name = _("user")
         verbose_name_plural = _("users")
+        constraints = [
+            models.UniqueConstraint(
+                models.functions.Lower("email"),
+                condition=models.Q(sub__isnull=True),
+                name="unique_email_when_sub_is_null",
+            )
+        ]
 
     def __str__(self):
         return self.email or self.admin_email or str(self.id)
@@ -385,6 +395,7 @@ class Room(Resource):
         choices=RoomAccessLevel.choices,
         default=settings.RESOURCE_DEFAULT_ACCESS_LEVEL,
     )
+    # Public configuration exposed to any room participant via the API
     configuration = models.JSONField(
         blank=True,
         default=dict,
@@ -756,7 +767,7 @@ class Application(BaseModel):
         verbose_name=_("Application name"),
         help_text=_("Descriptive name for this application."),
     )
-    active = models.BooleanField(default=True)
+    is_active = models.BooleanField(default=True)
     client_id = models.CharField(
         max_length=100, unique=True, default=utils.generate_client_id
     )
@@ -829,3 +840,202 @@ class ApplicationDomain(BaseModel):
 
         self.domain = self.domain.lower().strip()
         super().save(*args, **kwargs)
+
+
+class FileUploadStateChoices(models.TextChoices):
+    """Possible states of a file."""
+
+    PENDING = "pending", _("Pending")
+    ANALYZING = "analyzing", _("Analyzing")
+    # Commented out for now, as we may need this when we implement the malware detection logic.
+    # SUSPICIOUS = "suspicious", _("Suspicious")
+    # FILE_TOO_LARGE_TO_ANALYZE = (
+    #     "file_too_large_to_analyze",
+    #     _("File too large to analyze"),
+    # )
+    READY = "ready", _("Ready")
+
+
+class FileTypeChoices(models.TextChoices):
+    """Defines the possible types of a file."""
+
+    BACKGROUND_IMAGE = "background_image", _("Background image")
+
+
+class File(BaseModel):
+    """File uploaded by a user."""
+
+    type = models.CharField(
+        max_length=25,
+        choices=FileTypeChoices.choices,
+        null=False,
+        blank=False,
+    )
+    title = models.CharField(_("title"), max_length=255)
+    creator = models.ForeignKey(
+        User,
+        on_delete=models.RESTRICT,
+        related_name="files_created",
+        blank=True,
+        null=True,
+    )
+    deleted_at = models.DateTimeField(null=True, blank=True)
+    hard_deleted_at = models.DateTimeField(null=True, blank=True)
+
+    filename = models.CharField(max_length=255, null=False, blank=False)
+
+    upload_state = models.CharField(
+        max_length=25,
+        choices=FileUploadStateChoices.choices,
+    )
+    mimetype = models.CharField(max_length=255, null=True, blank=True)
+    size = models.BigIntegerField(null=True, blank=True)
+    description = models.TextField(null=True, blank=True)
+    malware_detection_info = models.JSONField(
+        null=True,
+        blank=True,
+        default=dict,
+        help_text=_("Malware detection info when the analysis status is unsafe."),
+    )
+
+    class Meta:
+        db_table = "file"
+        verbose_name = _("File")
+        verbose_name_plural = _("Files")
+        ordering = ("created_at",)
+        indexes = [
+            models.Index(fields=["creator", "type", "-created_at"]),
+        ]
+
+    def __str__(self):
+        return str(self.title)
+
+    def save(self, *args, **kwargs):
+        """Set the upload state to pending if it's the first save and it's a file."""
+
+        if self.created_at is None:
+            self.upload_state = FileUploadStateChoices.PENDING
+
+        return super().save(*args, **kwargs)
+
+    def delete(self, using=None, keep_parents=False):
+        if self.deleted_at is None:
+            raise RuntimeError("The file must be soft deleted before being deleted.")
+
+        return super().delete(using, keep_parents)
+
+    @property
+    def is_ready(self):
+        """Return whether the file is in a ready upload state"""
+        return self.upload_state == FileUploadStateChoices.READY
+
+    @property
+    def extension(self):
+        """Return the extension related to the filename."""
+        if self.filename is None:
+            raise RuntimeError(
+                "The file must have a filename to compute its extension."
+            )
+
+        _, extension = splitext(self.filename)
+
+        if extension:
+            return extension.lstrip(".")
+
+        return None
+
+    @property
+    def key_base(self):
+        """Key base of the location where the file is stored in object storage."""
+        if not self.pk:
+            raise RuntimeError(
+                "The file instance must be saved before requesting a storage key."
+            )
+
+        return f"{settings.FILE_UPLOAD_PATH}/{self.pk!s}"
+
+    @property
+    def temporary_key_base(self):
+        """Temporary key base used while upload is still pending."""
+        if not self.pk:
+            raise RuntimeError(
+                "The file instance must be saved before requesting a storage key."
+            )
+
+        return f"{settings.FILE_UPLOAD_TMP_PATH}/{self.pk!s}"
+
+    @property
+    def file_key(self):
+        """Key used to store the file in object storage."""
+        _, extension = splitext(self.filename)
+        # We store only the extension in the storage system to avoid
+        # leaking Personal Information in logs, etc.
+        return f"{self.key_base}{extension!s}"
+
+    @property
+    def temporary_file_key(self):
+        """Temporary key used to upload the file before it is finalized."""
+        _, extension = splitext(self.filename)
+        return f"{self.temporary_key_base}{extension!s}"
+
+    def get_abilities(self, user):
+        """
+        Compute and return abilities for a given user on the file.
+        """
+        # Characteristics that are based only on specific access
+        is_creator = user == self.creator
+        retrieve = is_creator
+        is_deleted = self.deleted_at is not None
+        can_update = is_creator and not is_deleted and user.is_authenticated
+        can_hard_delete = is_creator and user.is_authenticated
+        can_destroy = can_hard_delete and not is_deleted
+
+        return {
+            "destroy": can_destroy,
+            "hard_delete": can_hard_delete,
+            "retrieve": retrieve,
+            "media_auth": retrieve and not is_deleted,
+            "partial_update": can_update,
+            "update": can_update,
+            "upload_ended": can_update and user.is_authenticated,
+        }
+
+    @transaction.atomic
+    def soft_delete(self):
+        """
+        Soft delete the file.
+        We still keep the .delete() method untouched for programmatic purposes.
+        """
+        if self.deleted_at:
+            raise RuntimeError("This file is already deleted.")
+
+        self.deleted_at = timezone.now()
+        self.save(update_fields=["deleted_at"])
+
+    def hard_delete(self):
+        """
+        Hard delete the file.
+        We still keep the .delete() method untouched for programmatic purposes.
+        """
+        if self.hard_deleted_at:
+            raise ValidationError(
+                {
+                    "hard_deleted_at": ValidationError(
+                        _("This file is already hard deleted."),
+                        code="file_hard_delete_already_effective",
+                    )
+                }
+            )
+
+        if self.deleted_at is None:
+            raise ValidationError(
+                {
+                    "hard_deleted_at": ValidationError(
+                        _("To hard delete a file, it must first be soft deleted."),
+                        code="file_hard_delete_should_soft_delete_first",
+                    )
+                }
+            )
+
+        self.hard_deleted_at = timezone.now()
+        self.save(update_fields=["hard_deleted_at"])

src/backend/core/recording/event/notification.py

@@ -1,7 +1,9 @@
 """Service to notify external services when a new recording is ready."""
 
+import asyncio
 import logging
 import smtplib
+from datetime import datetime, timezone
 
 from django.conf import settings
 from django.core.mail import send_mail
@@ -9,9 +11,12 @@ from django.template.loader import render_to_string
 from django.utils.translation import get_language, override
 from django.utils.translation import gettext_lazy as _
 
+import aiohttp
 import requests
+from asgiref.sync import async_to_sync
+from livekit import api as livekit_api
 
-from core import models
+from core import models, utils
 
 logger = logging.getLogger(__name__)
 
@@ -131,7 +136,50 @@ class NotificationService:
         return not has_failures
 
     @staticmethod
-    def _notify_summary_service(recording):
+    async def _get_recording_timestamps(worker_id):
+        """Fetch FileInfo.started_at and ended_at from LiveKit's egress API.
+
+        FileInfo.started_at is more accurate than EgressInfo.started_at because
+        it reflects when file recording actually began. The started_at value exposed
+        in the manifest file, as well as in the EgressInfo returned by the API,
+        corresponds to when the egress service received the request, not the moment
+        the egress worker effectively joined the room.
+
+        Returns:
+            Tuple of (started_at, ended_at) datetimes, either may be None.
+        """
+
+        if not worker_id:
+            return None, None
+
+        custom_configuration = {
+            **settings.LIVEKIT_CONFIGURATION,
+            "timeout": aiohttp.ClientTimeout(total=10),
+        }
+        lkapi = utils.create_livekit_client(custom_configuration=custom_configuration)
+        try:
+            egress_list = await lkapi.egress.list_egress(
+                livekit_api.ListEgressRequest(egress_id=worker_id)  # pylint: disable=no-member
+            )
+        except (livekit_api.TwirpError, OSError, asyncio.TimeoutError):
+            logger.exception("Could not fetch egress info for worker %s", worker_id)
+            return None, None
+        finally:
+            await lkapi.aclose()
+
+        if not egress_list.items or not egress_list.items[0].file_results:
+            logger.debug("No file_results for worker %s", worker_id)
+            return None, None
+
+        file_result = egress_list.items[0].file_results[0]
+
+        def _ns_to_utc(ns):
+            return datetime.fromtimestamp(ns / 1e9, tz=timezone.utc) if ns else None
+
+        return _ns_to_utc(file_result.started_at), _ns_to_utc(file_result.ended_at)
+
+    @staticmethod
+    def _notify_summary_service(recording: models.Recording):
         """Notify summary service about a new recording."""
 
         if (
@@ -150,24 +198,35 @@ class NotificationService:
             .first()
         )
 
+        if settings.METADATA_COLLECTOR_ENABLED and recording.options.get(
+            "collect_metadata", False
+        ):
+            output_folder = settings.METADATA_COLLECTOR_OUTPUT_FOLDER
+            metadata_filename = f"{output_folder}/{recording.id}-metadata.json"
+        else:
+            metadata_filename = None
+
         if not owner_access:
             logger.error("No owner found for recording %s", recording.id)
             return False
+
+        started_at, ended_at = async_to_sync(
+            NotificationService._get_recording_timestamps
+        )(recording.worker_id)
+
         payload = {
             "owner_id": str(owner_access.user.id),
-            "filename": recording.key,
+            "recording_filename": recording.key,
+            "metadata_filename": metadata_filename,
             "email": owner_access.user.email,
             "sub": owner_access.user.sub,
             "room": recording.room.name,
             "language": recording.options.get("language"),
-            "recording_date": recording.created_at.astimezone(
-                owner_access.user.timezone
-            ).strftime("%Y-%m-%d"),
-            "recording_time": recording.created_at.astimezone(
-                owner_access.user.timezone
-            ).strftime("%H:%M"),
+            "owner_timezone": str(owner_access.user.timezone),
             "download_link": f"{get_recording_download_base_url()}/{recording.id}",
             "context_language": owner_access.user.language,
+            "recording_start_at": (started_at.isoformat() if started_at else None),
+            "recording_end_at": (ended_at.isoformat() if ended_at else None),
         }
 
         headers = {

src/backend/core/recording/event/parsers.py

@@ -1,6 +1,7 @@
 """Meet storage event parser classes."""
 
 import logging
+import mimetypes
 import re
 from dataclasses import dataclass
 from functools import lru_cache
@@ -9,6 +10,8 @@ from typing import Any, Dict, Optional, Protocol
 from django.conf import settings
 from django.utils.module_loading import import_string
 
+from core.enums import FILE_EXT_REGEX, UUID_REGEX
+
 from .exceptions import (
     InvalidBucketError,
     InvalidFilepathError,
@@ -16,6 +19,9 @@ from .exceptions import (
     ParsingEventDataError,
 )
 
+# Additional MIME type mapping
+mimetypes.add_type("audio/ogg", ".ogg")
+
 logger = logging.getLogger(__name__)
 
 
@@ -72,8 +78,8 @@ def get_parser() -> EventParser:
     return event_parser_cls(bucket_name=settings.AWS_STORAGE_BUCKET_NAME)
 
 
-class MinioParser:
-    """Handle parsing and validation of Minio storage events."""
+class BaseS3Parser:
+    """Base class for handling parsing and validation of S3-compatible storage events."""
 
     def __init__(self, bucket_name: str, allowed_filetypes=None):
         """Initialize parser with target bucket name and accepted filetypes."""
@@ -86,35 +92,9 @@ class MinioParser:
 
         # pylint: disable=line-too-long
         self._filepath_regex = re.compile(
-            r"(?P<url_encoded_folder_path>(?:[^%]+%2F)+)?(?P<recording_id>[0-9a-fA-F\-]{36})\.(?P<extension>[a-zA-Z0-9]+)"
+            rf"(?P<url_encoded_folder_path>(?:[^%]+%2F)+)?{settings.RECORDING_OUTPUT_FOLDER}%2F(?P<recording_id>{UUID_REGEX})\.(?P<extension>{FILE_EXT_REGEX})"
         )
 
-    @staticmethod
-    def parse(data):
-        """Convert raw Minio event dictionary to StorageEvent object."""
-
-        if not data:
-            raise ParsingEventDataError("Received empty data.")
-
-        try:
-            record = data["Records"][0]
-            s3 = record["s3"]
-            bucket_name = s3["bucket"]["name"]
-            file_object = s3["object"]
-            filepath = file_object["key"]
-            filetype = file_object["contentType"]
-        except (KeyError, IndexError) as e:
-            raise ParsingEventDataError(f"Missing or malformed key: {e}.") from e
-        try:
-            return StorageEvent(
-                filepath=filepath,
-                filetype=filetype,
-                bucket_name=bucket_name,
-                metadata=None,
-            )
-        except TypeError as e:
-            raise ParsingEventDataError(f"Missing essential data fields: {e}") from e
-
     def validate(self, event_data: StorageEvent) -> str:
         """Verify StorageEvent matches bucket, filetype and filepath requirements."""
 
@@ -139,9 +119,56 @@ class MinioParser:
         return recording_id
 
     def get_recording_id(self, data):
-        """Extract recording ID from Minio event through parsing and validation."""
+        """Extract recording ID from S3 event through parsing and validation."""
 
         event_data = self.parse(data)
-        recording_id = self.validate(event_data)
+        return self.validate(event_data)
 
-        return recording_id
+    def parse(self, data: Dict) -> StorageEvent:
+        """To be implemented by subclasses."""
+        raise NotImplementedError("Subclasses must implement parse()")
+
+
+class MinioParser(BaseS3Parser):
+    """Minio specific event parsing."""
+
+    def parse(self, data: Dict) -> StorageEvent:
+        if not data:
+            raise ParsingEventDataError("Received empty data.")
+        try:
+            record = data["Records"][0]
+            s3 = record["s3"]
+            return StorageEvent(
+                filepath=s3["object"]["key"],
+                filetype=s3["object"]["contentType"],  # Minio-specific field
+                bucket_name=s3["bucket"]["name"],
+                metadata=None,
+            )
+        except (KeyError, IndexError) as e:
+            raise ParsingEventDataError(f"Malformed Minio event: {e}") from e
+        except TypeError as e:
+            raise ParsingEventDataError(f"Missing essential data fields: {e}") from e
+
+
+class S3Parser(BaseS3Parser):
+    """AWS S3 specific event parsing."""
+
+    def parse(self, data: Dict) -> StorageEvent:
+        if not data:
+            raise ParsingEventDataError("Received empty data.")
+        try:
+            # AWS S3 structure can slightly differ from Minio implementation
+            record = data["Records"][0]
+            s3 = record["s3"]
+            filepath = s3["object"]["key"]
+            if not filepath:
+                raise ParsingEventDataError("Missing object key name")
+            filetype, _ = mimetypes.guess_type(filepath)
+            return StorageEvent(
+                filepath=filepath,
+                filetype=filetype,
+                bucket_name=s3["bucket"]["name"],
+                metadata=None,
+            )
+        except (KeyError, IndexError) as e:
+            raise ParsingEventDataError(f"Malformed S3 event: {e}") from e

src/backend/core/recording/services/metadata_collector.py

@@ -0,0 +1,91 @@
+"""Meeting metadata collection service."""
+
+from logging import getLogger
+
+from django.conf import settings
+
+from asgiref.sync import async_to_sync, sync_to_async
+from livekit.protocol.agent_dispatch import (
+    CreateAgentDispatchRequest,
+)
+
+from core import utils
+from core.models import Recording
+
+logger = getLogger(__name__)
+
+
+class MetadataCollectorException(Exception):
+    """Generic exception in the metadata collector."""
+
+
+class MetadataCollectorService:
+    """Service for dispatching and managing the metadata collector agent."""
+
+    @async_to_sync
+    async def start(self, recording: Recording):
+        """Explicitly dispatch the metadata collector agent to a room."""
+
+        lkapi = utils.create_livekit_client()
+        room_id = str(recording.room.id)
+
+        try:
+            response = await lkapi.agent_dispatch.create_dispatch(
+                CreateAgentDispatchRequest(
+                    agent_name=settings.METADATA_COLLECTOR_AGENT_NAME,
+                    room=room_id,
+                    metadata=str(recording.id),
+                )
+            )
+        except Exception as e:
+            logger.exception(
+                "Failed to create metadata collector agent for room %s", room_id
+            )
+            raise MetadataCollectorException(
+                "Failed to create metadata collector agent"
+            ) from e
+        finally:
+            await lkapi.aclose()
+
+        dispatch_id = getattr(response, "id", None)
+
+        if not dispatch_id:
+            logger.error("LiveKit response missing dispatch ID for room %s", room_id)
+            raise MetadataCollectorException(
+                f"LiveKit did not return a dispatch_id for room {room_id}"
+            )
+
+        recording.options["metadata_collector_dispatch_id"] = dispatch_id
+        await sync_to_async(recording.save)(update_fields=["options"])
+
+        return dispatch_id
+
+    @async_to_sync
+    async def stop(self, recording: Recording):
+        """Stop and delete the agent dispatch associated to the room."""
+
+        room_id = str(recording.room.id)
+        dispatch_id = recording.options.get("metadata_collector_dispatch_id")
+        lkapi = utils.create_livekit_client()
+
+        try:
+            if not dispatch_id:
+                logger.warning(
+                    "No metadata collector dispatch ID stored for room %s", room_id
+                )
+                return None
+
+            await lkapi.agent_dispatch.delete_dispatch(
+                dispatch_id=str(dispatch_id), room_name=room_id
+            )
+
+        except Exception as e:
+            logger.exception(
+                "Failed to stop metadata collector agent dispatch for room %s",
+                room_id,
+            )
+            raise MetadataCollectorException(
+                f"Failed to stop metadata collector agent for room {room_id}"
+            ) from e
+        finally:
+            await lkapi.aclose()