Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
fix(deploy): add production preflight checks (#4)
AAA987a5820b8fc
diff --git a/.env.example b/.env.exampleindex 3c758c62..ea895cf6 100644--- a/.env.example+++ b/.env.example@@ -1,4 +1,7 @@# Application+# Keep the default loopback binding behind a local reverse proxy. Set+# LISTEN_HOST=0.0.0.0 explicitly only for a container or trusted LAN listener.+LISTEN_HOST=127.0.0.1PORT=8787PUBLIC_BASE_URL=http://localhost:8787ALLOWED_ORIGINS=http://localhost:8787diff --git a/README.md b/README.mdindex c2b46c2b..ea3601c4 100644--- a/README.md+++ b/README.md@@ -17,6 +17,11 @@ npm run devOpen `http://localhost:8787`. The default development configuration uses a localhost origin and has no STUN or TURN server, so it is suitable only for same-machine checks. Multi-device or cross-network use requires HTTPS and the production-shaped ICE configuration documented separately.+The server binds `127.0.0.1` by default. Set `LISTEN_HOST=0.0.0.0` explicitly+only when a container or trusted LAN deployment requires it. Production startup+also requires separate TURN/UDP, TURN/TCP, and TURN/TLS-on-TCP-443 URLs; this is+a configuration preflight, not evidence that the external relay path works.+Run the complete automated validation with:```shdiff --git a/docs/deployment.md b/docs/deployment.mdindex 14f0ee28..4fedcc31 100644--- a/docs/deployment.md+++ b/docs/deployment.md@@ -42,7 +42,10 @@ Run `npm start` under a service supervisor that injects the environment, restarton failure, and applies bounded logs. For a simple untracked environment file,the equivalent direct launch is`node --env-file=.env.production dist/server/server/index.js`. Do not expose port-8787 to the Internet.+8787 to the Internet. The application binds `127.0.0.1` by default. Set+`LISTEN_HOST=0.0.0.0` explicitly only when a container runtime or trusted LAN+path requires an externally reachable listener, then enforce the intended+network boundary with container publishing rules or a host firewall.## Production application environment@@ -59,6 +62,7 @@ Use this production baseline:```dotenvNODE_ENV=production+LISTEN_HOST=127.0.0.1PORT=8787PUBLIC_BASE_URL=https://share.example.comALLOWED_ORIGINS=https://share.example.com@@ -80,6 +84,16 @@ browsers receive HMAC-SHA1-derived, time-limited credentials after roomauthentication. Keep host clocks synchronized because the credential usernamecontains its Unix expiry time.+Production startup validates the configured TURN transport mix before the+server listens. The baseline must contain separate `TURN_URLS` entries for+`turn:` with explicit `transport=udp`, `turn:` with explicit `transport=tcp`,+and `turns:` with explicit port 443 and `transport=tcp`. This startup check only+validates configuration shape; it does not prove that DNS, certificates,+firewall rules, NAT mappings, or the coturn listeners work from an external+network. Every STUN and TURN entry is also syntax-checked; use the exact+lowercase TURN query forms shown above because one malformed ICE URL can make a+browser reject the whole peer-connection configuration.+## HTTPS and WSS ingressTerminate public TLS at Caddy or nginx and proxy every application path to the@@ -110,6 +124,13 @@ Keep the proxy's access-log retention bounded and access controlled. Viewertokens are URL fragments and therefore are not sent in HTTP requests, but logsstill contain network metadata and must not be treated as public artifacts.+For a process-level liveness probe, send `GET /healthz`. A running process+returns HTTP 200 with `{"status":"ok"}` and `Cache-Control: no-store`; other+methods return 405 with `Allow: GET`. The endpoint does not inspect room state,+TURN reachability, or any external dependency, so use it only to decide whether+the Node process can accept HTTP requests. It is not a deployment-readiness or+end-to-end media check.+## coturnCopy [`deploy/coturn/turnserver.conf.example`](../deploy/coturn/turnserver.conf.example)diff --git a/docs/project-memory.md b/docs/project-memory.mdindex 5eb581fe..e7482715 100644--- a/docs/project-memory.md+++ b/docs/project-memory.md@@ -31,7 +31,7 @@ Last updated: 2026-08-18## Current Implementation-- The repository contains a single npm package using Node.js 24, React, TypeScript, Vite, native WebRTC, `ws`, Zod, Vitest, and a separate coturn deployment.+- The repository contains a single npm package using Node.js 24, React, TypeScript, Vite, native WebRTC, `ws`, Zod, Vitest, and a separate coturn deployment. The server binds to loopback by default, provides a process-only `/healthz` liveness endpoint, and requires the full TURN/UDP, TURN/TCP, and TURN/TLS-on-TCP-443 URL mix before production startup; these checks do not establish public-network reachability.- The Web PoC implements capture-before-room creation, live source replacement without renegotiating healthy peers, expiring role tokens, one independent peer connection per viewer, stable signaling reconnect identities, explicit ICE restart or peer rebuild, host generation isolation, short-lived TURN credentials, three manual quality profiles, and local WebRTC statistics.- Automated checks and same-machine synthetic-media Chromium recovery tests pass, including lost offer/answer, one transient offer failure, signaling-only viewer reconnect, viewer-tab replacement with old-peer cleanup, cancelled-room cleanup, and video/audio source changes on an existing connection. Real screen/game audio, public TURN/NAT behavior, mobile lifecycle handling, and latency or quality targets remain unverified.- The next milestone is a staging coturn deployment and the manual matrix in `docs/status.md`, not additional product surface or a native sender.diff --git a/docs/research/webrtc-p2p-screen-sharing.md b/docs/research/webrtc-p2p-screen-sharing.mdindex f2e83fa7..9f3f1c8e 100644--- a/docs/research/webrtc-p2p-screen-sharing.md+++ b/docs/research/webrtc-p2p-screen-sharing.md@@ -264,6 +264,8 @@ WebRTC 标准没有承诺固定毫秒延迟。工程目标必须带网络条件- `ws.close()` 默认会等待关闭握手,不能用“升级成功后发送 close frame”实现公网连接硬上限。总连接和未鉴权连接容量应在 `handleUpgrade()` 前检查,超限直接返回 HTTP 503 并销毁底层 socket。- Node 的 `IncomingMessage.url` 是未经应用路由解析的 request-target,而 WHATWG `URL` 构造器会拒绝部分输入。upgrade handler 必须捕获解析失败并关闭 socket,不能让未鉴权输入抛到 EventEmitter 顶层。- coturn 使用 `use-auth-secret` 支持的 TURN REST 短期凭据:`base64(HMAC-SHA1(secret, expiry + ":" + subject))`。coturn 不提供 HTTP 凭据接口,必须由已鉴权的应用服务生成。+- RFC 7065/5928 将 `turn` + UDP、`turn` + TCP 和 `turns` + TCP 分别映射到客户端至 TURN 的 UDP、TCP 和 TLS 传输。WebRTC 会逐条验证 ICE URL,任一坏项都可能使整个 PeerConnection 配置失败,因此启动预检先按原始 URI 语法 fail closed,再要求三类目标 URL 显式声明小写 `transport`,且 TLS URL 显式使用 TCP 443;这只能验证配置形状,不能替代公网 relay allocation 测试。+- Node `server.listen()` 省略 host 时可能监听未指定 IPv6 地址或 `0.0.0.0`。单机反向代理基线应显式绑定 loopback,容器或可信 LAN 才通过配置选择宽绑定;进程级 HTTP 健康检查不应同步探测 TURN 或其他外部网络。- 截至本次复核,coturn 应使用 4.17.2 或更新补丁版本;4.17.2 修复了此前补丁版本的 UDP TTL 回归。- MiroTalk BRO 当前 P2P 模式仍是 broadcaster 对每位 viewer 建独立连接;Screego 也采用独立 session 和 HMAC TURN 凭据。这验证了拓扑,但两者的静态/长时凭据与轻量恢复策略不直接照搬。- Screego 的分享生命周期保持简单,当前客户端在分享停止时关闭 peers,未提供 `replaceTrack()` 换源路径,且为 GPL-3.0;本项目只借鉴其边界清晰的生命周期,不复制实现。Tailchat Meeting 使用 Apache-2.0,但其媒体生产者生命周期绑定 mediasoup/SFU;只参考捕获状态,不引入与 ADR-0001 冲突的拓扑。@@ -277,6 +279,9 @@ WebRTC 标准没有承诺固定毫秒延迟。工程目标必须带网络条件- [coturn 4.17.2 release](https://github.com/coturn/coturn/releases/tag/4.17.2)- [coturn turnserver documentation](https://github.com/coturn/coturn/blob/master/README.turnserver)- [coturn example configuration](https://github.com/coturn/coturn/blob/master/examples/etc/turnserver.conf)+- [TURN URI scheme RFC 7065](https://www.rfc-editor.org/rfc/rfc7065.html)+- [TURN TCP/TLS allocations RFC 5928](https://www.rfc-editor.org/rfc/rfc5928.html)+- [Node.js 24 `server.listen`](https://nodejs.org/docs/latest-v24.x/api/net.html#serverlistenport-host-backlog-callback)## 实施难度与预估diff --git a/docs/status.md b/docs/status.mdindex e3f65c17..9e89ed6b 100644--- a/docs/status.md+++ b/docs/status.md@@ -18,13 +18,15 @@ The first measurable WebRTC Web proof of concept is implemented. Automated check## Verified In This Revision-- `npm run check` passes type checking, 43 Vitest tests, the client production build, and the server production build.+- `npm run check` passes type checking, 54 Vitest tests, the client production build, and the server production build.- Headless Chromium 151 created real local peer connections from animated canvas streams. The viewer reached `connected`, received a live video track, and reported a direct UDP path.- Browser fault injection recovered after dropping the first offer, dropping the first answer, and failing the first `createOffer`. A viewer-only signaling reconnect preserved the existing healthy media peer; replacing that viewer tab rebuilt media, released the old peer, and did not enter a reconnect loop.- Cancelling a delayed room A and immediately starting room B left B live, stopped only A's capture, and invalidated A's invitation after bounded cleanup.- Injecting a live picker-cancellation result preserved the old stream. Replacing synthetic video, adding synthetic audio, and removing it all kept the same connected host/viewer peer objects and did not create another offer; retired capture tracks stopped after each successful change.- Desktop and 390 px responsive layouts were smoke-checked without horizontal overflow.- Production configuration fails closed when HTTPS, TURN, or sufficiently strong secrets are missing.+- Production startup rejects malformed ICE URLs and requires explicit TURN/UDP, TURN/TCP, and TURN/TLS-on-TCP-443 entries. This checks configuration only; external relay reachability remains unverified.+- The application binds to loopback by default and exposes a process-only `GET /healthz` liveness response; containers and trusted LAN deployments must opt in to `LISTEN_HOST=0.0.0.0`.- coturn is not installed on this workstation; its configuration has only been checked against upstream documentation and local application tests.## Next Milestonediff --git a/src/server/app.ts b/src/server/app.tsindex fafd3187..91c2dd80 100644--- a/src/server/app.ts+++ b/src/server/app.ts@@ -130,7 +130,7 @@ export async function createScreenerServer(return {httpServer,roomStore,- listen(port = config.port, host = "0.0.0.0") {+ listen(port = config.port, host = config.listenHost) {return new Promise<number>((resolve, reject) => {const onError = (error: Error) => {httpServer.off("listening", onListening);@@ -172,6 +172,17 @@ async function handleRequest(getFrontendHandler: () => FrontendHandler | undefined,): Promise<void> {const url = new URL(request.url ?? "/", config.publicBaseUrl);+ if (url.pathname === "/healthz") {+ response.setHeader("Cache-Control", "no-store");+ if (request.method !== "GET") {+ response.setHeader("Allow", "GET");+ sendJson(response, 405, { error: "Method not allowed" });+ return;+ }+ sendJson(response, 200, { status: "ok" });+ return;+ }+if (url.pathname === "/api/rooms") {response.setHeader("Cache-Control", "no-store");response.setHeader("X-Content-Type-Options", "nosniff");diff --git a/src/server/config.ts b/src/server/config.tsindex ba1e6691..ca4140bd 100644--- a/src/server/config.ts+++ b/src/server/config.ts@@ -8,6 +8,7 @@ const MIN_PRODUCTION_SECRET_BYTES = 32;export interface ServerConfig {nodeEnv: RuntimeEnvironment;port: number;+ listenHost: string;publicBaseUrl: URL;allowedOrigins: ReadonlySet<string>;roomCreationToken?: string;@@ -19,6 +20,12 @@ export interface ServerConfig {turnCredentialTtlSeconds: number;}+interface IceEndpoint {+ scheme: "stun" | "stuns" | "turn" | "turns";+ port?: number;+ transport?: "udp" | "tcp";+}+function parsePositiveInteger(value: string | undefined,fallback: number,@@ -86,6 +93,9 @@ function parseIceUrlList(if (!allowedProtocols.has(protocol)) {throw new Error(`${name} contains an unsupported URL scheme`);}+ if (!parseIceEndpoint(value)) {+ throw new Error(`${name} contains an invalid ICE URL`);+ }return value;});}@@ -95,6 +105,101 @@ function parseOrigins(value: string | undefined, fallback: string): Set<string>return new Set((origins.length > 0 ? origins : [fallback]).map(toOrigin));}+function parseIceEndpoint(value: string): IceEndpoint | undefined {+ const schemeSeparator = value.indexOf(":");+ if (schemeSeparator <= 0) {+ return undefined;+ }++ const scheme = value.slice(0, schemeSeparator).toLowerCase();+ if (+ scheme !== "stun" &&+ scheme !== "stuns" &&+ scheme !== "turn" &&+ scheme !== "turns"+ ) {+ return undefined;+ }++ const remainder = value.slice(schemeSeparator + 1);+ if (!remainder || remainder.includes("#")) {+ return undefined;+ }++ const querySeparator = remainder.indexOf("?");+ const authorityText =+ querySeparator === -1 ? remainder : remainder.slice(0, querySeparator);+ const query =+ querySeparator === -1 ? undefined : remainder.slice(querySeparator + 1);+ let transport: IceEndpoint["transport"];+ if (scheme === "stun" || scheme === "stuns") {+ if (query !== undefined) {+ return undefined;+ }+ } else if (query !== undefined) {+ if (query === "transport=udp" || query === "transport=tcp") {+ transport = query.slice("transport=".length) as "udp" | "tcp";+ } else {+ return undefined;+ }+ }+ if (+ !authorityText ||+ /[\\/\s]/.test(authorityText) ||+ authorityText.endsWith(":")+ ) {+ return undefined;+ }++ let authority: URL;+ try {+ authority = new URL(`http://${authorityText}`);+ } catch {+ return undefined;+ }+ if (+ !authority.hostname ||+ authority.username ||+ authority.password ||+ authority.pathname !== "/" ||+ authority.search ||+ authority.hash+ ) {+ return undefined;+ }++ const port = authority.port ? Number(authority.port) : undefined;+ if (port === 0) {+ return undefined;+ }++ return {+ scheme,+ port,+ transport,+ };+}++function requireProductionTurnCoverage(turnUrls: readonly string[]): void {+ const endpoints = turnUrls.map((value) => parseIceEndpoint(value)!);+ const hasTurnUdp = endpoints.some(+ ({ scheme, transport }) => scheme === "turn" && transport === "udp",+ );+ const hasTurnTcp = endpoints.some(+ ({ scheme, transport }) => scheme === "turn" && transport === "tcp",+ );+ const hasTurnsTcp443 = endpoints.some(+ ({ scheme, port, transport }) =>+ scheme === "turns" && port === 443 && transport === "tcp",+ );++ if (!hasTurnUdp || !hasTurnTcp || !hasTurnsTcp443) {+ throw new Error(+ "TURN_URLS must include explicit TURN/UDP, TURN/TCP, and TURN/TLS on TCP port 443 endpoints in production",+ );+ }+}+function toOrigin(value: string): string {const url = new URL(value);if (url.protocol !== "http:" && url.protocol !== "https:") {@@ -111,6 +216,7 @@ export function loadConfig(if (port > 65_535) {throw new Error("PORT must be at most 65535");}+ const listenHost = environment.LISTEN_HOST?.trim() || "127.0.0.1";const publicBaseUrl = new URL(environment.PUBLIC_BASE_URL ?? `http://localhost:${port}`,@@ -166,10 +272,14 @@ export function loadConfig() {throw new Error("TURN_SHARED_SECRET must contain at least 32 bytes in production");}+ if (nodeEnv === "production") {+ requireProductionTurnCoverage(turnUrls);+ }return {nodeEnv,port,+ listenHost,publicBaseUrl,allowedOrigins: parseOrigins(environment.ALLOWED_ORIGINS,diff --git a/src/server/index.ts b/src/server/index.tsindex 1d13e3db..eb79f6cd 100644--- a/src/server/index.ts+++ b/src/server/index.ts@@ -15,7 +15,9 @@ const config = loadConfig();const server = await createScreenerServer({ config });const port = await server.listen();-console.log(`Screener is listening on ${config.publicBaseUrl.origin} (port ${port})`);+console.log(+ `Screener is listening on ${config.listenHost}:${port}; public URL ${config.publicBaseUrl.origin}`,+);let shuttingDown = false;async function shutdown(): Promise<void> {diff --git a/tests/server-config.test.ts b/tests/server-config.test.tsindex 062deffa..4f7457b6 100644--- a/tests/server-config.test.ts+++ b/tests/server-config.test.ts@@ -2,15 +2,25 @@ import { describe, expect, it } from "vitest";import { loadConfig } from "../src/server/config.ts";+const completeProductionTurnUrls =+ "turn:turn.test:3478?transport=udp,turn:turn.test:3478?transport=tcp,turns:turn.test:443?transport=tcp";+describe("server configuration", () => {it("allows development without TURN and defaults the origin", () => {const config = loadConfig({ NODE_ENV: "development", PORT: "9123" });+ expect(config.listenHost).toBe("127.0.0.1");expect(config.publicBaseUrl.href).toBe("http://localhost:9123/");expect(config.allowedOrigins).toEqual(new Set(["http://localhost:9123"]));expect(config.turnUrls).toEqual([]);});+ it("allows an explicit listen host", () => {+ const config = loadConfig({ LISTEN_HOST: " 0.0.0.0 " });++ expect(config.listenHost).toBe("0.0.0.0");+ });+it("requires room creation authorization and TURN in production", () => {expect(() =>loadConfig({ NODE_ENV: "production", PUBLIC_BASE_URL: "https://share.test" }),@@ -41,14 +51,107 @@ describe("server configuration", () => {PUBLIC_BASE_URL: "https://share.test",ROOM_CREATION_TOKEN: "c".repeat(32),STUN_URLS: "stun:turn.test:3478,stuns:turn.test:5349",- TURN_URLS: "turn:turn.test:3478,turns:turn.test:5349",+ TURN_URLS: completeProductionTurnUrls,TURN_SHARED_SECRET: "t".repeat(32),});- expect(config.turnUrls).toHaveLength(2);+ expect(config.turnUrls).toHaveLength(3);expect(config.turnSharedSecret).toBe("t".repeat(32));});+ it("does not require transport coverage outside production", () => {+ const config = loadConfig({+ TURN_URLS: "turn:turn.test:3478",+ TURN_SHARED_SECRET: "development-secret",+ });++ expect(config.turnUrls).toEqual(["turn:turn.test:3478"]);+ });++ it("accepts a valid uppercase scheme, IPv6 host, and secure UDP URL", () => {+ const config = loadConfig({+ TURN_URLS: "TURNS:[2001:db8::1]:443?transport=udp",+ TURN_SHARED_SECRET: "development-secret",+ });++ expect(config.turnUrls).toEqual([+ "TURNS:[2001:db8::1]:443?transport=udp",+ ]);+ });++ it("rejects every malformed ICE URL, including extras after valid TURN URLs", () => {+ const invalidTurnUrls = [+ "turn:turn.test/path?transport=udp",+ "turn:turn.test:3478/?transport=udp",+ "turn:turn.test:3478?transport=udp#",+ "turn:turn.test:3478?transport=udp&",+ "turn:turn.test:3478?",+ "turn:turn.test:?transport=udp",+ "turn:turn.test:0?transport=udp",+ "turn:[email protected]:3478?transport=udp",+ "turn:turn.test:3478?transport=UDP",+ "turn:turn.test:3478?transport=%75dp",+ ];+ for (const invalidUrl of invalidTurnUrls) {+ expect(() =>+ loadConfig({+ NODE_ENV: "production",+ PUBLIC_BASE_URL: "https://share.test",+ ROOM_CREATION_TOKEN: "c".repeat(32),+ STUN_URLS: "stun:turn.test:3478",+ TURN_URLS: `${completeProductionTurnUrls},${invalidUrl}`,+ TURN_SHARED_SECRET: "t".repeat(32),+ }),+ ).toThrow("TURN_URLS contains an invalid ICE URL");+ }++ for (const invalidUrl of [+ "stun:turn.test/path",+ "stun:turn.test?transport=udp",+ "stun:turn.test#",+ ]) {+ expect(() => loadConfig({ STUN_URLS: invalidUrl })).toThrow(+ "STUN_URLS contains an invalid ICE URL",+ );+ }+ });++ it.each([+ {+ missing: "TURN/UDP",+ urls:+ "turn:turn.test:3478,turn:turn.test:3478?transport=tcp,turns:turn.test:443?transport=tcp",+ },+ {+ missing: "TURN/TCP",+ urls:+ "turn:turn.test:3478?transport=udp,turns:turn.test:443?transport=tcp",+ },+ {+ missing: "TURN/TLS on TCP port 443",+ urls:+ "turn:turn.test:3478?transport=udp,turn:turn.test:3478?transport=tcp,turns:turn.test:5349?transport=tcp",+ },+ {+ missing: "explicit TURN/TLS transport",+ urls:+ "turn:turn.test:3478?transport=udp,turn:turn.test:3478?transport=tcp,turns:turn.test:443",+ },+ ])("rejects production TURN URLs missing $missing", ({ urls }) => {+ expect(() =>+ loadConfig({+ NODE_ENV: "production",+ PUBLIC_BASE_URL: "https://share.test",+ ROOM_CREATION_TOKEN: "c".repeat(32),+ STUN_URLS: "stun:turn.test:3478",+ TURN_URLS: urls,+ TURN_SHARED_SECRET: "t".repeat(32),+ }),+ ).toThrow(+ "TURN_URLS must include explicit TURN/UDP, TURN/TCP, and TURN/TLS on TCP port 443 endpoints in production",+ );+ });+it("rejects weak production secrets", () => {expect(() =>loadConfig({diff --git a/tests/server-http.test.ts b/tests/server-http.test.tsindex a337caa9..fb11d791 100644--- a/tests/server-http.test.ts+++ b/tests/server-http.test.ts@@ -19,6 +19,7 @@ function testConfig(overrides: Partial<ServerConfig> = {}): ServerConfig {return {nodeEnv: "test",port: 0,+ listenHost: "127.0.0.1",publicBaseUrl: new URL("https://share.example.test"),allowedOrigins: new Set([allowedOrigin]),roomCreationToken: "create-secret",@@ -111,3 +112,41 @@ describe("room HTTP API", () => {expect(await full.json()).toEqual({ error: "Room capacity reached" });});});++describe("server HTTP listener", () => {+ it("uses the configured listen host by default", async () => {+ runningServer = await createScreenerServer({+ config: testConfig(),+ serveFrontend: false,+ });+ await runningServer.listen(0);+ const address = runningServer.httpServer.address();+ if (!address || typeof address === "string") {+ throw new Error("Expected a TCP server address");+ }++ expect(address.address).toBe("127.0.0.1");+ });+});++describe("health HTTP endpoint", () => {+ it("reports process liveness without caching or origin checks", async () => {+ const baseUrl = await start();+ const response = await fetch(`${baseUrl}/healthz`, {+ headers: { Origin: "https://foreign.example.test" },+ });++ expect(response.status).toBe(200);+ expect(response.headers.get("cache-control")).toBe("no-store");+ expect(await response.json()).toEqual({ status: "ok" });+ });++ it("only accepts GET requests", async () => {+ const baseUrl = await start();+ const response = await fetch(`${baseUrl}/healthz`, { method: "POST" });++ expect(response.status).toBe(405);+ expect(response.headers.get("allow")).toBe("GET");+ expect(await response.json()).toEqual({ error: "Method not allowed" });+ });+});diff --git a/tests/server-signal.test.ts b/tests/server-signal.test.tsindex c5fb9ebf..48c8af5f 100644--- a/tests/server-signal.test.ts+++ b/tests/server-signal.test.ts@@ -101,6 +101,7 @@ function testConfig(): ServerConfig {return {nodeEnv: "test",port: 0,+ listenHost: "127.0.0.1",publicBaseUrl: new URL("https://share.example.test"),allowedOrigins: new Set([allowedOrigin]),roomTtlMs: 14_400_000,