dsh-live-voice 0.6.2 → 0.7.0

package/deploy/attendee/README.md

@@ -0,0 +1,34 @@
+# Compose-managed Attendee audio
+
+These deployment assets are included in the Live Voice plugin. They complement the existing Attendee development Compose stack; they are not a separate package, host daemon or public proxy.
+
+## Start
+
+Set `DSH_LIVE_VOICE_DEPLOY` to this directory’s absolute path. Append `-f "$DSH_LIVE_VOICE_DEPLOY/compose.dsh-audio.yaml"` to the same Compose command you already use for Attendee, preserving every ARM64/FakeCloud override, then run `up -d`. The default image is `attendee-local:arm64`; set `DSH_ATTENDEE_IMAGE` to a compatible existing Attendee image if needed. The image must include Python, cryptography and websockets 14.1. No new image download is required when that image already exists.
+
+Compose provisions deployment-local TLS material in two named volumes and configures the worker’s `SSL_CERT_FILE`. The private key is mounted only in the initializer/relay, never the worker. A loopback-only descriptor (18766) gives the local plugin the public certificate; the host verifies TLS on its receiving connection (18765). The worker verifies the internal `dsh-audio-bridge` name with the public bundle. This trusts the local machine/Docker environment, not a hostile process that can impersonate loopback services. Never forward these ports. The relay validates the project API key against `attendee-app-local` before providing an ephemeral producer URL. The request uses the fixed `localhost:8000` Host header expected by the upstream development Django configuration, not a caller-controlled host. The loopback ports are 18765/18766, avoiding the memory service’s common 8765 port.
+
+In DSH, connect to Attendee without setting an advanced receiver URL. The plugin discovers the bridge and coordinates its secret URL automatically when creating a bot. Disconnecting DSH only revokes reception; explicitly use Leave meeting for the bot to depart.
+
+## Lifecycle and limits
+
+- No Docker socket, arbitrary proxy destination, DSH credentials or host filesystem is exposed by the relay.
+- One consumer and one producer at a time; 128 KB messages, bounded WebSocket queues, no compression or replay. Slow/invalid/disconnected sessions close rather than silently archive/drop audio.
+- The certificate lasts 90 days and is reused until near expiry. The initializer renews it on its next execution; recreate the initializer and bridge together for renewal. Mounted public roots are used for new worker TLS connections. Restart dependent workers outside meetings if required. Continuous unattended renewal is not implemented.
+- Recreating workers to apply the override interrupts their active bots. Do not apply it during a meeting.
+- Stop with the same Compose file set. Removing named volumes deletes TLS material; regenerate it by rerunning the initializer. Do not remove the existing Postgres/FakeCloud volumes.
+- This override targets upstream development service names and the same-machine Docker setup. Remote Docker, custom service names and arbitrary bridge ports are not automatically discovered.
+
+## Isolated test
+
+From the plugin checkout, with its compatible Attendee image already built:
+
+```sh
+docker run --rm --network none --entrypoint python -v "$PWD/packages/live-voice/deploy/attendee:/dsh:ro" attendee-local:arm64 /dsh/test_audio_bridge.py
+```
+
+This checks TLS, certificate/bundle reuse, capability rejection, binary/oversize rejection, receive-only policy, forwarding and revocation in a disposable container. A separate HTTP test exercises the real credential-verification function against a local fixture API, including 401, malformed headers and redirect refusal. The WebSocket test stubs only its API admission callback. It does not start a bot or contact Meet. See the repository Attendee guide for full runtime acceptance limits.
+
+## Cross-runtime verification
+
+From the repository root, run `node scripts/test-attendee-relay.mjs` to connect the actual Node host consumer to the actual Python relay in a disposable container. It publishes random loopback ports, sends PCM from two UUIDs, and checks producer revocation when the receiver closes. Its authentication callback accepts only a fixture key; it never creates a bot, calls Meet, imports host certificates or recreates production services. The runner stops its exact named container on failure and removes it on normal exit. It requires Docker and the existing compatible image, so it is an explicit integration check rather than part of `npm test`.

package/deploy/attendee/audio_bridge.py

