wip functional setup without keycloak and silent login

Change to reduce memory usage in dev.

CHANGELOG.md

@@ -14,11 +14,12 @@ and this project adheres to
 - ✨(frontend) add configurable documentation menu item
 - ✨(frontend) allow promoting authenticated participants
 - ✨(frontend) introduce an "unauthenticated" participant badge
+- ✨(backend) add roomkit viewset to start a room without WebRTC join
 
 ### Changed
 
 - ⬆️(frontend) upgrade @mediapipe/tasks-vision from 0.10.14 to 0.10.35
-- ⬆️(frontend) upgrade i18next from 26.3.1 to 26.3.4
+- ⬆️(frontend) upgrade i18next from 26.3.1 to 26.3.6
 - ⬆️(frontend) upgrade posthog-js from 1.391.2 to 1.395.0
 - ⬆️(frontend) upgrade @tanstack/react-query from 5.101.0 to 5.101.1
 - ⬆️(frontend) upgrade livekit-client from 2.19.2 to 2.20.0
@@ -26,6 +27,7 @@ and this project adheres to
 - 📝(legal) update terms of service
 - 💄(frontend) render Avatar initials in uppercase
 - 💄(frontend) improve participant name rendering in the list
+- 🚚(backend) rename TelephonyService to SIPManagement
 
 ## Fixed
 

Makefile

@@ -44,6 +44,7 @@ COMPOSE_EXEC        = $(COMPOSE) exec
 COMPOSE_EXEC_APP    = $(COMPOSE_EXEC) app-dev
 COMPOSE_RUN         = $(COMPOSE) run --rm
 COMPOSE_RUN_APP     = $(COMPOSE_RUN) app-dev
+COMPOSE_RUN_LINT    = $(COMPOSE_RUN) --no-deps app-dev
 COMPOSE_RUN_CROWDIN = $(COMPOSE_RUN) crowdin crowdin
 WAIT_DB             = @$(COMPOSE_RUN) dockerize -wait tcp://$(DB_HOST):$(DB_PORT) -timeout 60s
 
@@ -51,6 +52,14 @@ WAIT_DB             = @$(COMPOSE_RUN) dockerize -wait tcp://$(DB_HOST):$(DB_PORT
 MANAGE              = $(COMPOSE_RUN_APP) python manage.py
 MAIL_NPM            = $(COMPOSE_RUN) -w /app/src/mail node npm
 
+# -- Linters
+LINT_RUFF_FORMAT    = ruff format .
+LINT_RUFF_CHECK     = ruff check . --fix
+LINT_PYLINT         = pylint meet demo core
+LINT_BACK           = echo 'lint:ruff-format started…' && $(LINT_RUFF_FORMAT) \
+  && echo 'lint:ruff-check started…' && $(LINT_RUFF_CHECK) \
+  && echo 'lint:pylint started…' && $(LINT_PYLINT)
+
 # -- Frontend
 PATH_FRONT          = ./src/frontend
 
@@ -72,7 +81,6 @@ create-env-files: \
 	env.d/development/common \
 	env.d/development/crowdin \
 	env.d/development/postgresql \
-	env.d/development/kc_postgresql \
 	env.d/development/summary \
 	env.d/development/kube-secret \
 	env.d/development/multi_user_transcriber \
@@ -124,6 +132,7 @@ logs: ## display app-dev logs (follow mode)
 run-backend: ## start only the backend application and all needed services
 	@$(COMPOSE) up --force-recreate -d celery-dev --remove-orphans
 	@$(COMPOSE) up --force-recreate -d nginx
+	@$(COMPOSE) up -d livekit
 	@echo "Wait for postgresql to be up..."
 	@$(WAIT_DB)
 .PHONY: run-backend
@@ -188,27 +197,23 @@ demo: ## flush db then create a demo for load testing purpose
 	@$(MANAGE) create_demo
 .PHONY: demo
 
-# Nota bene: Black should come after isort just in case they don't agree...
 lint: ## lint back-end python sources
-lint: \
-  lint-ruff-format \
-  lint-ruff-check \
-  lint-pylint
+	@$(COMPOSE_RUN_LINT) sh -c "$(LINT_BACK)"
 .PHONY: lint
 
 lint-ruff-format: ## format back-end python sources with ruff
 	@echo 'lint:ruff-format started…'
-	@$(COMPOSE_RUN_APP) ruff format .
+	@$(COMPOSE_RUN_LINT) $(LINT_RUFF_FORMAT)
 .PHONY: lint-ruff-format
 
 lint-ruff-check: ## lint back-end python sources with ruff
 	@echo 'lint:ruff-check started…'
-	@$(COMPOSE_RUN_APP) ruff check . --fix
+	@$(COMPOSE_RUN_LINT) $(LINT_RUFF_CHECK)
 .PHONY: lint-ruff-check
 
 lint-pylint: ## lint back-end python sources with pylint only on changed files from main
 	@echo 'lint:pylint started…'
-	@$(COMPOSE_RUN_APP) pylint meet demo core
+	@$(COMPOSE_RUN_LINT) $(LINT_PYLINT)
 .PHONY: lint-pylint
 
 test: ## run project tests; pass extra pytest args via ARGS, e.g. `make test ARGS="-vv"`
@@ -282,9 +287,6 @@ env.d/development/common:
 env.d/development/postgresql:
 	cp -n env.d/development/postgresql.dist env.d/development/postgresql
 
-env.d/development/kc_postgresql:
-	cp -n env.d/development/kc_postgresql.dist env.d/development/kc_postgresql
-
 env.d/development/summary:
 	cp -n env.d/development/summary.dist env.d/development/summary
 
@@ -389,12 +391,6 @@ build-k8s-cluster: \
     ./bin/start-kind.sh
 .PHONY: build-k8s-cluster
 
-build-k8s-cluster-orbstack: ## setup the kubernetes environment on OrbStack's built-in cluster (macOS)
-build-k8s-cluster-orbstack: \
-    env.d/development/kube-secret
-	./bin/start-orbstack.sh
-.PHONY: build-k8s-cluster-orbstack
-
 start-tilt-keycloak: ## start the kubernetes cluster using kind, without Pro Connect for authentication, use keycloak
 	DEV_ENV=dev-keycloak tilt up --namespace=meet -f ./bin/Tiltfile
 .PHONY: build-k8s-cluster

bin/Tiltfile

@@ -1,11 +1,5 @@
 load('ext://uibutton', 'cmd_button', 'bool_input', 'location')
 load('ext://namespace', 'namespace_create', 'namespace_inject')
-
-# OrbStack's built-in cluster (macOS) is a supported alternative to kind.
-# Recent Tilt versions (>= 0.33) detect it as a local dev cluster; this is
-# a no-op for kind and a safety net for older Tilt versions.
-allow_k8s_contexts('orbstack')
-
 namespace_create('meet')
 
 DEV_ENV = os.getenv('DEV_ENV', 'dev-keycloak')

bin/start-orbstack.sh

@@ -1,182 +0,0 @@
-#!/usr/bin/env bash
-#
-# Bootstrap the local dev environment on OrbStack's built-in Kubernetes
-# cluster (macOS) instead of kind.
-#
-# This replicates what bin/start-kind.sh (numerique-gouv/tools
-# kind/create_cluster.sh) provides, minus what OrbStack makes unnecessary:
-#   - no kind cluster: OrbStack ships a lightweight single-node cluster
-#   - no local registry (kind-registry): OrbStack's cluster shares the
-#     Docker image store, so images built by Tilt are directly visible
-#     to pods. Tilt detects the "orbstack" context as a local cluster
-#     and skips pushing images entirely.
-#
-# Requirements: OrbStack (with Kubernetes enabled), kubectl, mkcert, curl.
-set -o errexit
-
-APPLICATION=${1:-meet}
-CONTEXT="orbstack"
-
-echo "0. Check OrbStack Kubernetes is available"
-if ! command -v mkcert >/dev/null 2>&1; then
-  echo "❌ mkcert is not installed. Install it first: brew install mkcert"
-  exit 1
-fi
-if ! kubectl config get-contexts -o name | grep -qx "${CONTEXT}"; then
-  echo "Context '${CONTEXT}' not found. Trying to start OrbStack Kubernetes..."
-  if command -v orb >/dev/null 2>&1; then
-    orb start k8s
-  else
-    echo "❌ Enable Kubernetes in OrbStack (Settings > Kubernetes) and retry."
-    exit 1
-  fi
-fi
-kubectl config use-context "${CONTEXT}"
-
-echo "0b. Check ports 80/443 are free on localhost"
-# OrbStack forwards LoadBalancer service ports to 127.0.0.1. If the kind
-# cluster is still running, its docker proxy already holds 80/443.
-# Skip the check if ingress-nginx is already installed here: in that case
-# the listener on 80/443 is our own LoadBalancer.
-if ! kubectl -n ingress-nginx get deployment ingress-nginx-controller >/dev/null 2>&1; then
-  for port in 80 443; do
-    if lsof -nP -iTCP:"${port}" -sTCP:LISTEN >/dev/null 2>&1; then
-      echo "❌ Port ${port} is already in use on the host."
-      echo "   If the kind cluster is running, delete it first:"
-      echo "     kind delete cluster --name suite"
-      exit 1
-    fi
-  done
-fi
-
-echo "1. Create ca"
-CURRENT_DIR=$(pwd)
-mkcert -install
-cd /tmp
-mkcert "127.0.0.1.nip.io" "*.127.0.0.1.nip.io"
-cd "${CURRENT_DIR}"
-
-echo "2. Install ingress-nginx (cloud provider: LoadBalancer service)"
-# OrbStack exposes LoadBalancer services on 127.0.0.1, so the cloud
-# manifest replaces kind's hostPort-based deploy. Every sub-step below is
-# guarded individually so the script is safe to re-run after a partial
-# failure (unlike the upstream kind script, which guards the whole block
-# on namespace existence).
-
-# Make sure no stale registry configmap tells Tilt to push to localhost:5001
-# (there is no registry on OrbStack).
-kubectl -n kube-public delete configmap local-registry-hosting --ignore-not-found
-
-if ! kubectl -n ingress-nginx get deployment ingress-nginx-controller >/dev/null 2>&1; then
-  kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/cloud/deploy.yaml
-fi
-if ! kubectl -n ingress-nginx get deployment nginx-errors >/dev/null 2>&1; then
-  kubectl apply -n ingress-nginx -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/refs/heads/main/docs/examples/customization/custom-errors/custom-default-backend.yaml
-fi
-kubectl -n ingress-nginx create secret tls mkcert --key /tmp/127.0.0.1.nip.io+1-key.pem --cert /tmp/127.0.0.1.nip.io+1.pem || echo ok
-
-# The meet charts render Ingresses without ingressClassName. The kind
-# provider manifest handles this via --watch-ingress-without-class=true;
-# the cloud manifest does not, so add it here (otherwise: 404 everywhere).
-if ! kubectl -n ingress-nginx get deployment ingress-nginx-controller -o jsonpath='{.spec.template.spec.containers[0].args}' | grep -q 'watch-ingress-without-class'; then
-  kubectl -n ingress-nginx patch deployments.apps ingress-nginx-controller --type 'json' -p '[{"op": "add", "path": "/spec/template/spec/containers/0/args/-", "value":"--watch-ingress-without-class=true"},{"op": "add", "path": "/spec/template/spec/containers/0/args/-", "value":"--default-ssl-certificate=ingress-nginx/mkcert"},{"op": "add", "path": "/spec/template/spec/containers/0/args/-", "value":"--default-backend-service=ingress-nginx/nginx-errors"}
-]'
-fi
-if ! kubectl -n ingress-nginx get deployment nginx-errors -o jsonpath='{.spec.template.spec.containers[0].image}' | grep -q 'error-pages'; then
-  kubectl -n ingress-nginx patch deployment nginx-errors --type=json -p='[
-  {"op": "replace", "path": "/spec/template/spec/containers/0/image", "value": "ghcr.io/tarampampam/error-pages:3.3.0"},
-  {"op": "add", "path": "/spec/template/spec/containers/0/env", "value": [{"name": "TEMPLATE_NAME", "value": "ghost"}, {"name": "SHOW_DETAILS", "value": "false"}, {"name": "SEND_SAME_HTTP_CODE", "value": "true"}]}
-]'
-fi
-cat <<EOF | kubectl apply -n ingress-nginx -f -
-  apiVersion: v1
-  data:
-    allow-snippet-annotations: "true"
-    annotations-risk-level: Critical
-    custom-http-errors: 500,501,502,503,504
-  kind: ConfigMap
-  metadata:
-    name: ingress-nginx-controller
-    namespace: ingress-nginx
-EOF
-
-echo "2b. Wait for the ingress controller to be ready"
-kubectl -n ingress-nginx rollout status deployment/ingress-nginx-controller --timeout=180s
-
-echo "3. Patch CoreDNS so in-cluster pods resolve *.127.0.0.1.nip.io to the ingress"
-# nip.io resolves to 127.0.0.1, which inside a pod is the pod itself.
-# Rewrite these names to the ingress-nginx service, like the kind setup does.
-# Unlike kind, we amend OrbStack's existing Corefile instead of replacing it.
-if ! kubectl -n kube-system get configmap coredns -o jsonpath='{.data.Corefile}' | grep -q '127\.0\.0\.1\.nip\.io'; then
-  kubectl -n kube-system get configmap coredns -o jsonpath='{.data.Corefile}' \
-    | awk '/forward \./ && !done { print "    rewrite stop {"; print "      name regex (.*).127.0.0.1.nip.io ingress-nginx-controller.ingress-nginx.svc.cluster.local answer auto"; print "    }"; done=1 } { print }' \
-    >/tmp/Corefile.orbstack
-  kubectl -n kube-system create configmap coredns --from-file=Corefile=/tmp/Corefile.orbstack --dry-run=client -o yaml | kubectl apply -f -
-  kubectl -n kube-system rollout restart deployments/coredns
-fi
-
-if ! kubectl get ns "${APPLICATION}" >/dev/null 2>&1; then
-  echo "4. Setup namespace"
-  kubectl create ns "${APPLICATION}"
-fi
-kubectl config set-context --current --namespace="${APPLICATION}"
-kubectl -n "${APPLICATION}" create secret generic mkcert --from-file=rootCA.pem="$(mkcert -CAROOT)/rootCA.pem" || echo ok
-
-if ! kubectl get configmap certifi -n "${APPLICATION}" >/dev/null 2>&1; then
-  echo "5. Inject our custom CA in a configmap for certifi"
-  curl https://raw.githubusercontent.com/certifi/python-certifi/refs/heads/master/certifi/cacert.pem -o /tmp/cacert.pem
-  cat "$(mkcert -CAROOT)/rootCA.pem" >>/tmp/cacert.pem
-  kubectl -n "${APPLICATION}" create configmap certifi --from-file=cacert.pem=/tmp/cacert.pem
-  kubectl -n "${APPLICATION}" create secret generic certifi --from-file=/tmp/cacert.pem || echo ok
-fi
-
-echo "5b. Smoke test: the ingress chain answers on https://127.0.0.1"
-# Before Tilt deploys the app this returns the styled 404 from the default
-# backend — that still proves LB -> controller works. 000 means the
-# LoadBalancer is not bound to localhost.
-HTTP_CODE=$(curl -sk -o /dev/null -w '%{http_code}' --max-time 10 https://127.0.0.1/ || true)
-if [ "${HTTP_CODE}" = "000" ]; then
-  echo "⚠️  Nothing answered on https://127.0.0.1 — check the LoadBalancer:"
-  echo "    kubectl -n ingress-nginx get svc ingress-nginx-controller"
-else
-  echo "✅ Ingress reachable (HTTP ${HTTP_CODE})"
-fi
-
-echo "6. Check pod readiness across all namespaces..."
-
-sleep_interval=10
-
-echo "Initial wait time: $((sleep_interval * 2)) seconds…"
-sleep $((sleep_interval * 2))
-
-check_pods_ready() {
-    local max_attempts=60  # Maximum number of attempts (10 minutes with 10s intervals)
-    local attempt=1
-
-    while [ $attempt -le $max_attempts ]; do
-        echo "Attempt $attempt/$max_attempts - Checking pod status..."
-
-        not_ready_count=$( kubectl get po -A --no-headers | grep -v -E "Running|Completed"| wc -l | tr -d ' ')
-
-        if [ "$not_ready_count" -eq 0 ]; then
-            echo "✅ All pods are ready!"
-            return 0
-        else
-            echo "⏳ $not_ready_count pod(s) still not ready. Waiting $sleep_interval seconds…"
-            sleep $sleep_interval
-            ((attempt++))
-        fi
-    done
-
-    echo "❌ Timeout: Some pods are still not ready after 10 minutes"
-    echo "Final pod status:"
-    kubectl get po -A
-    return 1
-}
-
-if check_pods_ready; then
-    echo "🎉 Cluster is fully ready!"
-else
-    echo "⚠️  Some pods may need manual intervention"
-    exit 1
-fi

compose.yml

@@ -85,7 +85,6 @@ services:
         - postgresql
         - mailcatcher
         - redis
-        - livekit
         - createbuckets
         - createwebhook
     extra_hosts:
@@ -97,7 +96,7 @@ services:
   celery-dev:
     user: ${DOCKER_USER:-1000}
     image: meet:backend-development
-    command: ["celery", "-A", "meet.celery_app", "worker", "-l", "DEBUG"]
+    command: ["celery", "-A", "meet.celery_app", "worker", "-l", "DEBUG", "--pool=solo"]
     environment:
       - DJANGO_CONFIGURATION=Development
     env_file:
@@ -132,7 +131,7 @@ services:
   celery:
     user: ${DOCKER_USER:-1000}
     image: meet:backend-production
-    command: ["celery", "-A", "meet.celery_app", "worker", "-l", "INFO"]
+    command: ["celery", "-A", "meet.celery_app", "worker", "-l", "INFO", "--pool=solo"]
     environment:
       - DJANGO_CONFIGURATION=Demo
     env_file:
@@ -148,7 +147,7 @@ services:
     volumes:
       - ./docker/files/etc/nginx/conf.d:/etc/nginx/conf.d:ro
     depends_on:
-      - keycloak
+      - dex
       - app-dev
     networks:
       - resource-server
@@ -188,40 +187,16 @@ services:
     volumes:
       - ".:/app"
 
-  kc_postgresql:
-    image: postgres:14.3
-    ports:
-      - "5433:5432"
-    env_file:
-      - env.d/development/kc_postgresql
-
-  keycloak:
-    image: quay.io/keycloak/keycloak:20.0.1
+  # OIDC provider for the development stack. Dex uses in-memory storage, so it
+  # needs no database and no volume: restarting it rotates the signing keys and
+  # drops every active session, which is fine locally.
+  dex:
+    image: dexidp/dex:v2.45.1
+    command: ["dex", "serve", "/etc/dex/config.yaml"]
     volumes:
-      - ./docker/auth/realm.json:/opt/keycloak/data/import/realm.json
-    command:
-      - start-dev
-      - --features=preview
-      - --import-realm
-      - --proxy=edge
-      - --hostname-url=http://localhost:8083
-      - --hostname-admin-url=http://localhost:8083/
-      - --hostname-strict=false
-      - --hostname-strict-https=false
-    environment:
-      KEYCLOAK_ADMIN: admin
-      KEYCLOAK_ADMIN_PASSWORD: admin
-      KC_DB: postgres
-      KC_DB_URL_HOST: kc_postgresql
-      KC_DB_URL_DATABASE: keycloak
-      KC_DB_PASSWORD: pass
-      KC_DB_USERNAME: meet
-      KC_DB_SCHEMA: public
-      PROXY_ADDRESS_FORWARDING: 'true'
-    ports:
-      - "8080:8080"
-    depends_on:
-      - kc_postgresql
+      - ./docker/auth/dex.yaml:/etc/dex/config.yaml:ro
+    expose:
+      - "5556"
 
   livekit:
     image: livekit/livekit-server

docker/auth/dex.yaml

@@ -0,0 +1,93 @@
+# Dex configuration for the local development stack.
+#
+# This file replaces the former Keycloak "meet" realm (docker/auth/realm.json).
+# The client and the users below are a one-to-one port of that realm.
+#
+# Storage is in-memory on purpose: no database container, no volume, ~30 MB of
+# RAM instead of the Keycloak + PostgreSQL pair. The trade-off is that
+# restarting the `dex` service rotates the signing keys and drops every active
+# session, so you have to log in again.
+
+# Must match OIDC_OP_URL in env.d/development/common. Dex serves all of its
+# endpoints under the path component of the issuer, i.e. /dex/auth, /dex/token,
+# /dex/keys, /dex/userinfo and /dex/.well-known/openid-configuration.
+issuer: http://localhost:8083/dex
+
+storage:
+  type: memory
+
+web:
+  http: 0.0.0.0:5556
+  allowedOrigins:
+    - http://localhost:3000
+    - http://localhost:8071
+
+logger:
+  level: info
+  format: text
+
+oauth2:
+  # Logging in implies authorization: no consent screen, as with the realm.
+  skipApprovalScreen: true
+
+expiry:
+  idTokens: 24h
+  signingKeys: 6h
+
+staticClients:
+  - id: meet
+    name: Meet
+    secret: ThisIsAnExampleKeyForDevPurposeOnly
+    # Dex does not support wildcards: every callback URL must be listed
+    # explicitly. The path is the one exposed by mozilla-django-oidc through
+    # lasuite.oidc_login, mounted under api/<version>/ by core.urls.
+    redirectURIs:
+      - http://localhost:3000/api/v1.0/callback/
+      - http://localhost:3200/api/v1.0/callback/
+      - http://localhost:8070/api/v1.0/callback/
+      - http://localhost:8071/api/v1.0/callback/
+      - http://localhost:8088/api/v1.0/callback/
+
+enablePasswordDB: true
+
+# Dex's local password database authenticates on the *email address*, not on
+# the username, so the login is now "meet@meet.world" (password unchanged).
+#
+# Hashes are bcrypt with cost 10, the minimum dex accepts. To add a user:
+#   htpasswd -bnBC 10 "" <password> | tr -d ':\n'
+staticPasswords:
+  - email: meet@meet.world
+    hash: "$2b$10$qVCVTnaF67S/7a.pQM4djOgpj61FxD/yz6LoiQdtX0TKISelAfZxC"
+    username: meet
+    name: John Doe
+    preferredUsername: John
+    userID: 4ad6106f-a64f-43eb-ad0e-380d2cad9a9d
+    groups:
+      - user
+
+  - email: user@chromium.e2e
+    hash: "$2b$10$4Rs3Jd/Q23RM09g7c1Z/yeGmEjoAYlMKXDBkkjERaRDlz0Doiwl2q"
+    username: user-e2e-chromium
+    name: E2E Chromium
+    preferredUsername: E2E
+    userID: 1cd83dfc-153f-4987-b8a6-a2ac72d39122
+    groups:
+      - user
+
+  - email: user@webkit.e2e
+    hash: "$2b$10$D50UlVVMA7qWlB.Pw8P02eMJpo8qfwWuGiA63IeTqq/3mAE7RyH3m"
+    username: user-e2e-webkit
+    name: E2E Webkit
+    preferredUsername: E2E
+    userID: 9b9bd390-a6e5-42f8-a06d-9a11ede7bb8c
+    groups:
+      - user
+
+  - email: user@firefox.e2e
+    hash: "$2b$10$0D8WW7.KXMkzSY2b9JhwYeIM3WkTPQCwGd36/G3TZ/HHh4ObCVRga"
+    username: user-e2e-firefox
+    name: E2E Firefox
+    preferredUsername: E2E
+    userID: ec3e8750-7629-42f1-a0c3-6e23968a2fba
+    groups:
+      - user

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

@@ -40,7 +40,7 @@ server {
     }
 
     location / {
-        proxy_pass http://keycloak:8080;
+        proxy_pass http://dex:5556;
         proxy_set_header Host $host;
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

docker/resource-server/compose.yml

@@ -1,12 +1,13 @@
 version: '3'
 
 # You can add any necessary service here that will join the same docker network
-# sharing keycloak. Services added to the 'meet_resource-server' network will be
-# able to communicate with keycloak and the backend on that network.
+# sharing the OIDC provider. Services added to the 'meet_resource-server'
+# network will be able to communicate with dex (through nginx) and the backend
+# on that network.
 services:
   # busybox service is only used for testing purposes. It provides curl to test
-  # connectivity to the backend and keycloak services. Replace this with your
-  # relevant application services that need to communicate with keycloak.
+  # connectivity to the backend and the OIDC provider. Replace this with your
+  # relevant application services that need to communicate with them.
   busybox:
     image: alpine:latest
     privileged: true

docs/developping_locally.md

@@ -71,8 +71,12 @@ $ make bootstrap FLUSH_ARGS='--no-input'
 
 2. Access the project:
 - The frontend is available at [http://localhost:3000](http://localhost:3000) with the default credentials:
-    - username: meet
+    - email: meet@meet.world
     - password: meet
+
+  Authentication is handled by [dex](https://dexidp.io/), configured in
+  `docker/auth/dex.yaml`. It logs you in by email address, and its storage is
+  in-memory: restarting the `dex` container logs everyone out.
 - The Django backend is available at [http://localhost:8071](http://localhost:8071)
 
 ---
@@ -143,24 +147,3 @@ $ make start-tilt-keycloak
 ```
 
 Monitor Tilt’s progress at [http://localhost:10350/](http://localhost:10350/). After Tilt actions finish, you can access the app at [https://meet.127.0.0.1.nip.io/](https://meet.127.0.0.1.nip.io/).
-
-### Alternative: OrbStack's built-in Kubernetes (macOS)
-
-If you use [OrbStack](https://orbstack.dev/) on macOS, you can run the stack on its built-in Kubernetes cluster instead of kind. It uses noticeably less RAM (no nested kubeadm node container) and no local registry is needed: OrbStack's cluster shares the Docker image store, so Tilt uses images directly without pushing.
-
-Enable Kubernetes in OrbStack (Settings > Kubernetes), then:
-
-```shellscript
-$ make build-k8s-cluster-orbstack
-```
-
-This installs ingress-nginx (exposed by OrbStack on `127.0.0.1:80/443`), the mkcert TLS certificates, and the CoreDNS rewrite for `*.127.0.0.1.nip.io`, then you start Tilt as usual:
-
-```shellscript
-$ make start-tilt-keycloak
-```
-
-Notes:
-- Ports 80/443 must be free: delete the kind cluster first if you used it (`kind delete cluster --name suite`).
-- If you "Reset Kubernetes" in OrbStack, re-run `make build-k8s-cluster-orbstack`.
-- kind remains the reference setup (matches CI and lets you pin the Kubernetes version).

env.d/development/common.dist

@@ -31,24 +31,35 @@ MEDIA_BASE_URL=http://localhost:3000
 FILE_UPLOAD_ENABLED=True
 
 # OIDC
-OIDC_OP_JWKS_ENDPOINT=http://nginx:8083/realms/meet/protocol/openid-connect/certs
-OIDC_OP_AUTHORIZATION_ENDPOINT=http://localhost:8083/realms/meet/protocol/openid-connect/auth
-OIDC_OP_TOKEN_ENDPOINT=http://nginx:8083/realms/meet/protocol/openid-connect/token
-OIDC_OP_USER_ENDPOINT=http://nginx:8083/realms/meet/protocol/openid-connect/userinfo
-OIDC_OP_INTROSPECTION_ENDPOINT=http://nginx:8083/realms/meet/protocol/openid-connect/token/introspect
-OIDC_OP_URL=http://localhost:8083/realms/meet
+# Provider is dex (docker/auth/dex.yaml), served behind nginx on port 8083.
+# Endpoints reached by the browser use localhost, the ones called server-side
+# by the backend use the nginx service name.
+OIDC_OP_JWKS_ENDPOINT=http://nginx:8083/dex/keys
+OIDC_OP_AUTHORIZATION_ENDPOINT=http://localhost:8083/dex/auth
+OIDC_OP_TOKEN_ENDPOINT=http://nginx:8083/dex/token
+OIDC_OP_USER_ENDPOINT=http://nginx:8083/dex/userinfo
+OIDC_OP_INTROSPECTION_ENDPOINT=http://nginx:8083/dex/token/introspect
+OIDC_OP_URL=http://localhost:8083/dex
 
 OIDC_RP_CLIENT_ID=meet
 OIDC_RP_CLIENT_SECRET=ThisIsAnExampleKeyForDevPurposeOnly
 OIDC_RP_SIGN_ALGO=RS256
-OIDC_RP_SCOPES="openid email"
+# "profile" is required: dex only emits the name claims under that scope.
+OIDC_RP_SCOPES="openid email profile"
+
+# Dex exposes the display name through the standard "name" and
+# "preferred_username" claims and never emits given_name/family_name.
+OIDC_USERINFO_FULLNAME_FIELDS=name
+OIDC_USERINFO_SHORTNAME_FIELD=preferred_username
 
 LOGIN_REDIRECT_URL=http://localhost:3000
 LOGIN_REDIRECT_URL_FAILURE=http://localhost:3000
 LOGOUT_REDIRECT_URL=http://localhost:3000
 
 OIDC_REDIRECT_ALLOWED_HOSTS=localhost:8083,localhost:3000
-OIDC_AUTH_REQUEST_EXTRA_PARAMS={"acr_values": "eidas1"}
+# Dex has no notion of ACR, the eIDAS level requested from ProConnect in
+# production is meaningless here and would just be ignored.
+OIDC_AUTH_REQUEST_EXTRA_PARAMS={}
 
 OIDC_RS_CLIENT_ID=meet
 OIDC_RS_CLIENT_SECRET=ThisIsAnExampleKeyForDevPurposeOnly
@@ -63,7 +74,7 @@ ALLOW_UNREGISTERED_ROOMS=False
 
 # Recording
 RECORDING_ENABLE=True
-RECORDING_STORAGE_EVENT_ENABLE=True
+RECORDING_STORAGE_EVENT_ENABLE=False
 RECORDING_STORAGE_EVENT_TOKEN=password
 SUMMARY_SERVICE_ENDPOINT=http://app-summary-dev:8000/api/v2/async-jobs/transcribe/
 SUMMARY_SERVICE_API_TOKEN=password
@@ -85,6 +96,10 @@ RECORDING_DOWNLOAD_BASE_URL=http://localhost:3000/recording
 # Telephony
 ROOM_TELEPHONY_ENABLED=True
 
+# RoomKit
+# ROOMKIT_ENABLED = True
+# ROOMKIT_SERVER_TO_SERVER_API_TOKEN = ThisIsAnExampleKeyForDevPurposeOnly
+
 # Metadata
 METADATA_COLLECTOR_ENABLED=True
 

env.d/development/kc_postgresql.dist

@@ -1,11 +0,0 @@
-# Postgresql db container configuration
-POSTGRES_DB=keycloak
-POSTGRES_USER=meet
-POSTGRES_PASSWORD=pass
-
-# App database configuration
-DB_HOST=kc_postgresql
-DB_NAME=keycloak
-DB_USER=meet
-DB_PASSWORD=pass
-DB_PORT=5433

src/addons/outlook/package-lock.json

@@ -10,7 +10,7 @@
       "license": "MIT",
       "dependencies": {
         "core-js": "3.49.0",
-        "i18next": "^26.3.4",
+        "i18next": "^26.3.6",
         "i18next-browser-languagedetector": "8.2.1",
         "regenerator-runtime": "0.14.1"
       },
@@ -9364,9 +9364,9 @@
       }
     },
     "node_modules/i18next": {
-      "version": "26.3.4",
-      "resolved": "https://registry.npmjs.org/i18next/-/i18next-26.3.4.tgz",
-      "integrity": "sha512-pa7m0d7pBDqGHZxljT+WPFeyFgQ7P7SciPPo1tTqYuO0z4sqADYhwnBESmmGp/wEof1inwdls/k8ZgTg8rxFHA==",
+      "version": "26.3.6",
+      "resolved": "https://registry.npmjs.org/i18next/-/i18next-26.3.6.tgz",
+      "integrity": "sha512-Bu5Z2nAXgfVyM8xvW3jk9EKRIuX37PudsrBViThNFx7CR7aaYTpP01cxNB/E4c4UUzTDiAZRstEhsRfPOL/8xA==",
       "funding": [
         {
           "type": "individual",
@@ -9383,7 +9383,7 @@
       ],
       "license": "MIT",
       "peerDependencies": {
-        "typescript": "^5 || ^6"
+        "typescript": "^5 || ^6 || ^7"
       },
       "peerDependenciesMeta": {
         "typescript": {

src/addons/outlook/package.json

@@ -27,7 +27,7 @@
   },
   "dependencies": {
     "core-js": "3.49.0",
-    "i18next": "26.3.4",
+    "i18next": "26.3.6",
     "i18next-browser-languagedetector": "8.2.1",
     "regenerator-runtime": "0.14.1"
   },

src/backend/core/analytics/events.py

@@ -8,3 +8,6 @@ class AnalyticsEvent(StrEnum):
 
     # Rooms
     ROOM_CREATED = "room_created"
+
+    # Roomkit (meeting-room SIP devices)
+    ROOMKIT_JOINED = "roomkit_joined"

src/backend/core/api/feature_flag.py

@@ -16,6 +16,7 @@ class FeatureFlag:
         "file_upload": "FILE_UPLOAD_ENABLED",
         "addons": "ADDONS_ENABLED",
         "application": "APPLICATION_ENABLED",
+        "roomkit": "ROOMKIT_ENABLED",
     }
 
     @classmethod

src/backend/core/api/throttling.py

@@ -73,3 +73,15 @@ class CreationCallbackAnonRateThrottle(MonitoredAnonRateThrottle):
     """Throttle Anonymous user requesting room generation callback"""
 
     scope = "creation_callback"
+
+
+class RoomKitJoinRateThrottle(MonitoredUserRateThrottle):
+    """Throttle the LiveKit SIP module requesting roomkit joins.
+
+    The roomkit endpoints are authenticated as a machine user, so all requests
+    share a single throttle bucket. This is not a security measure against
+    brute-force attacks but a guard against accidental hammering from a buggy
+    SIP module.
+    """
+
+    scope = "roomkit_join"

src/backend/core/models.py

@@ -429,7 +429,14 @@ class Room(Resource):
 
     def save(self, *args, **kwargs):
         """Generate a unique n-digit pin code for new rooms."""
-        if settings.ROOM_TELEPHONY_ENABLED and not self.pk and not self.pin_code:
+
+        # Roomkit devices also join by PIN, so a PIN is needed as soon as
+        # either integration is enabled.
+        if (
+            (settings.ROOM_TELEPHONY_ENABLED or settings.ROOMKIT_ENABLED)
+            and not self.pk
+            and not self.pin_code
+        ):
             self.pin_code = self.generate_unique_pin_code(
                 length=settings.ROOM_TELEPHONY_PIN_LENGTH
             )

src/backend/core/roomkit/__init__.py

@@ -0,0 +1 @@
+"""Meet core roomkit API endpoints for meeting-room (SIP) device integration."""

src/backend/core/roomkit/authentication.py

@@ -0,0 +1,65 @@
+"""Authentication for the roomkit API of the Meet core app."""
+
+import logging
+import secrets
+
+from django.conf import settings
+
+from rest_framework.authentication import BaseAuthentication
+from rest_framework.exceptions import AuthenticationFailed
+
+from core.recording.event.authentication import MachineUser
+
+logger = logging.getLogger(__name__)
+
+
+class ServerToServerAuthentication(BaseAuthentication):
+    """Custom authentication class for roomkit server-to-server requests.
+
+    Validates the Authorization header against the roomkit server-to-server
+    token. A valid PIN code is intentionally not enough to authenticate: the
+    endpoints are restricted to the LiveKit SIP module's credentials.
+    """
+
+    AUTH_HEADER = "Authorization"
+    TOKEN_TYPE = "Bearer"  # noqa S105
+
+    def authenticate(self, request):
+        """Validate the Bearer token from the Authorization header.
+
+        Returns a (MachineUser, token) pair on success, and raises
+        AuthenticationFailed if the header is missing, malformed, or contains
+        an invalid token.
+        """
+        required_token = settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN
+        if not required_token:
+            raise AuthenticationFailed("Server-to-server token is not configured.")
+
+        auth_header = request.headers.get(self.AUTH_HEADER)
+        if not auth_header:
+            logger.warning(
+                "Roomkit authentication failed: missing Authorization header (ip: %s)",
+                request.META.get("REMOTE_ADDR"),
+            )
+            raise AuthenticationFailed("Authorization header is missing.")
+
+        # Validate token format and existence
+        auth_parts = auth_header.split(" ")
+        if len(auth_parts) != 2 or auth_parts[0] != self.TOKEN_TYPE:
+            raise AuthenticationFailed("Invalid authorization header.")
+
+        token = auth_parts[1]
+
+        # Use constant-time comparison to prevent timing attacks
+        if not secrets.compare_digest(token.encode(), required_token.encode()):
+            logger.warning(
+                "Roomkit authentication failed: invalid token (ip: %s)",
+                request.META.get("REMOTE_ADDR"),
+            )
+            raise AuthenticationFailed("Invalid server-to-server token.")
+
+        return MachineUser(username="roomkit"), token
+
+    def authenticate_header(self, request):
+        """Return the WWW-Authenticate header value."""
+        return f"{self.TOKEN_TYPE} realm='Roomkit server to server'"

src/backend/core/roomkit/serializers.py

@@ -0,0 +1,21 @@
+"""Serializers for the roomkit API of the Meet core app."""
+
+# pylint: disable=abstract-method
+
+from django.conf import settings
+
+from rest_framework import serializers
+
+from core.api.serializers import BaseValidationOnlySerializer
+
+
+class RoomKitJoinSerializer(BaseValidationOnlySerializer):
+    """Validate roomkit join requests from the LiveKit SIP module."""
+
+    pin_code = serializers.CharField(required=True)
+
+    def validate_pin_code(self, value):
+        """Ensure the PIN code matches the configured length."""
+        if len(value) != settings.ROOM_TELEPHONY_PIN_LENGTH:
+            raise serializers.ValidationError("PIN code length is invalid.")
+        return value

src/backend/core/roomkit/viewsets.py

@@ -0,0 +1,89 @@
+"""Roomkit API endpoints for meeting-room (SIP) device integration."""
+
+from logging import getLogger
+
+from rest_framework import decorators, viewsets
+from rest_framework import (
+    exceptions as drf_exceptions,
+)
+from rest_framework import (
+    response as drf_response,
+)
+from rest_framework import (
+    status as drf_status,
+)
+
+from core import analytics, models
+from core.api import permissions, throttling
+from core.api.feature_flag import FeatureFlag
+from core.services.sip_management import SIPException, SIPManagement
+
+from . import authentication, serializers
+
+logger = getLogger(__name__)
+
+
+class RoomKitViewSet(viewsets.ViewSet):
+    """Server-to-server API endpoints for the roomkit integration.
+
+    Groups all interactions between roomkit (SIP) devices and the backend,
+    brokered by the LiveKit SIP module. All endpoints are authenticated
+    with the roomkit server-to-server tokens.
+    """
+
+    authentication_classes = [authentication.ServerToServerAuthentication]
+    permission_classes = [permissions.IsAuthenticated]
+
+    @decorators.action(
+        detail=False,
+        methods=["post"],
+        url_path="join",
+        throttle_classes=[throttling.RoomKitJoinRateThrottle],
+    )
+    @FeatureFlag.require("roomkit")
+    def join(self, request):
+        """Prepare a room for a meeting-room (SIP) device joining by PIN code.
+
+        Called by the LiveKit SIP module when a meeting-room device dials in
+        with a PIN code before any WebRTC participant has joined. Resolves the
+        room by PIN and creates its SIP dispatch rule, so the device can enter
+        without waiting for a WebRTC user.
+
+        The webhook-based creation path is kept: both converge on the same rule
+        through the shared SIPManagement.
+        """
+
+        serializer = serializers.RoomKitJoinSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        try:
+            room = models.Room.objects.get(
+                pin_code=serializer.validated_data["pin_code"]
+            )
+        except models.Room.DoesNotExist as e:
+            raise drf_exceptions.NotFound("No room found for this PIN code.") from e
+
+        try:
+            created = SIPManagement().ensure_dispatch_rule(room)
+        except SIPException as e:
+            raise drf_exceptions.APIException("Could not create dispatch rule.") from e
+
+        analytics.capture(
+            request.user,
+            analytics.AnalyticsEvent.ROOMKIT_JOINED,
+            {
+                "room_id": str(room.pk),
+                "dispatch_rule_created": created,
+            },
+        )
+
+        logger.info(
+            "Roomkit join requested: room_id=%s, dispatch_rule_created=%s",
+            room.id,
+            created,
+        )
+
+        return drf_response.Response(
+            {"status": "success"},
+            status=drf_status.HTTP_200_OK,
+        )

src/backend/core/services/livekit_events.py

@@ -28,7 +28,7 @@ from .room_management import (
     RoomManagementException,
     RoomNotFoundException,
 )
-from .telephony import TelephonyException, TelephonyService
+from .sip_management import SIPException, SIPManagement
 
 logger = getLogger(__name__)
 
@@ -107,7 +107,7 @@ class LiveKitEventsService:
         )
         self.webhook_receiver = api.WebhookReceiver(token_verifier)
         self.lobby_service = LobbyService()
-        self.telephony_service = TelephonyService()
+        self.sip_management = SIPManagement()
         self.recording_events = RecordingEventsService()
 
         self._filter_regex = None
@@ -245,12 +245,12 @@ class LiveKitEventsService:
         except models.Room.DoesNotExist as err:
             raise ActionFailedError(f"Room with ID {room_id} does not exist") from err
 
-        if settings.ROOM_TELEPHONY_ENABLED:
+        if settings.ROOM_TELEPHONY_ENABLED or settings.ROOMKIT_ENABLED:
             try:
-                self.telephony_service.create_dispatch_rule(room)
-            except TelephonyException as e:
+                self.sip_management.ensure_dispatch_rule(room)
+            except SIPException as e:
                 raise ActionFailedError(
-                    f"Failed to create telephony dispatch rule for room {room_id}"
+                    f"Failed to create sip dispatch rule for room {room_id}"
                 ) from e
 
     def _handle_room_finished(self, data):
@@ -265,12 +265,12 @@ class LiveKitEventsService:
             )
             raise ActionFailedError("Failed to process room finished event") from e
 
-        if settings.ROOM_TELEPHONY_ENABLED:
+        if settings.ROOM_TELEPHONY_ENABLED or settings.ROOMKIT_ENABLED:
             try:
-                self.telephony_service.delete_dispatch_rule(room_id)
-            except TelephonyException as e:
+                self.sip_management.delete_dispatch_rule(room_id)
+            except SIPException as e:
                 raise ActionFailedError(
-                    f"Failed to delete telephony dispatch rule for room {room_id}"
+                    f"Failed to delete sip dispatch rule for room {room_id}"
                 ) from e
 
         try:

src/backend/core/services/sip_management.py

@@ -1,9 +1,9 @@
-"""Telephony service for managing SIP dispatch rules for room access."""
+"""SIP management service for managing SIP dispatch rules for room access."""
 
 from logging import getLogger
 
 from asgiref.sync import async_to_sync
-from livekit.api import TwirpError
+from livekit.api import TwirpError, TwirpErrorCode
 from livekit.protocol.sip import (
     CreateSIPDispatchRuleRequest,
     DeleteSIPDispatchRuleRequest,
@@ -17,12 +17,16 @@ from core import utils
 logger = getLogger(__name__)
 
 
-class TelephonyException(Exception):
-    """Exception raised when telephony operations fail."""
+class SIPException(Exception):
+    """Exception raised when SIP operations fail."""
 
 
-class TelephonyService:
-    """Service for managing participant access through the telephony system (SIP)."""
+class DispatchRuleConflictError(SIPException):
+    """Raised when a dispatch rule already exists for the same routing criteria."""
+
+
+class SIPManagement:
+    """Service for managing SIP access through the telephony or roomkit system (SIP)."""
 
     def _rule_name(self, room_id):
         """Generate the rule name for a room based on its ID."""
@@ -32,7 +36,7 @@ class TelephonyService:
     async def create_dispatch_rule(self, room):
         """Create a SIP inbound dispatch rule for direct room routing.
 
-        Configures telephony to route incoming SIP calls directly to the specified room
+        Configures livekit-sip to route incoming SIP calls directly to the specified room
         using the room's ID and PIN code for authentication.
         """
 
@@ -51,10 +55,12 @@ class TelephonyService:
         try:
             await lkapi.sip.create_sip_dispatch_rule(create=request)
         except TwirpError as e:
+            if e.code == TwirpErrorCode.ALREADY_EXISTS:
+                raise DispatchRuleConflictError("Dispatch rule already exists") from e
             logger.exception(
                 "Unexpected error creating dispatch rule for room %s", room.id
             )
-            raise TelephonyException("Could not create dispatch rule") from e
+            raise SIPException("Could not create dispatch rule") from e
 
         finally:
             await lkapi.aclose()
@@ -79,7 +85,7 @@ class TelephonyService:
             )
         except TwirpError as e:
             logger.exception("Failed to list dispatch rules for room %s", room_id)
-            raise TelephonyException("Could not list dispatch rules") from e
+            raise SIPException("Could not list dispatch rules") from e
         finally:
             await lkapi.aclose()
 
@@ -94,6 +100,28 @@ class TelephonyService:
             if existing_rule.name == rule_name
         ]
 
+    @async_to_sync
+    async def has_dispatch_rule(self, room_id):
+        """Check whether at least one dispatch rule exists for a specific room."""
+        return bool(await self._list_dispatch_rules_ids(room_id))
+
+    def ensure_dispatch_rule(self, room):
+        """Create the SIP dispatch rule for a room if it does not already exist.
+
+        Returns:
+            bool: True if a rule was created, False if it already existed.
+        """
+
+        if self.has_dispatch_rule(room.pk):
+            return False
+
+        try:
+            self.create_dispatch_rule(room)
+        except DispatchRuleConflictError:
+            return False
+
+        return True
+
     @async_to_sync
     async def delete_dispatch_rule(self, room_id):
         """Delete all SIP inbound dispatch rules associated with a specific room."""
@@ -118,7 +146,7 @@ class TelephonyService:
 
         except TwirpError as e:
             logger.exception("Failed to delete dispatch rules for room %s", room_id)
-            raise TelephonyException("Could not delete dispatch rules") from e
+            raise SIPException("Could not delete dispatch rules") from e
 
         finally:
             await lkapi.aclose()

src/backend/core/tests/roomkit/__init__.py

@@ -0,0 +1 @@
+"""Tests for the roomkit API of the Meet core app."""

src/backend/core/tests/roomkit/test_api_roomkit_join.py

@@ -0,0 +1,305 @@
+"""
+Test the roomkit join server-to-server API endpoint.
+"""
+
+# pylint: disable=redefined-outer-name,unused-argument
+
+from unittest import mock
+
+import pytest
+
+from ...factories import RoomFactory
+from ...services.sip_management import SIPException
+
+pytestmark = pytest.mark.django_db
+
+
+@mock.patch("core.roomkit.viewsets.SIPManagement")
+def test_join_anonymous(mock_sip_management, settings, client):
+    """Requests without an Authorization header should be rejected."""
+
+    mock_sip_instance = mock_sip_management.return_value
+
+    settings.ROOMKIT_ENABLED = True
+    settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN = "testAuthToken"
+
+    room = RoomFactory(pin_code="1234567890")
+
+    response = client.post("/api/v1.0/roomkit/join/", {"pin_code": room.pin_code})
+
+    assert response.status_code == 401
+    assert response.json() == {"detail": "Authorization header is missing."}
+    mock_sip_instance.ensure_dispatch_rule.assert_not_called()
+
+
+@mock.patch("core.roomkit.viewsets.SIPManagement")
+def test_join_malformed_authorization_header(mock_sip_management, settings, client):
+    """Requests with a malformed Authorization header should be rejected."""
+
+    mock_sip_instance = mock_sip_management.return_value
+
+    settings.ROOMKIT_ENABLED = True
+    settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN = "testAuthToken"
+
+    room = RoomFactory(pin_code="1234567890")
+
+    response = client.post(
+        "/api/v1.0/roomkit/join/",
+        {"pin_code": room.pin_code},
+        HTTP_AUTHORIZATION="testAuthToken",
+    )
+
+    assert response.status_code == 401
+    assert response.json() == {"detail": "Invalid authorization header."}
+    mock_sip_instance.ensure_dispatch_rule.assert_not_called()
+
+
+@mock.patch("core.roomkit.viewsets.SIPManagement")
+def test_join_wrong_bearer(mock_sip_management, settings, client):
+    """Requests with an incorrect bearer token should be rejected."""
+
+    mock_sip_instance = mock_sip_management.return_value
+
+    settings.ROOMKIT_ENABLED = True
+    settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN = "testAuthToken"
+
+    room = RoomFactory(pin_code="1234567890")
+
+    response = client.post(
+        "/api/v1.0/roomkit/join/",
+        {"pin_code": room.pin_code},
+        HTTP_AUTHORIZATION="Bearer wrongAuthToken",
+    )
+
+    assert response.status_code == 401
+    assert response.json() == {"detail": "Invalid server-to-server token."}
+    mock_sip_instance.ensure_dispatch_rule.assert_not_called()
+
+
+@mock.patch("core.roomkit.viewsets.SIPManagement")
+def test_join_token_not_configured(mock_sip_management, settings, client):
+    """Requests should be rejected when no server-to-server token is configured."""
+
+    mock_sip_instance = mock_sip_management.return_value
+
+    settings.ROOMKIT_ENABLED = True
+    settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN = None
+
+    room = RoomFactory(pin_code="1234567890")
+
+    response = client.post(
+        "/api/v1.0/roomkit/join/",
+        {"pin_code": room.pin_code},
+        HTTP_AUTHORIZATION="Bearer testAuthToken",
+    )
+
+    assert response.status_code == 401
+    mock_sip_instance.ensure_dispatch_rule.assert_not_called()
+
+
+@mock.patch("core.roomkit.viewsets.SIPManagement")
+def test_join_roomkit_disabled(mock_sip_management, settings, client):
+    """The endpoint should not be exposed when the roomkit integration is disabled."""
+
+    mock_sip_instance = mock_sip_management.return_value
+
+    settings.ROOMKIT_ENABLED = False
+    settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN = "testAuthToken"
+
+    room = RoomFactory(pin_code="1234567890")
+
+    response = client.post(
+        "/api/v1.0/roomkit/join/",
+        {"pin_code": room.pin_code},
+        HTTP_AUTHORIZATION="Bearer testAuthToken",
+    )
+
+    assert response.status_code == 404
+    mock_sip_instance.ensure_dispatch_rule.assert_not_called()
+
+
+@mock.patch("core.roomkit.viewsets.SIPManagement")
+def test_join_missing_pin(mock_sip_management, settings, client):
+    """Requests without a PIN code should be rejected."""
+
+    mock_sip_instance = mock_sip_management.return_value
+
+    settings.ROOMKIT_ENABLED = True
+    settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN = "testAuthToken"
+
+    response = client.post(
+        "/api/v1.0/roomkit/join/",
+        {},
+        HTTP_AUTHORIZATION="Bearer testAuthToken",
+    )
+
+    assert response.status_code == 400
+    assert response.json() == {"pin_code": ["This field is required."]}
+    mock_sip_instance.ensure_dispatch_rule.assert_not_called()
+
+
+@mock.patch("core.roomkit.viewsets.SIPManagement")
+def test_join_blank_pin(mock_sip_management, settings, client):
+    """Requests with a blank PIN code should be rejected."""
+
+    mock_sip_instance = mock_sip_management.return_value
+
+    settings.ROOMKIT_ENABLED = True
+    settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN = "testAuthToken"
+
+    response = client.post(
+        "/api/v1.0/roomkit/join/",
+        {"pin_code": ""},
+        HTTP_AUTHORIZATION="Bearer testAuthToken",
+    )
+
+    assert response.status_code == 400
+    assert response.json() == {"pin_code": ["This field may not be blank."]}
+    mock_sip_instance.ensure_dispatch_rule.assert_not_called()
+
+
+@mock.patch("core.roomkit.viewsets.SIPManagement")
+def test_join_wrong_pin_length(mock_sip_management, settings, client):
+    """Requests with a PIN code of unexpected length should be rejected."""
+
+    mock_sip_instance = mock_sip_management.return_value
+
+    settings.ROOMKIT_ENABLED = True
+    settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN = "testAuthToken"
+    settings.ROOM_TELEPHONY_PIN_LENGTH = 10
+
+    response = client.post(
+        "/api/v1.0/roomkit/join/",
+        {"pin_code": "123"},
+        HTTP_AUTHORIZATION="Bearer testAuthToken",
+    )
+
+    assert response.status_code == 400
+    assert response.json() == {"pin_code": ["PIN code length is invalid."]}
+    mock_sip_instance.ensure_dispatch_rule.assert_not_called()
+
+
+@mock.patch("core.roomkit.viewsets.SIPManagement")
+def test_join_unknown_pin(mock_sip_management, settings, client):
+    """Requests with a PIN matching no room should return 404 and create no rule."""
+
+    mock_sip_instance = mock_sip_management.return_value
+
+    settings.ROOMKIT_ENABLED = True
+    settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN = "testAuthToken"
+
+    RoomFactory(pin_code="1234567890")
+
+    response = client.post(
+        "/api/v1.0/roomkit/join/",
+        {"pin_code": "0987654321"},
+        HTTP_AUTHORIZATION="Bearer testAuthToken",
+    )
+
+    assert response.status_code == 404
+    assert response.json() == {"detail": "No room found for this PIN code."}
+    mock_sip_instance.ensure_dispatch_rule.assert_not_called()
+
+
+@mock.patch("core.roomkit.viewsets.SIPManagement")
+def test_join_success(mock_sip_management, settings, client):
+    """Requests with a valid PIN should create the dispatch rule."""
+
+    mock_sip_instance = mock_sip_management.return_value
+
+    settings.ROOMKIT_ENABLED = True
+    settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN = "testAuthToken"
+
+    room = RoomFactory(pin_code="1234567890")
+    mock_sip_instance.ensure_dispatch_rule.return_value = True
+
+    response = client.post(
+        "/api/v1.0/roomkit/join/",
+        {"pin_code": room.pin_code},
+        HTTP_AUTHORIZATION="Bearer testAuthToken",
+    )
+
+    assert response.status_code == 200
+    assert response.json() == {"status": "success"}
+    mock_sip_instance.ensure_dispatch_rule.assert_called_once_with(room)
+
+
+@mock.patch("core.roomkit.viewsets.SIPManagement")
+def test_join_dispatch_rule_already_exists(mock_sip_management, settings, client):
+    """Requests should succeed when the dispatch rule already exists (idempotency)."""
+
+    mock_sip_instance = mock_sip_management.return_value
+
+    settings.ROOMKIT_ENABLED = True
+    settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN = "testAuthToken"
+
+    room = RoomFactory(pin_code="1234567890")
+    mock_sip_instance.ensure_dispatch_rule.return_value = False
+
+    response = client.post(
+        "/api/v1.0/roomkit/join/",
+        {"pin_code": room.pin_code},
+        HTTP_AUTHORIZATION="Bearer testAuthToken",
+    )
+
+    assert response.status_code == 200
+    assert response.json() == {"status": "success"}
+    mock_sip_instance.ensure_dispatch_rule.assert_called_once_with(room)
+
+
+@mock.patch("core.roomkit.viewsets.analytics.capture")
+@mock.patch("core.roomkit.viewsets.SIPManagement")
+def test_join_tracks_analytics_event(
+    mock_sip_management, mock_capture, settings, client
+):
+    """Successful joins should be tracked with an analytics event."""
+
+    mock_sip_instance = mock_sip_management.return_value
+
+    settings.ROOMKIT_ENABLED = True
+    settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN = "testAuthToken"
+
+    room = RoomFactory(pin_code="1234567890")
+    mock_sip_instance.ensure_dispatch_rule.return_value = True
+
+    response = client.post(
+        "/api/v1.0/roomkit/join/",
+        {"pin_code": room.pin_code},
+        HTTP_AUTHORIZATION="Bearer testAuthToken",
+    )
+
+    assert response.status_code == 200
+    mock_capture.assert_called_once()
+    _user, event, properties = mock_capture.call_args[0]
+    assert str(event) == "roomkit_joined"
+    assert properties == {
+        "room_id": str(room.pk),
+        "dispatch_rule_created": True,
+    }
+
+
+@mock.patch("core.roomkit.viewsets.analytics.capture")
+@mock.patch("core.roomkit.viewsets.SIPManagement")
+def test_join_sip_failure(mock_sip_management, mock_capture, settings, client):
+    """Requests should fail with a server error when the sip management service fails."""
+
+    mock_sip_instance = mock_sip_management.return_value
+
+    settings.ROOMKIT_ENABLED = True
+    settings.ROOMKIT_SERVER_TO_SERVER_API_TOKEN = "testAuthToken"
+
+    room = RoomFactory(pin_code="1234567890")
+    mock_sip_instance.ensure_dispatch_rule.side_effect = SIPException(
+        "Could not create dispatch rule"
+    )
+
+    response = client.post(
+        "/api/v1.0/roomkit/join/",
+        {"pin_code": room.pin_code},
+        HTTP_AUTHORIZATION="Bearer testAuthToken",
+        raise_request_exception=False,
+    )
+
+    assert response.status_code == 500
+    mock_sip_instance.ensure_dispatch_rule.assert_called_once_with(room)
+    mock_capture.assert_not_called()

src/backend/core/tests/services/test_livekit_events.py

@@ -21,7 +21,10 @@ from core.services.livekit_events import (
 )
 from core.services.lobby import LobbyService
 from core.services.room_management import RoomManagementException
-from core.services.telephony import TelephonyException, TelephonyService
+from core.services.sip_management import (
+    SIPException,
+    SIPManagement,
+)
 from core.utils import NotificationError
 
 pytestmark = pytest.mark.django_db
@@ -59,7 +62,7 @@ def test_initialization(
     mock_token_verifier.assert_called_once_with(api_key, api_secret)
     mock_webhook_receiver.assert_called_once_with(mock_token_verifier.return_value)
     assert isinstance(service.lobby_service, LobbyService)
-    assert isinstance(service.telephony_service, TelephonyService)
+    assert isinstance(service.sip_management, SIPManagement)
     assert isinstance(service.recording_events, RecordingEventsService)
 
 
@@ -72,11 +75,12 @@ def test_initialization(
 )
 @mock.patch("core.utils.notify_participants")
 @mock.patch("core.services.room_management.RoomManagement.update_metadata")
-def test_handle_egress_ended_success(
-    mock_update_metadata, mock_notify, mode, notification_type, service
+def test_handle_egress_ended_success(  # noqa: PLR0913 # pylint: disable=too-many-arguments, too-many-positional-arguments
+    mock_update_metadata, mock_notify, mode, notification_type, service, settings
 ):
     """Should successfully stop recording and notifies all participant."""
 
+    settings.RECORDING_STORAGE_EVENT_ENABLE = False
     recording = RecordingFactory(worker_id="worker-1", mode=mode, status="active")
     mock_data = mock.MagicMock()
     mock_data.egress_info.egress_id = recording.worker_id
@@ -155,11 +159,12 @@ def test_handle_egress_updated_non_handled(
 )
 @mock.patch("core.utils.notify_participants")
 @mock.patch("core.services.room_management.RoomManagement.update_metadata")
-def test_handle_egress_ended_metadata_update_fails(
-    mock_update_metadata, mock_notify, mode, notification_type, service
+def test_handle_egress_ended_metadata_update_fails(  # noqa: PLR0913 # pylint: disable=too-many-arguments, too-many-positional-arguments
+    mock_update_metadata, mock_notify, mode, notification_type, service, settings
 ):
     """Should successfully stop and save recording when metadata's update fails."""
 
+    settings.RECORDING_STORAGE_EVENT_ENABLE = False
     recording = RecordingFactory(worker_id="worker-1", mode=mode, status="active")
     mock_data = mock.MagicMock()
     mock_data.egress_info.egress_id = recording.worker_id
@@ -469,11 +474,11 @@ def test_handle_egress_ended_ignores_non_savable_recording(
 
 
 @mock.patch.object(LobbyService, "clear_room_cache")
-@mock.patch.object(TelephonyService, "delete_dispatch_rule")
+@mock.patch.object(SIPManagement, "delete_dispatch_rule")
 def test_handle_room_finished_clears_cache_and_deletes_dispatch_rule(
     mock_delete_dispatch_rule, mock_clear_cache, service, settings
 ):
-    """Should clear lobby cache and delete telephony dispatch rule when room finishes."""
+    """Should clear lobby cache and delete SIP dispatch rule when room finishes."""
     settings.ROOM_TELEPHONY_ENABLED = True
     mock_room_name = uuid.uuid4()
     mock_data = mock.MagicMock()
@@ -486,12 +491,31 @@ def test_handle_room_finished_clears_cache_and_deletes_dispatch_rule(
 
 
 @mock.patch.object(LobbyService, "clear_room_cache")
-@mock.patch.object(TelephonyService, "delete_dispatch_rule")
+@mock.patch.object(SIPManagement, "delete_dispatch_rule")
+def test_handle_room_finished_deletes_dispatch_rule_when_only_roomkit_enabled(
+    mock_delete_dispatch_rule, mock_clear_cache, service, settings
+):
+    """Should delete dispatch rule when only roomkit is enabled when room finishes."""
+    settings.ROOM_TELEPHONY_ENABLED = False
+    settings.ROOMKIT_ENABLED = True
+    mock_room_name = uuid.uuid4()
+    mock_data = mock.MagicMock()
+    mock_data.room.name = str(mock_room_name)
+
+    service._handle_room_finished(mock_data)
+
+    mock_delete_dispatch_rule.assert_called_once_with(mock_room_name)
+    mock_clear_cache.assert_called_once_with(mock_room_name)
+
+
+@mock.patch.object(LobbyService, "clear_room_cache")
+@mock.patch.object(SIPManagement, "delete_dispatch_rule")
 def test_handle_room_finished_skips_telephony_when_disabled(
     mock_delete_dispatch_rule, mock_clear_cache, service, settings
 ):
     """Should clear lobby cache but skip dispatch rule deletion when telephony is disabled."""
     settings.ROOM_TELEPHONY_ENABLED = False
+    settings.ROOMKIT_ENABLED = False
     mock_room_name = uuid.uuid4()
     mock_data = mock.MagicMock()
     mock_data.room.name = str(mock_room_name)
@@ -505,7 +529,7 @@ def test_handle_room_finished_skips_telephony_when_disabled(
 @mock.patch.object(
     LobbyService, "clear_room_cache", side_effect=Exception("Test error")
 )
-@mock.patch.object(TelephonyService, "delete_dispatch_rule")
+@mock.patch.object(SIPManagement, "delete_dispatch_rule")
 def test_handle_room_finished_raises_error_when_cache_clearing_fails(
     mock_delete_dispatch_rule, mock_clear_cache, service, settings
 ):
@@ -528,9 +552,9 @@ def test_handle_room_finished_raises_error_when_cache_clearing_fails(
 
 @mock.patch.object(LobbyService, "clear_room_cache")
 @mock.patch.object(
-    TelephonyService,
+    SIPManagement,
     "delete_dispatch_rule",
-    side_effect=TelephonyException("Test error"),
+    side_effect=SIPException("Test error"),
 )
 def test_handle_room_finished_raises_error_when_telephony_deletion_fails(
     mock_delete_dispatch_rule, mock_clear_cache, service, settings
@@ -541,7 +565,7 @@ def test_handle_room_finished_raises_error_when_telephony_deletion_fails(
     mock_data.room.name = "00000000-0000-0000-0000-000000000000"
 
     expected_error = (
-        "Failed to delete telephony dispatch rule for room "
+        "Failed to delete sip dispatch rule for room "
         "00000000-0000-0000-0000-000000000000"
     )
 
@@ -562,11 +586,11 @@ def test_handle_room_finished_raises_error_for_invalid_room_name(service):
         service._handle_room_finished(mock_data)
 
 
-@mock.patch.object(TelephonyService, "create_dispatch_rule")
+@mock.patch.object(SIPManagement, "ensure_dispatch_rule")
 def test_handle_room_started_creates_dispatch_rule_successfully(
-    mock_create_dispatch_rule, service, settings
+    mock_ensure_dispatch_rule, service, settings
 ):
-    """Should create telephony dispatch rule when room starts successfully."""
+    """Should ensure the SIP dispatch rule exists when room starts successfully."""
     settings.ROOM_TELEPHONY_ENABLED = True
     room = RoomFactory()
     mock_data = mock.MagicMock()
@@ -574,22 +598,75 @@ def test_handle_room_started_creates_dispatch_rule_successfully(
 
     service._handle_room_started(mock_data)
 
-    mock_create_dispatch_rule.assert_called_once_with(room)
+    mock_ensure_dispatch_rule.assert_called_once_with(room)
 
 
-@mock.patch.object(TelephonyService, "create_dispatch_rule")
-def test_handle_room_started_skips_dispatch_rule_when_telephony_disabled(
-    mock_create_dispatch_rule, service, settings
+@mock.patch.object(SIPManagement, "ensure_dispatch_rule")
+def test_handle_room_started_creates_dispatch_rule_when_only_roomkit_enabled(
+    mock_ensure_dispatch_rule, service, settings
 ):
-    """Should skip creating telephony dispatch rule when telephony is disabled during room start."""
+    """Should ensure the dispatch rule exists when only roomkit is enabled during room start."""
     settings.ROOM_TELEPHONY_ENABLED = False
+    settings.ROOMKIT_ENABLED = True
     room = RoomFactory()
     mock_data = mock.MagicMock()
     mock_data.room.name = str(room.id)
 
     service._handle_room_started(mock_data)
 
-    mock_create_dispatch_rule.assert_not_called()
+    mock_ensure_dispatch_rule.assert_called_once_with(room)
+
+
+@mock.patch.object(SIPManagement, "ensure_dispatch_rule", return_value=False)
+def test_handle_room_started_ignores_existing_dispatch_rule(
+    mock_ensure_dispatch_rule, service, settings
+):
+    """Should proceed silently when the dispatch rule already exists when room starts."""
+    settings.ROOM_TELEPHONY_ENABLED = True
+    room = RoomFactory()
+    mock_data = mock.MagicMock()
+    mock_data.room.name = str(room.id)
+
+    # ensure_dispatch_rule reports the rule as pre-existing: nothing to raise
+    service._handle_room_started(mock_data)
+
+    mock_ensure_dispatch_rule.assert_called_once_with(room)
+
+
+@mock.patch.object(
+    SIPManagement,
+    "ensure_dispatch_rule",
+    side_effect=SIPException("Test error"),
+)
+def test_handle_room_started_raises_error_when_dispatch_rule_creation_fails(
+    mock_ensure_dispatch_rule, service, settings
+):
+    """Should raise ActionFailedError when ensuring the dispatch rule fails when room starts."""
+    settings.ROOM_TELEPHONY_ENABLED = True
+    room = RoomFactory()
+    mock_data = mock.MagicMock()
+    mock_data.room.name = str(room.id)
+
+    expected_error = f"Failed to create sip dispatch rule for room {room.id}"
+
+    with pytest.raises(ActionFailedError, match=expected_error):
+        service._handle_room_started(mock_data)
+
+
+@mock.patch.object(SIPManagement, "ensure_dispatch_rule")
+def test_handle_room_started_skips_dispatch_rule_when_telephony_disabled(
+    mock_ensure_dispatch_rule, service, settings
+):
+    """Should skip ensuring the SIP dispatch rule when telephony is disabled during room start."""
+    settings.ROOM_TELEPHONY_ENABLED = False
+    settings.ROOMKIT_ENABLED = False
+    room = RoomFactory()
+    mock_data = mock.MagicMock()
+    mock_data.room.name = str(room.id)
+
+    service._handle_room_started(mock_data)
+
+    mock_ensure_dispatch_rule.assert_not_called()
 
 
 def test_handle_room_started_raises_error_for_invalid_room_name(service):

src/backend/core/tests/services/test_sip_management.py

@@ -1,5 +1,5 @@
 """
-Test telephony service.
+Test SIP mamagement service.
 """
 
 # pylint: disable=W0212
@@ -20,7 +20,11 @@ from livekit.protocol.sip import (
 
 from core.factories import RoomFactory
 from core.models import RoomAccessLevel
-from core.services.telephony import TelephonyException, TelephonyService
+from core.services.sip_management import (
+    DispatchRuleConflictError,
+    SIPException,
+    SIPManagement,
+)
 
 pytestmark = pytest.mark.django_db
 
@@ -35,9 +39,9 @@ def create_mock_livekit_client():
 
 def test_rule_name():
     """Test rule name generation."""
-    telephony_service = TelephonyService()
+    sip_management = SIPManagement()
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
-    rule_name = telephony_service._rule_name(room.id)
+    rule_name = sip_management._rule_name(room.id)
 
     assert rule_name == f"SIP_{str(room.id)}"
 
@@ -45,14 +49,14 @@ def test_rule_name():
 @mock.patch("core.utils.create_livekit_client")
 def test_create_dispatch_rule_success(mock_client_factory):
     """Test successful dispatch rule creation."""
-    telephony_service = TelephonyService()
+    sip_management = SIPManagement()
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
 
     mock_api = create_mock_livekit_client()
     mock_api.sip.create_sip_dispatch_rule = mock.AsyncMock()
     mock_client_factory.return_value = mock_api
 
-    telephony_service.create_dispatch_rule(room)
+    sip_management.create_dispatch_rule(room)
 
     mock_api.sip.create_sip_dispatch_rule.assert_called_once()
     create_request = mock_api.sip.create_sip_dispatch_rule.call_args[1]["create"]
@@ -67,7 +71,7 @@ def test_create_dispatch_rule_success(mock_client_factory):
 @mock.patch("core.utils.create_livekit_client")
 def test_create_dispatch_rule_api_failure(mock_client_factory):
     """Test dispatch rule creation when API fails."""
-    telephony_service = TelephonyService()
+    sip_management = SIPManagement()
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
 
     mock_api = create_mock_livekit_client()
@@ -76,8 +80,8 @@ def test_create_dispatch_rule_api_failure(mock_client_factory):
     )
     mock_client_factory.return_value = mock_api
 
-    with pytest.raises(TelephonyException, match="Could not create dispatch rule"):
-        telephony_service.create_dispatch_rule(room)
+    with pytest.raises(SIPException, match="Could not create dispatch rule"):
+        sip_management.create_dispatch_rule(room)
 
     mock_api.sip.create_sip_dispatch_rule.assert_called_once()
     mock_api.aclose.assert_called_once()
@@ -86,7 +90,7 @@ def test_create_dispatch_rule_api_failure(mock_client_factory):
 @mock.patch("core.utils.create_livekit_client")
 def test_list_dispatch_rules_ids_success(mock_client_factory):
     """Test successful listing of dispatch rule IDs."""
-    telephony_service = TelephonyService()
+    sip_management = SIPManagement()
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
 
     mock_rules = [
@@ -111,7 +115,7 @@ def test_list_dispatch_rules_ids_success(mock_client_factory):
     )
     mock_client_factory.return_value = mock_api
 
-    result = async_to_sync(telephony_service._list_dispatch_rules_ids)(room.id)
+    result = async_to_sync(sip_management._list_dispatch_rules_ids)(room.id)
 
     assert len(result) == 2
     assert "rule-1" in result
@@ -127,7 +131,7 @@ def test_list_dispatch_rules_ids_success(mock_client_factory):
 @mock.patch("core.utils.create_livekit_client")
 def test_list_dispatch_rules_ids_empty_response(mock_client_factory):
     """Test listing dispatch rule IDs when no rules exist."""
-    telephony_service = TelephonyService()
+    sip_management = SIPManagement()
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
 
     mock_api = create_mock_livekit_client()
@@ -136,7 +140,7 @@ def test_list_dispatch_rules_ids_empty_response(mock_client_factory):
     )
     mock_client_factory.return_value = mock_api
 
-    result = async_to_sync(telephony_service._list_dispatch_rules_ids)(room.id)
+    result = async_to_sync(sip_management._list_dispatch_rules_ids)(room.id)
 
     assert result == []
     mock_api.aclose.assert_called_once()
@@ -145,7 +149,7 @@ def test_list_dispatch_rules_ids_empty_response(mock_client_factory):
 @mock.patch("core.utils.create_livekit_client")
 def test_list_dispatch_rules_ids_no_matching_rules(mock_client_factory):
     """Test listing dispatch rule IDs when no rules match the room."""
-    telephony_service = TelephonyService()
+    sip_management = SIPManagement()
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
 
     mock_rules = [
@@ -163,7 +167,7 @@ def test_list_dispatch_rules_ids_no_matching_rules(mock_client_factory):
     )
     mock_client_factory.return_value = mock_api
 
-    result = async_to_sync(telephony_service._list_dispatch_rules_ids)(room.id)
+    result = async_to_sync(sip_management._list_dispatch_rules_ids)(room.id)
 
     assert result == []
     mock_api.aclose.assert_called_once()
@@ -172,7 +176,7 @@ def test_list_dispatch_rules_ids_no_matching_rules(mock_client_factory):
 @mock.patch("core.utils.create_livekit_client")
 def test_list_dispatch_rules_ids_api_failure(mock_client_factory):
     """Test listing dispatch rule IDs when API fails."""
-    telephony_service = TelephonyService()
+    sip_management = SIPManagement()
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
 
     mock_api = create_mock_livekit_client()
@@ -181,34 +185,34 @@ def test_list_dispatch_rules_ids_api_failure(mock_client_factory):
     )
     mock_client_factory.return_value = mock_api
 
-    with pytest.raises(TelephonyException, match="Could not list dispatch rules"):
-        async_to_sync(telephony_service._list_dispatch_rules_ids)(room.id)
+    with pytest.raises(SIPException, match="Could not list dispatch rules"):
+        async_to_sync(sip_management._list_dispatch_rules_ids)(room.id)
 
     mock_api.sip.list_sip_dispatch_rule.assert_called_once()
     mock_api.aclose.assert_called_once()
 
 
-@mock.patch("core.services.telephony.TelephonyService._list_dispatch_rules_ids")
+@mock.patch("core.services.sip_management.SIPManagement._list_dispatch_rules_ids")
 @mock.patch("core.utils.create_livekit_client")
 def test_delete_dispatch_rule_no_rules(mock_client_factory, mock_list_rules):
     """Test deleting dispatch rules when no rules exist."""
-    telephony_service = TelephonyService()
+    sip_management = SIPManagement()
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
 
     mock_list_rules.return_value = []
 
-    result = telephony_service.delete_dispatch_rule(room.id)
+    result = sip_management.delete_dispatch_rule(room.id)
 
     assert result is False
     mock_list_rules.assert_called_once_with(room.id)
     mock_client_factory.assert_not_called()
 
 
-@mock.patch("core.services.telephony.TelephonyService._list_dispatch_rules_ids")
+@mock.patch("core.services.sip_management.SIPManagement._list_dispatch_rules_ids")
 @mock.patch("core.utils.create_livekit_client")
 def test_delete_dispatch_rule_single_rule(mock_client_factory, mock_list_rules):
     """Test deleting a single dispatch rule."""
-    telephony_service = TelephonyService()
+    sip_management = SIPManagement()
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
 
     mock_list_rules.return_value = ["rule-1"]
@@ -216,7 +220,7 @@ def test_delete_dispatch_rule_single_rule(mock_client_factory, mock_list_rules):
     mock_api.sip.delete_sip_dispatch_rule = mock.AsyncMock()
     mock_client_factory.return_value = mock_api
 
-    result = telephony_service.delete_dispatch_rule(room.id)
+    result = sip_management.delete_dispatch_rule(room.id)
 
     assert result is True
     mock_api.sip.delete_sip_dispatch_rule.assert_called_once()
@@ -226,11 +230,11 @@ def test_delete_dispatch_rule_single_rule(mock_client_factory, mock_list_rules):
     mock_api.aclose.assert_called_once()
 
 
-@mock.patch("core.services.telephony.TelephonyService._list_dispatch_rules_ids")
+@mock.patch("core.services.sip_management.SIPManagement._list_dispatch_rules_ids")
 @mock.patch("core.utils.create_livekit_client")
 def test_delete_dispatch_rule_multiple_rules(mock_client_factory, mock_list_rules):
     """Test deleting multiple dispatch rules."""
-    telephony_service = TelephonyService()
+    sip_management = SIPManagement()
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
 
     mock_list_rules.return_value = ["rule-1", "rule-2", "rule-3"]
@@ -238,7 +242,7 @@ def test_delete_dispatch_rule_multiple_rules(mock_client_factory, mock_list_rule
     mock_api.sip.delete_sip_dispatch_rule = mock.AsyncMock()
     mock_client_factory.return_value = mock_api
 
-    result = telephony_service.delete_dispatch_rule(room.id)
+    result = sip_management.delete_dispatch_rule(room.id)
 
     assert result is True
     assert mock_api.sip.delete_sip_dispatch_rule.call_count == 3
@@ -253,11 +257,11 @@ def test_delete_dispatch_rule_multiple_rules(mock_client_factory, mock_list_rule
     mock_api.aclose.assert_called_once()
 
 
-@mock.patch("core.services.telephony.TelephonyService._list_dispatch_rules_ids")
+@mock.patch("core.services.sip_management.SIPManagement._list_dispatch_rules_ids")
 @mock.patch("core.utils.create_livekit_client")
 def test_delete_dispatch_rule_partial_failure(mock_client_factory, mock_list_rules):
     """Test deleting multiple dispatch rules when one deletion fails."""
-    telephony_service = TelephonyService()
+    sip_management = SIPManagement()
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
 
     mock_list_rules.return_value = ["rule-1", "rule-2", "rule-3"]
@@ -277,18 +281,18 @@ def test_delete_dispatch_rule_partial_failure(mock_client_factory, mock_list_rul
     )
     mock_client_factory.return_value = mock_api
 
-    with pytest.raises(TelephonyException, match="Could not delete dispatch rules"):
-        telephony_service.delete_dispatch_rule(room.id)
+    with pytest.raises(SIPException, match="Could not delete dispatch rules"):
+        sip_management.delete_dispatch_rule(room.id)
 
     assert mock_api.sip.delete_sip_dispatch_rule.call_count == 2
     mock_api.aclose.assert_called_once()
 
 
-@mock.patch("core.services.telephony.TelephonyService._list_dispatch_rules_ids")
+@mock.patch("core.services.sip_management.SIPManagement._list_dispatch_rules_ids")
 @mock.patch("core.utils.create_livekit_client")
 def test_delete_dispatch_rule_api_failure(mock_client_factory, mock_list_rules):
     """Test deleting dispatch rules when API fails immediately."""
-    telephony_service = TelephonyService()
+    sip_management = SIPManagement()
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
 
     mock_list_rules.return_value = ["rule-1"]
@@ -298,8 +302,131 @@ def test_delete_dispatch_rule_api_failure(mock_client_factory, mock_list_rules):
     )
     mock_client_factory.return_value = mock_api
 
-    with pytest.raises(TelephonyException, match="Could not delete dispatch rules"):
-        telephony_service.delete_dispatch_rule(room.id)
+    with pytest.raises(SIPException, match="Could not delete dispatch rules"):
+        sip_management.delete_dispatch_rule(room.id)
 
     mock_api.sip.delete_sip_dispatch_rule.assert_called_once()
     mock_api.aclose.assert_called_once()
+
+
+@mock.patch("core.utils.create_livekit_client")
+def test_create_dispatch_rule_conflict_raises_dedicated_error(mock_client_factory):
+    """Test that a LiveKit conflict error raises DispatchRuleConflictError."""
+    sip_management = SIPManagement()
+    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
+
+    mock_api = create_mock_livekit_client()
+    mock_api.sip.create_sip_dispatch_rule = mock.AsyncMock(
+        side_effect=TwirpError(
+            msg=(
+                "Dispatch rule for the same trunk, inbound number, number, and "
+                "PIN combination already exists in dispatch rule"
+            ),
+            code="already_exists",
+            status=409,
+        )
+    )
+    mock_client_factory.return_value = mock_api
+
+    with pytest.raises(DispatchRuleConflictError):
+        sip_management.create_dispatch_rule(room)
+
+    mock_api.aclose.assert_called_once()
+
+
+@mock.patch("core.utils.create_livekit_client")
+def test_ensure_dispatch_rule_creates_when_missing(mock_client_factory):
+    """Test that ensure_dispatch_rule creates the rule when none exists."""
+    sip_management = SIPManagement()
+    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
+
+    mock_api = create_mock_livekit_client()
+    mock_api.sip.list_sip_dispatch_rule = mock.AsyncMock(
+        return_value=ListSIPDispatchRuleResponse(items=[])
+    )
+    mock_api.sip.create_sip_dispatch_rule = mock.AsyncMock()
+    mock_client_factory.return_value = mock_api
+
+    created = sip_management.ensure_dispatch_rule(room)
+
+    assert created is True
+    mock_api.sip.create_sip_dispatch_rule.assert_called_once()
+    create_request = mock_api.sip.create_sip_dispatch_rule.call_args[1]["create"]
+
+    assert isinstance(create_request, CreateSIPDispatchRuleRequest)
+    assert create_request.name == f"SIP_{str(room.id)}"
+    assert create_request.rule.dispatch_rule_direct.room_name == str(room.id)
+    assert create_request.rule.dispatch_rule_direct.pin == str(room.pin_code)
+
+
+@mock.patch("core.utils.create_livekit_client")
+def test_ensure_dispatch_rule_skips_when_existing(mock_client_factory):
+    """Test that ensure_dispatch_rule is idempotent when the rule already exists."""
+    sip_management = SIPManagement()
+    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
+
+    existing_rule = SIPDispatchRuleInfo(
+        sip_dispatch_rule_id="rule-1", name=f"SIP_{str(room.id)}"
+    )
+    mock_api = create_mock_livekit_client()
+    mock_api.sip.list_sip_dispatch_rule = mock.AsyncMock(
+        return_value=ListSIPDispatchRuleResponse(items=[existing_rule])
+    )
+    mock_api.sip.create_sip_dispatch_rule = mock.AsyncMock()
+    mock_client_factory.return_value = mock_api
+
+    created = sip_management.ensure_dispatch_rule(room)
+
+    assert created is False
+    mock_api.sip.create_sip_dispatch_rule.assert_not_called()
+
+
+@mock.patch("core.utils.create_livekit_client")
+def test_ensure_dispatch_rule_returns_false_on_conflict(mock_client_factory):
+    """Test that ensure_dispatch_rule tolerates a concurrent rule creation.
+
+    If the rule is created by a concurrent caller (e.g. the LiveKit webhook)
+    between the existence check and the creation, LiveKit rejects the
+    duplicate and ensure_dispatch_rule reports the rule as already existing.
+    """
+    sip_management = SIPManagement()
+    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
+
+    mock_api = create_mock_livekit_client()
+    mock_api.sip.list_sip_dispatch_rule = mock.AsyncMock(
+        return_value=ListSIPDispatchRuleResponse(items=[])
+    )
+    mock_api.sip.create_sip_dispatch_rule = mock.AsyncMock(
+        side_effect=TwirpError(
+            msg=(
+                "Dispatch rule for the same trunk, inbound number, number, and "
+                "PIN combination already exists in dispatch rule"
+            ),
+            code="already_exists",
+            status=409,
+        )
+    )
+    mock_client_factory.return_value = mock_api
+
+    created = sip_management.ensure_dispatch_rule(room)
+
+    assert created is False
+
+
+@mock.patch("core.utils.create_livekit_client")
+def test_ensure_dispatch_rule_raises_on_other_failures(mock_client_factory):
+    """Test that ensure_dispatch_rule propagates unexpected LiveKit failures."""
+    sip_management = SIPManagement()
+    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, pin_code="1234")
+
+    mock_api = create_mock_livekit_client()
+    mock_api.sip.list_sip_dispatch_rule = mock.AsyncMock(
+        return_value=ListSIPDispatchRuleResponse(items=[])
+    )
+    mock_api.sip.create_sip_dispatch_rule = mock.AsyncMock(
+        side_effect=TwirpError(msg="Internal server error", code="unknown", status=500)
+    )
+    mock_client_factory.return_value = mock_api
+
+    with pytest.raises(SIPException, match="Could not create dispatch rule"):
+        sip_management.ensure_dispatch_rule(room)

src/backend/core/tests/test_models_rooms.py

@@ -184,12 +184,13 @@ def test_models_rooms_is_public_property():
 
 
 @mock.patch.object(Room, "generate_unique_pin_code")
-def test_telephony_disabled_skips_pin_generation(
+def test_telephony_and_roomkit_disabled_skips_pin_generation(
     mock_generate_unique_pin_code, settings
 ):
-    """Telephony disabled should not generate pin codes."""
+    """Telephony and roomkit both disabled should not generate pin codes."""
 
     settings.ROOM_TELEPHONY_ENABLED = False
+    settings.ROOMKIT_ENABLED = False
 
     room = RoomFactory()
 
@@ -197,6 +198,18 @@ def test_telephony_disabled_skips_pin_generation(
     assert room.pin_code is None
 
 
+def test_roomkit_enabled_generates_pin_code(settings):
+    """Roomkit enabled alone should generate pin codes, even without telephony."""
+
+    settings.ROOM_TELEPHONY_ENABLED = False
+    settings.ROOMKIT_ENABLED = True
+
+    room = RoomFactory()
+
+    assert room.pin_code is not None
+    assert len(room.pin_code) == settings.ROOM_TELEPHONY_PIN_LENGTH
+
+
 def test_default_and_custom_pin_length(settings):
     """Pin codes should be created with correct configured length."""
 

src/backend/core/urls.py

@@ -9,6 +9,7 @@ from rest_framework.routers import DefaultRouter, SimpleRouter
 from core.addons import viewsets as addons_viewsets
 from core.api import get_frontend_configuration, viewsets
 from core.external_api import viewsets as external_viewsets
+from core.roomkit import viewsets as roomkit_viewsets
 
 # - Main endpoints
 router = DefaultRouter()
@@ -19,6 +20,11 @@ router.register("files", viewsets.FileViewSet, basename="files")
 router.register(
     "resource-accesses", viewsets.ResourceAccessViewSet, basename="resource_accesses"
 )
+router.register(
+    "roomkit",
+    roomkit_viewsets.RoomKitViewSet,
+    basename="roomkit",
+)
 router.register(
     "addons/sessions",
     addons_viewsets.SessionViewSet,

src/backend/meet/settings.py

@@ -349,6 +349,11 @@ class Base(Configuration):
                 environ_name="CREATION_CALLBACK_THROTTLE_RATES",
                 environ_prefix=None,
             ),
+            "roomkit_join": values.Value(
+                default="300/minute",
+                environ_name="ROOMKIT_JOIN_THROTTLE_RATES",
+                environ_prefix=None,
+            ),
         },
     }
     MONITORED_THROTTLE_FAILURE_CALLBACK = (
@@ -881,6 +886,21 @@ class Base(Configuration):
         environ_prefix=None,
     )
 
+    # Roomkit (meeting-room SIP devices) integration
+    ROOMKIT_ENABLED = values.BooleanValue(
+        False,
+        environ_name="ROOMKIT_ENABLED",
+        environ_prefix=None,
+    )
+    # Server-to-server API token allowing the LiveKit SIP module to call the
+    # roomkit endpoints (e.g. join a room on behalf of a meeting-room device
+    # dialing in before any WebRTC participant).
+    ROOMKIT_SERVER_TO_SERVER_API_TOKEN = SecretFileValue(
+        None,
+        environ_name="ROOMKIT_SERVER_TO_SERVER_API_TOKEN",
+        environ_prefix=None,
+    )
+
     # Subtitles settings
     ROOM_SUBTITLE_ENABLED = values.BooleanValue(
         False, environ_name="ROOM_SUBTITLE_ENABLED", environ_prefix=None

src/backend/pyproject.toml

@@ -40,7 +40,7 @@ dependencies = [
     "django-storages[s3]==1.14.6",
     "django-timezone-field>=5.1",
     "django-pydantic-field==0.5.4",
-    "django==5.2.14",
+    "django==5.2.16",
     "djangorestframework==3.17.1",
     "drf_spectacular==0.29.0",
     "dockerflow==2026.3.4",

src/backend/uv.lock

@@ -586,16 +586,16 @@ wheels = [
 
 [[package]]
 name = "django"
-version = "5.2.14"
+version = "5.2.16"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "asgiref" },
     { name = "sqlparse" },
     { name = "tzdata", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/65/95/95f7faa0950867afaa0bef2460c6263afd6a2c78cc9434046ed28160b015/django-5.2.14.tar.gz", hash = "sha256:58a63ba841662e5c686b57ba1fec52ddd68c0b93bd96ac3029d55728f00bf8a2", size = 10895118, upload-time = "2026-05-05T13:57:31.104Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/26/889449d521ae508b26de715954faecd8bcf3f740affb81b2d146a83b42a5/django-5.2.16.tar.gz", hash = "sha256:59ea02020c3136fce14bef0bbece21a10a4febef5eed1c51c22ae468efa22200", size = 10890894, upload-time = "2026-07-07T13:52:17.005Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/14/44/f172870cf87aa25afef48fb72adba89ee8b77fcab6f3b23d240b923f1528/django-5.2.14-py3-none-any.whl", hash = "sha256:6f712143bd3064310d1f50fac859c3e9a274bdcfc9595339853be7779297fc76", size = 8311320, upload-time = "2026-05-05T13:57:25.795Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/13/1e5e3e4c15dcecb04281b3cb2a46a4670e1cef131068e202f6040df19224/django-5.2.16-py3-none-any.whl", hash = "sha256:04f354bf9d807a86ad1a8392fe3808d362358a8eafc322848e0e43e59b24371d", size = 8311943, upload-time = "2026-07-07T13:52:11.223Z" },
 ]
 
 [[package]]
@@ -1260,7 +1260,7 @@ requires-dist = [
     { name = "brotli", specifier = "==1.2.0" },
     { name = "celery", extras = ["redis"], specifier = "==5.6.3" },
     { name = "dj-database-url", specifier = "==3.1.2" },
-    { name = "django", specifier = "==5.2.14" },
+    { name = "django", specifier = "==5.2.16" },
     { name = "django-configurations", specifier = "==2.5.1" },
     { name = "django-cors-headers", specifier = "==4.9.0" },
     { name = "django-countries", specifier = "==9.0.0" },

src/frontend/src/components/Avatar.tsx

@@ -59,9 +59,10 @@ export const Avatar = React.memo(
           <text
             x="50"
             y="50"
+            dy="-0.08em"
             textAnchor="middle"
             dominantBaseline="central"
-            fontSize={initials.length > 1 ? 48 : 52}
+            fontSize="52"
             fontWeight="500"
             fill="currentColor"
           >