@@ -0,0 +1,186 @@
+"""DSH-local audio relay. No shell, generic proxy, recordings, or audio logs."""
+import asyncio
+import datetime
+import hmac
+import json
+import os
+import re
+from pathlib import Path
+import secrets
+import ssl
+import urllib.error
+import urllib.request
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from threading import Thread
+from urllib.parse import urlsplit, parse_qs
+from websockets.exceptions import ConnectionClosed
+
+MAX_MESSAGE = 128000
+PUBLIC = Path(os.environ.get("BRIDGE_PUBLIC", "/bridge-public"))
+PRIVATE = Path(os.environ.get("BRIDGE_PRIVATE", "/bridge-private"))
+
+
+def provision():
+    from cryptography import x509
+    from cryptography.hazmat.primitives import hashes, serialization
+    from cryptography.hazmat.primitives.asymmetric import rsa
+    from cryptography.x509.oid import NameOID, ExtendedKeyUsageOID
+    import ipaddress
+    PUBLIC.mkdir(parents=True, exist_ok=True)
+    PRIVATE.mkdir(parents=True, exist_ok=True)
+    if (PUBLIC / "server.pem").exists() and (PRIVATE / "server.key").exists():
+        try:
+            cert = x509.load_pem_x509_certificate((PUBLIC / "server.pem").read_bytes())
+            existing_key = serialization.load_pem_private_key((PRIVATE / "server.key").read_bytes(), password=None)
+            same_key = existing_key.public_key().public_numbers() == cert.public_key().public_numbers()
+            if same_key and cert.not_valid_after_utc > datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(days=2):
+                # Repair/rebuild the public bundle if an earlier initializer was interrupted.
+                roots = Path("/etc/ssl/certs/ca-certificates.crt").read_bytes()
+                (PUBLIC / "ca-bundle.pem").write_bytes(roots + b"\n" + (PUBLIC / "server.pem").read_bytes())
+                (PRIVATE / "server.key").chmod(0o600)
+                return
+        except (ValueError, OSError):
+            pass
+    key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+    name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "DSH local Attendee audio")])
+    now = datetime.datetime.now(datetime.timezone.utc)
+    cert = (x509.CertificateBuilder().subject_name(name).issuer_name(name).public_key(key.public_key())
+            .serial_number(x509.random_serial_number()).not_valid_before(now - datetime.timedelta(minutes=5))
+            .not_valid_after(now + datetime.timedelta(days=90))
+            .add_extension(x509.BasicConstraints(ca=True, path_length=0), critical=True)
+            .add_extension(x509.SubjectAlternativeName([x509.DNSName("dsh-audio-bridge"), x509.DNSName("localhost"), x509.IPAddress(ipaddress.ip_address("127.0.0.1"))]), critical=False)
+            .add_extension(x509.ExtendedKeyUsage([ExtendedKeyUsageOID.SERVER_AUTH]), critical=False)
+            .sign(key, hashes.SHA256()))
+    path = PRIVATE / "server.key"
+    path.write_bytes(key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8, serialization.NoEncryption()))
+    path.chmod(0o600)
+    pem = cert.public_bytes(serialization.Encoding.PEM)
+    (PUBLIC / "server.pem").write_bytes(pem)
+    # Keep public roots for normal Meet HTTPS; add only this deployment's certificate.
+    roots = Path("/etc/ssl/certs/ca-certificates.crt").read_bytes()
+    (PUBLIC / "ca-bundle.pem").write_bytes(roots + b"\n" + pem)
+
+
+class Descriptor(BaseHTTPRequestHandler):
+    def do_GET(self):
+        if self.path != "/v1/descriptor":
+            self.send_error(404)
+            return
+        body = json.dumps({"protocol": "dsh-attendee-relay-v1", "certificate": (PUBLIC / "server.pem").read_text()}).encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Cache-Control", "no-store")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def setup(self):
+        super().setup()
+        self.connection.settimeout(5)
+
+    def log_message(self, *_):
+        pass
+
+
+class NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, *args, **kwargs):
+        return None
+
+
+def authorized(header):
+    if not header or not re.fullmatch(r"Token [\x21-\x7e]{8,512}", header):
+        return False
+    request = urllib.request.Request("http://attendee-app-local:8000/api/v1/bots?limit=1", headers={"Authorization": header, "Host": "localhost:8000"})
+    try:
+        with urllib.request.build_opener(urllib.request.ProxyHandler({}), NoRedirect()).open(request, timeout=5) as response:
+            return response.status == 200
+    except (OSError, urllib.error.URLError):
+        return False
+
+
+class Relay:
+    def __init__(self):
+        self.lease = None
+        self.lock = asyncio.Lock()
+        self.auth_slots = asyncio.Semaphore(4)
+
+    async def process_request(self, connection, request):
+        if request.headers.get("Origin"):
+            return connection.respond(HTTPStatus.FORBIDDEN, "Forbidden\n")
+        path = urlsplit(request.path)
+        if path.path == "/v1/receive":
+            if self.lease or self.auth_slots.locked():
+                return connection.respond(HTTPStatus.SERVICE_UNAVAILABLE, "Busy\n")
+            async with self.auth_slots:
+                if not await asyncio.to_thread(authorized, request.headers.get("Authorization")):
+                    return connection.respond(HTTPStatus.FORBIDDEN, "Forbidden\n")
+        elif path.path == "/ingest":
+            token = parse_qs(path.query).get("token", [""])[0]
+            lease = self.lease
+            if not lease or not re.fullmatch(r"[a-f0-9]{64}", token) or not hmac.compare_digest(token, lease["token"]) or lease["producer"]:
+                return connection.respond(HTTPStatus.FORBIDDEN, "Forbidden\n")
+        else:
+            return connection.respond(HTTPStatus.NOT_FOUND, "Not found\n")
+
+    async def handler(self, socket):
+        path = urlsplit(socket.request.path)
+        if path.path == "/v1/receive":
+            async with self.lock:
+                if self.lease:
+                    await socket.close(1008, "busy")
+                    return
+                lease = {"consumer": socket, "producer": None, "token": secrets.token_hex(32)}
+                self.lease = lease
+            try:
+                await socket.send(json.dumps({"type": "ready", "ingestUrl": "wss://dsh-audio-bridge:18765/ingest?token=" + lease["token"]}))
+                async for _ in socket:
+                    # Consumers receive only; unsolicited application writes are invalid.
+                    await socket.close(1008, "receive only")
+                    break
+            except ConnectionClosed:
+                pass
+            finally:
+                if self.lease is lease:
+                    self.lease = None
+                if lease["producer"]:
+                    await lease["producer"].close(1000, "receiver closed")
+        else:
+            async with self.lock:
+                lease = self.lease
+                token = parse_qs(path.query).get("token", [""])[0]
+                if not lease or lease["producer"] or not re.fullmatch(r"[a-f0-9]{64}", token) or not hmac.compare_digest(token, lease["token"]):
+                    await socket.close(1008, "ownership")
+                    return
+                lease["producer"] = socket
+            try:
+                async for message in socket:
+                    if not isinstance(message, str):
+                        raise ValueError("binary")
+                    # The plugin performs strict protocol, bot, UUID and PCM validation.
+                    await asyncio.wait_for(lease["consumer"].send(message), timeout=5)
+            except Exception:
+                pass
+            finally:
+                await lease["consumer"].close(1008, "audio disconnected")
+
+
+async def run():
+    from websockets.asyncio.server import serve
+    context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+    context.load_cert_chain(PUBLIC / "server.pem", PRIVATE / "server.key")
+    relay = Relay()
+    descriptor = ThreadingHTTPServer(("0.0.0.0", 18766), Descriptor)
+    Thread(target=descriptor.serve_forever, daemon=True).start()
+    async with serve(relay.handler, "0.0.0.0", 18765, ssl=context, process_request=relay.process_request,
+                     max_size=MAX_MESSAGE, max_queue=16, write_limit=64000, compression=None,
+                     open_timeout=8, close_timeout=2, ping_interval=10, ping_timeout=10):
+        await asyncio.Future()
+
+
+if __name__ == "__main__":
+    import sys
+    if "--init" in sys.argv:
+        provision()
+    else:
+        asyncio.run(run())

package/deploy/attendee/compose.dsh-audio.yaml

@@ -0,0 +1,54 @@
+# Add after Attendee base + ARM64/FakeCloud overrides. No host process or public port.
+x-bridge-image: &bridge-image
+  image: ${DSH_ATTENDEE_IMAGE:-attendee-local:arm64}
+  entrypoint: []
+services:
+  dsh-audio-init:
+    <<: *bridge-image
+    user: "0:0"
+    command: ["python", "/dsh/audio_bridge.py", "--init"]
+    volumes:
+      - ${DSH_LIVE_VOICE_DEPLOY:-../packages/live-voice/deploy/attendee}/audio_bridge.py:/dsh/audio_bridge.py:ro
+      - dsh-audio-public:/bridge-public
+      - dsh-audio-private:/bridge-private
+    network_mode: none
+    restart: "no"
+  dsh-audio-bridge:
+    <<: *bridge-image
+    user: "0:0"
+    command: ["python", "/dsh/audio_bridge.py"]
+    depends_on:
+      dsh-audio-init:
+        condition: service_completed_successfully
+    volumes:
+      - ${DSH_LIVE_VOICE_DEPLOY:-../packages/live-voice/deploy/attendee}/audio_bridge.py:/dsh/audio_bridge.py:ro
+      - dsh-audio-public:/bridge-public:ro
+      - dsh-audio-private:/bridge-private:ro
+    ports:
+      - "127.0.0.1:18765:18765"
+      - "127.0.0.1:18766:18766"
+    networks:
+      - attendee_network
+    restart: unless-stopped
+    read_only: true
+    tmpfs:
+      - /tmp
+    cap_drop: [ALL]
+    security_opt: ["no-new-privileges:true"]
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:18766/v1/descriptor', timeout=2).close()"]
+      interval: 5s
+      timeout: 3s
+      retries: 10
+  attendee-worker-local:
+    image: ${DSH_ATTENDEE_IMAGE:-attendee-local:arm64}
+    environment:
+      SSL_CERT_FILE: /dsh-audio-public/ca-bundle.pem
+    volumes:
+      - dsh-audio-public:/dsh-audio-public:ro
+    depends_on:
+      dsh-audio-bridge:
+        condition: service_healthy
+volumes:
+  dsh-audio-public:
+  dsh-audio-private:

package/deploy/attendee/cross_runtime_fixture.py

@@ -0,0 +1,46 @@
+"""Disposable cross-runtime fixture. Fake API admission, real relay/TLS/PCM."""
+import asyncio
+import json
+from pathlib import Path
+import ssl
+import tempfile
+from threading import Thread
+from http.server import ThreadingHTTPServer
+import audio_bridge as bridge
+from websockets.asyncio.server import serve
+from websockets.asyncio.client import connect
+
+
+async def main():
+    with tempfile.TemporaryDirectory() as directory:
+        bridge.PUBLIC = Path(directory) / "public"
+        bridge.PRIVATE = Path(directory) / "private"
+        bridge.provision()
+        bridge.authorized = lambda header: header == "Token cross-runtime-test-key"
+        tls = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        tls.load_cert_chain(bridge.PUBLIC / "server.pem", bridge.PRIVATE / "server.key")
+        client_tls = ssl.create_default_context(cafile=str(bridge.PUBLIC / "ca-bundle.pem"))
+        relay = bridge.Relay()
+        descriptor = ThreadingHTTPServer(("0.0.0.0", 18766), bridge.Descriptor)
+        Thread(target=descriptor.serve_forever, daemon=True).start()
+        async with serve(relay.handler, "0.0.0.0", 18765, ssl=tls, process_request=relay.process_request,
+                         max_size=bridge.MAX_MESSAGE, max_queue=16, compression=None):
+            print("fixture-ready", flush=True)
+            for _ in range(2000):
+                if relay.lease:
+                    break
+                await asyncio.sleep(0.01)
+            if not relay.lease:
+                raise RuntimeError("receiver deadline exceeded")
+            token = relay.lease["token"]
+            async with connect("wss://localhost:18765/ingest?token=" + token, ssl=client_tls) as producer:
+                for uuid in ["device/python-one", "device/python-two"]:
+                    await producer.send(json.dumps({"trigger":"realtime_audio.per_participant","bot_id":"bot_CrossRuntime","data":{"participant_uuid":uuid,"chunk":"AID/fw==","sample_rate":16000,"timestamp_ms":1000}}))
+                await asyncio.wait_for(producer.wait_closed(), 15)
+            print("producer-revoked", flush=True)
+            descriptor.shutdown()
+            descriptor.server_close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/deploy/attendee/test_audio_bridge.py

@@ -0,0 +1,170 @@
+"""Isolated integration checks; never starts a bot or contacts a meeting."""
+import asyncio
+import importlib.util
+import json
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from threading import Thread
+import urllib.request
+from pathlib import Path
+import ssl
+import tempfile
+import unittest
+from unittest.mock import patch
+
+spec = importlib.util.spec_from_file_location("audio_bridge", Path(__file__).with_name("audio_bridge.py"))
+bridge = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(bridge)
+
+
+class RelayTest(unittest.IsolatedAsyncioTestCase):
+    async def test_api_admission_is_bounded_without_queueing_extra_auth_requests(self):
+        from types import SimpleNamespace
+        from threading import Event, Lock
+        gate = Event()
+        lock = Lock()
+        started = []
+        def slow_auth(_):
+            with lock:
+                started.append(True)
+            gate.wait(timeout=2)
+            return True
+        relay = bridge.Relay()
+        connection = SimpleNamespace(respond=lambda status, body: status)
+        request = SimpleNamespace(path="/v1/receive", headers={"Authorization": "Token test-only-key"})
+        with patch.object(bridge, "authorized", slow_auth):
+            tasks = [asyncio.create_task(relay.process_request(connection, request)) for _ in range(4)]
+            try:
+                for _ in range(100):
+                    if len(started) == 4:
+                        break
+                    await asyncio.sleep(0.005)
+                self.assertEqual(len(started), 4)
+                self.assertEqual(await relay.process_request(connection, request), bridge.HTTPStatus.SERVICE_UNAVAILABLE)
+                self.assertEqual(len(started), 4)
+            finally:
+                gate.set()
+                await asyncio.gather(*tasks)
+
+    async def test_real_tls_audio_ownership_and_revocation(self):
+        from websockets.asyncio.server import serve
+        from websockets.asyncio.client import connect
+        from websockets.exceptions import InvalidStatus
+        with tempfile.TemporaryDirectory() as directory:
+            bridge.PUBLIC = Path(directory) / "public"
+            bridge.PRIVATE = Path(directory) / "private"
+            bridge.provision()
+            first = (bridge.PUBLIC / "server.pem").read_bytes()
+            (bridge.PUBLIC / "ca-bundle.pem").unlink()
+            bridge.provision()
+            self.assertIn(first, (bridge.PUBLIC / "ca-bundle.pem").read_bytes())
+            self.assertEqual(first, (bridge.PUBLIC / "server.pem").read_bytes())
+            self.assertEqual((bridge.PRIVATE / "server.key").stat().st_mode & 0o777, 0o600)
+            server_tls = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+            server_tls.load_cert_chain(bridge.PUBLIC / "server.pem", bridge.PRIVATE / "server.key")
+            client_tls = ssl.create_default_context(cafile=str(bridge.PUBLIC / "ca-bundle.pem"))
+            relay = bridge.Relay()
+            with patch.object(bridge, "authorized", lambda value: value == "Token test-only-key"):
+                async with serve(relay.handler, "127.0.0.1", 0, ssl=server_tls, process_request=relay.process_request,
+                                 max_size=bridge.MAX_MESSAGE, max_queue=16, compression=None) as server:
+                    origin = "wss://127.0.0.1:" + str(server.sockets[0].getsockname()[1])
+                    loop = asyncio.get_running_loop()
+                    original_handler = loop.get_exception_handler()
+                    def expected_tls_reset(loop, context):
+                        if isinstance(context.get("exception"), ConnectionResetError):
+                            return
+                        if original_handler:
+                            original_handler(loop, context)
+                        else:
+                            loop.default_exception_handler(context)
+                    loop.set_exception_handler(expected_tls_reset)
+                    self.addCleanup(loop.set_exception_handler, original_handler)
+                    with self.assertRaises(ssl.SSLCertVerificationError):
+                        async with connect(origin + "/v1/receive"):
+                            self.fail("Untrusted certificate admitted")
+                    for path, headers in [("/v1/receive", {}), ("/v1/receive", {"Authorization": "Token test-only-key", "Origin": "https://foreign.example"}), ("/ingest?token=bad", {}), ("/ingest?token=%C3%A9", {})]:
+                        with self.assertRaises(InvalidStatus):
+                            async with connect(origin + path, ssl=client_tls, additional_headers=headers):
+                                self.fail("Unauthorized peer admitted")
+                    async with connect(origin + "/v1/receive", ssl=client_tls, additional_headers={"Authorization": "Token test-only-key"}) as consumer:
+                        ready = json.loads(await consumer.recv())
+                        self.assertEqual(ready["type"], "ready")
+                        token = ready["ingestUrl"].split("token=")[1]
+                        self.assertEqual(len(token), 64)
+                        async with connect(origin + "/ingest?token=" + token, ssl=client_tls) as producer:
+                            packet = json.dumps({"trigger": "realtime_audio.per_participant", "bot_id": "bot_Test", "data": {"participant_uuid": "device/1", "chunk": "AAAAAA==", "timestamp_ms": 1000, "sample_rate": 16000}})
+                            await producer.send(packet)
+                            self.assertEqual(await consumer.recv(), packet)
+                            with self.assertRaises(InvalidStatus):
+                                async with connect(origin + "/ingest?token=" + token, ssl=client_tls):
+                                    self.fail("Second producer admitted")
+                            await consumer.close()
+                            await asyncio.wait_for(producer.wait_closed(), 2)
+                    await asyncio.sleep(0)
+                    with self.assertRaises(InvalidStatus):
+                        async with connect(origin + "/ingest?token=" + token, ssl=client_tls):
+                            self.fail("Expired token admitted")
+                    for payload in [b"binary-is-not-audio-json", "x" * (bridge.MAX_MESSAGE + 1)]:
+                        async with connect(origin + "/v1/receive", ssl=client_tls, additional_headers={"Authorization": "Token test-only-key"}) as consumer:
+                            ready = json.loads(await consumer.recv())
+                            token = ready["ingestUrl"].split("token=")[1]
+                            async with connect(origin + "/ingest?token=" + token, ssl=client_tls) as producer:
+                                await producer.send(payload)
+                                await asyncio.wait_for(consumer.wait_closed(), 2)
+                                self.assertEqual(consumer.close_code, 1008)
+                                await asyncio.wait_for(producer.wait_closed(), 2)
+                        await asyncio.sleep(0)
+                    async with connect(origin + "/v1/receive", ssl=client_tls, additional_headers={"Authorization": "Token test-only-key"}) as consumer:
+                        await consumer.recv()
+                        await consumer.send("unsolicited-write")
+                        await asyncio.wait_for(consumer.wait_closed(), 2)
+                        self.assertEqual(consumer.close_code, 1008)
+            self.assertIsNone(relay.lease)
+
+
+class AuthenticationTest(unittest.TestCase):
+    def test_real_http_auth_rejects_bad_keys_redirects_and_malformed_headers(self):
+        calls = []
+        class Api(BaseHTTPRequestHandler):
+            def do_GET(self):
+                calls.append((self.path, self.headers.get("Authorization")))
+                if self.headers.get("Host") != "localhost:8000":
+                    self.send_response(400)
+                    self.end_headers()
+                    return
+                if self.path == "/redirect-target":
+                    self.send_response(200)
+                elif self.headers.get("Authorization") == "Token redirect-key":
+                    self.send_response(302)
+                    self.send_header("Location", "/redirect-target")
+                elif self.headers.get("Authorization") == "Token valid-test-key":
+                    self.send_response(200)
+                else:
+                    self.send_response(401)
+                self.end_headers()
+            def log_message(self, *_):
+                pass
+        api = ThreadingHTTPServer(("127.0.0.1", 0), Api)
+        thread = Thread(target=api.serve_forever, daemon=True)
+        thread.start()
+        real_request = urllib.request.Request
+        def route_request(url, **kwargs):
+            self.assertEqual(url, "http://attendee-app-local:8000/api/v1/bots?limit=1")
+            return real_request("http://127.0.0.1:" + str(api.server_port) + "/api/v1/bots?limit=1", **kwargs)
+        try:
+            with patch.dict("os.environ", {"http_proxy": "http://127.0.0.1:1", "HTTP_PROXY": "http://127.0.0.1:1", "no_proxy": "", "NO_PROXY": ""}), patch.object(bridge.urllib.request, "Request", route_request):
+                self.assertTrue(bridge.authorized("Token valid-test-key"))
+                self.assertFalse(bridge.authorized("Token invalid-key"))
+                self.assertFalse(bridge.authorized("Token redirect-key"))
+                count = len(calls)
+                for header in [None, "", "Bearer valid-test-key", "Token x\r\nHost: evil", "Token nonascii-é", "Token " + "x" * 520]:
+                    self.assertFalse(bridge.authorized(header))
+                self.assertEqual(len(calls), count)
+                self.assertEqual(len(calls), 3, "Redirect must not leak the key to a follow-up request")
+        finally:
+            api.shutdown()
+            api.server_close()
+            thread.join(timeout=2)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/lib/asr/asr.worker.js

@@ -36682,7 +36682,7 @@ async function createQwenRuntime(options) {
 }
 
 // src/modules/recognition/local/assets.ts
-var browserAsrAssetBase = () => "/api/dsh-live-voice/asr/" + encodeURIComponent(true ? "0.6.2" : "test") + "/";
+var browserAsrAssetBase = () => "/api/dsh-live-voice/asr/" + encodeURIComponent(true ? "0.7.0" : "test") + "/";
 
 // src/modules/recognition/local/modelCatalog.ts
 var browserAsrModels = [

package/lib/asr/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.6.2",
+  "version": "0.7.0",
   "assets": [
     "asr.worker.js",
     "manifest.json",