rechrome 1.45.0 → 1.47.0

package/serve.js

@@ -1,5 +1,5 @@
 import { receiveUpload, readRequestJson } from "./scoped-upload.js";
-import { readListeners, listenerAddress, authorizeProfileRequest, canReadProfileFile, profileOutputPrefix, normalizePrefix, resolveAllowedProfile, type Listener } from "./listeners.js";
+import { readListeners, listenerAddress, authorizeProfileRequest, canReadProfileFile, profileOutputPrefix, normalizePrefix, resolveAllowedProfile, shareRtcListeners, rtcListeners, type Listener } from "./listeners.js";
 import { WEBRTC, authorizeCredential, credentialForBearer, readShares, redeemInvite, shareProblem, updateShares, webrtcCredentials, type Credential, type ShareConfig } from "./shares.js";
 import { bearerOf, safeEqual } from "./secret.js";
 import { WebrtcHost } from "./webrtc.js";
@@ -1350,11 +1350,18 @@ export async function serve() {
 
   // WebRTC: the same handler, reached over an encrypted DataChannel. Each request carries the
   // bearer of the credential whose room it came in on, so share checks apply unchanged.
-  const webrtcListener: Listener = { name: WEBRTC, host: "webrtc", port: 0, key: randomBytes(24).toString("base64url"), profiles: [] };
-  const webrtc = new WebrtcHost(async (req, token) => {
+  // Each WebRTC listener is its own transport: a share is checked against the one its room is on.
+  const webrtcKey = randomBytes(24).toString("base64url");
+  const webrtcListeners = new Map<string, Listener>();
+  const webrtcListener = (name = WEBRTC): Listener => {
+    let l = webrtcListeners.get(name);
+    if (!l) webrtcListeners.set(name, l = { name, host: "webrtc", port: 0, key: webrtcKey, profiles: [] });
+    return l;
+  };
+  const webrtc = new WebrtcHost(async (req, token, listenerName) => {
     const headers = new Headers(req.headers);
     headers.set("Authorization", `Bearer ${bearerOf(token)}`);
-    return handle(new Request(req, { headers }), webrtcListener, () => "webrtc");
+    return handle(new Request(req, { headers }), webrtcListener(listenerName), () => "webrtc");
   }, log);
 
   const startServer = (initial: Listener, reusePort = false) => Bun.serve({
@@ -1446,10 +1453,11 @@ export async function serve() {
   let appliedShares = "";
   const reloadShares = async () => {
     const next = await readShares();
+    const listenerConfig = await readListeners().catch(() => null);
     // Expiry is time-based: fold "what is live right now" into the fingerprint so an expiring
     // share or invite closes its rooms and sessions without anyone touching the file.
     const now = Date.now();
-    const fingerprint = JSON.stringify(next) + JSON.stringify(next.shares.map(s => [!!shareProblem(s, now), !!(s.inviteExpiresAt && now >= s.inviteExpiresAt)]));
+    const fingerprint = JSON.stringify(next) + JSON.stringify(listenerConfig?.rtcListeners ?? []) + JSON.stringify(next.shares.map(s => [!!shareProblem(s, now), !!(s.inviteExpiresAt && now >= s.inviteExpiresAt)]));
     if (fingerprint === appliedShares) return;
     const allowed = new Set(next.shares.filter(s => !shareProblem(s, now)).flatMap(s => s.devices.map(d => `share:${s.id}:${d.id}`)));
     const dropped = [...sessionOwners.entries()].filter(([, o]) => o.owner.startsWith("share:") && !allowed.has(o.owner));
@@ -1464,9 +1472,14 @@ export async function serve() {
         log(`closed session ${session} of ${o.label}: its share was revoked or its device removed`);
       }
     }
-    const creds = webrtcCredentials(next);
-    webrtc.sync(creds.map(c => ({ token: c.token, signal: c.share.signal!, label: c.kind === "device" ? `${c.share.label}/${c.device.name}` : `${c.share.label} (invite)` })));
-    if (creds.length || webrtc.size) log(`webrtc: listening for ${creds.length} share credential(s)`);
+    // One room per share credential on each WebRTC listener the share names.
+    const creds = webrtcCredentials(next, now, rtcListeners(listenerConfig).map(l => l.name));
+    const rooms = creds.flatMap(c => shareRtcListeners(c.share, listenerConfig).map(l => ({
+      token: c.token, signal: l.signal, listener: l.name, ...(l.ice?.length ? { ice: l.ice } : {}),
+      label: `${c.kind === "device" ? `${c.share.label}/${c.device.name}` : `${c.share.label} (invite)`} via ${l.name}`,
+    })));
+    webrtc.sync(rooms);
+    if (rooms.length || webrtc.size) log(`webrtc: listening for ${creds.length} share credential(s) in ${rooms.length} room(s)`);
   };
   await reloadShares().catch(error => log(`shares.json rejected: ${error}`));
   await reload(true);

package/serve.ts

@@ -1,5 +1,5 @@
 import { receiveUpload, readRequestJson } from "./scoped-upload.ts";
-import { readListeners, listenerAddress, authorizeProfileRequest, canReadProfileFile, profileOutputPrefix, normalizePrefix, resolveAllowedProfile, type Listener } from "./listeners.ts";
+import { readListeners, listenerAddress, authorizeProfileRequest, canReadProfileFile, profileOutputPrefix, normalizePrefix, resolveAllowedProfile, shareRtcListeners, rtcListeners, type Listener } from "./listeners.ts";
 import { WEBRTC, authorizeCredential, credentialForBearer, readShares, redeemInvite, shareProblem, updateShares, webrtcCredentials, type Credential, type ShareConfig } from "./shares.ts";
 import { bearerOf, safeEqual } from "./secret.ts";
 import { WebrtcHost } from "./webrtc.ts";
@@ -1350,11 +1350,18 @@ export async function serve() {
 
   // WebRTC: the same handler, reached over an encrypted DataChannel. Each request carries the
   // bearer of the credential whose room it came in on, so share checks apply unchanged.
-  const webrtcListener: Listener = { name: WEBRTC, host: "webrtc", port: 0, key: randomBytes(24).toString("base64url"), profiles: [] };
-  const webrtc = new WebrtcHost(async (req, token) => {
+  // Each WebRTC listener is its own transport: a share is checked against the one its room is on.
+  const webrtcKey = randomBytes(24).toString("base64url");
+  const webrtcListeners = new Map<string, Listener>();
+  const webrtcListener = (name = WEBRTC): Listener => {
+    let l = webrtcListeners.get(name);
+    if (!l) webrtcListeners.set(name, l = { name, host: "webrtc", port: 0, key: webrtcKey, profiles: [] });
+    return l;
+  };
+  const webrtc = new WebrtcHost(async (req, token, listenerName) => {
     const headers = new Headers(req.headers);
     headers.set("Authorization", `Bearer ${bearerOf(token)}`);
-    return handle(new Request(req, { headers }), webrtcListener, () => "webrtc");
+    return handle(new Request(req, { headers }), webrtcListener(listenerName), () => "webrtc");
   }, log);
 
   const startServer = (initial: Listener, reusePort = false) => Bun.serve({
@@ -1446,10 +1453,11 @@ export async function serve() {
   let appliedShares = "";
   const reloadShares = async () => {
     const next = await readShares();
+    const listenerConfig = await readListeners().catch(() => null);
     // Expiry is time-based: fold "what is live right now" into the fingerprint so an expiring
     // share or invite closes its rooms and sessions without anyone touching the file.
     const now = Date.now();
-    const fingerprint = JSON.stringify(next) + JSON.stringify(next.shares.map(s => [!!shareProblem(s, now), !!(s.inviteExpiresAt && now >= s.inviteExpiresAt)]));
+    const fingerprint = JSON.stringify(next) + JSON.stringify(listenerConfig?.rtcListeners ?? []) + JSON.stringify(next.shares.map(s => [!!shareProblem(s, now), !!(s.inviteExpiresAt && now >= s.inviteExpiresAt)]));
     if (fingerprint === appliedShares) return;
     const allowed = new Set(next.shares.filter(s => !shareProblem(s, now)).flatMap(s => s.devices.map(d => `share:${s.id}:${d.id}`)));
     const dropped = [...sessionOwners.entries()].filter(([, o]) => o.owner.startsWith("share:") && !allowed.has(o.owner));
@@ -1464,9 +1472,14 @@ export async function serve() {
         log(`closed session ${session} of ${o.label}: its share was revoked or its device removed`);
       }
     }
-    const creds = webrtcCredentials(next);
-    webrtc.sync(creds.map(c => ({ token: c.token, signal: c.share.signal!, label: c.kind === "device" ? `${c.share.label}/${c.device.name}` : `${c.share.label} (invite)` })));
-    if (creds.length || webrtc.size) log(`webrtc: listening for ${creds.length} share credential(s)`);
+    // One room per share credential on each WebRTC listener the share names.
+    const creds = webrtcCredentials(next, now, rtcListeners(listenerConfig).map(l => l.name));
+    const rooms = creds.flatMap(c => shareRtcListeners(c.share, listenerConfig).map(l => ({
+      token: c.token, signal: l.signal, listener: l.name, ...(l.ice?.length ? { ice: l.ice } : {}),
+      label: `${c.kind === "device" ? `${c.share.label}/${c.device.name}` : `${c.share.label} (invite)`} via ${l.name}`,
+    })));
+    webrtc.sync(rooms);
+    if (rooms.length || webrtc.size) log(`webrtc: listening for ${creds.length} share credential(s) in ${rooms.length} room(s)`);
   };
   await reloadShares().catch(error => log(`shares.json rejected: ${error}`));
   await reload(true);

package/shares.js

@@ -95,6 +95,7 @@ function safeEqual(a, b) {
 // shares.ts
 var WEBRTC = "webrtc";
 var DEFAULT_SIGNAL = "https://rechrome.pages.dev/";
+var DEFAULT_RTC = "webrtc-default";
 var SHARES_FILE = join(homedir(), ".rechrome", "shares.json");
 var LABEL = /^[a-z0-9][a-z0-9_-]{0,39}$/;
 function validateShares(value) {
@@ -314,10 +315,11 @@ function parseDuration(text) {
   const unit = { m: 60000, min: 60000, h: 3600000, d: 86400000, w: 604800000 }[m[2]];
   return Math.round(Number(m[1]) * unit);
 }
-function webrtcCredentials(config, now = Date.now()) {
+function webrtcCredentials(config, now = Date.now(), rtcNames = [DEFAULT_RTC]) {
+  const names = new Set([WEBRTC, DEFAULT_RTC, ...rtcNames]);
   const out = [];
   for (const share of config.shares) {
-    if (!share.via.includes(WEBRTC) || shareProblem(share, now))
+    if (!share.via.some((v) => names.has(v)) || shareProblem(share, now))
       continue;
     if (!(share.inviteExpiresAt && now >= share.inviteExpiresAt))
       out.push({ share, kind: "invite", token: share.invite });
@@ -327,6 +329,7 @@ function webrtcCredentials(config, now = Date.now()) {
   return out;
 }
 export {
+  DEFAULT_RTC,
   DEFAULT_SIGNAL,
   SHARES_FILE,
   WEBRTC,

package/shares.ts

@@ -13,6 +13,8 @@ import { bearerOf, credentialIdOf, newToken, safeEqual } from "./secret.ts";
 
 export const WEBRTC = "webrtc";
 export const DEFAULT_SIGNAL = "https://rechrome.pages.dev/";
+// The built-in WebRTC listener's name (see listeners.ts): the public signal server above.
+export const DEFAULT_RTC = "webrtc-default";
 export const SHARES_FILE = join(homedir(), ".rechrome", "shares.json");
 
 export type Device = { id: string; name: string; token: string; addedAt: number; lastSeen?: number; approved: boolean };
@@ -127,6 +129,8 @@ export function createShare(config: ShareConfig, opts: NewShareOptions): Share {
     inviteTtlMs: opts.inviteTtlMs,
     profiles: [...new Set(opts.profiles)],
     via: [...new Set(opts.via)],
+    // Only the legacy "webrtc" transport keeps its signal server on the share; a WebRTC
+    // listener carries its own.
     signal: opts.via.includes(WEBRTC) ? normalizeSignal(opts.signal ?? DEFAULT_SIGNAL) : undefined,
     createdAt: now,
     expiresAt: opts.expiresAt,
@@ -244,10 +248,12 @@ export function parseDuration(text: string): number | undefined {
 }
 
 /** Every credential a WebRTC host should be reachable on: unused invites and devices. */
-export function webrtcCredentials(config: ShareConfig, now = Date.now()): Credential[] {
+/** Live credentials of shares offered on a WebRTC listener (`rtcNames`; the legacy "webrtc" always counts). */
+export function webrtcCredentials(config: ShareConfig, now = Date.now(), rtcNames: Iterable<string> = [DEFAULT_RTC]): Credential[] {
+  const names = new Set([WEBRTC, DEFAULT_RTC, ...rtcNames]);
   const out: Credential[] = [];
   for (const share of config.shares) {
-    if (!share.via.includes(WEBRTC) || shareProblem(share, now)) continue;
+    if (!share.via.some(v => names.has(v)) || shareProblem(share, now)) continue;
     // A used-up invite keeps its room while the share lives, so whoever tries it again hears
     // "already used" (a sign the link leaked) rather than "host offline".
     if (!(share.inviteExpiresAt && now >= share.inviteExpiresAt)) out.push({ share, kind: "invite", token: share.invite });

package/webrtc.js

@@ -231,8 +231,8 @@ function iceServersFromEnv(env = process.env) {
   return DEFAULT_STUN;
 }
 var turnCache = null;
-async function hostIceServers(log, env = process.env) {
-  const base = iceServersFromEnv(env);
+async function hostIceServers(log, env = process.env, extra = []) {
+  const base = [...iceServersFromEnv(env), ...extra];
   const { CF_TURN_KEY_ID: keyId, CF_TURN_API_TOKEN: apiToken } = env;
   if (!keyId || !apiToken)
     return base;
@@ -421,15 +421,23 @@ class WebrtcHost {
     this.log = log;
   }
   sync(creds) {
-    const wanted = new Map(creds.map((c) => [`${c.signal}\x00${c.token}`, c]));
+    const wanted = new Map;
+    for (const c of creds) {
+      const key = `${c.signal}\x00${c.token}`;
+      if (!wanted.has(key))
+        wanted.set(key, c);
+    }
     for (const [key, room] of this.rooms)
       if (!wanted.has(key)) {
         this.stopRoom(room);
         this.rooms.delete(key);
       }
     for (const [key, cred] of wanted) {
-      if (this.rooms.has(key))
+      const live = this.rooms.get(key);
+      if (live) {
+        live.cred = cred;
         continue;
+      }
       const room = { cred, peers: new Map, backoff: 1000, stopped: false };
       this.rooms.set(key, room);
       this.connect(room);
@@ -515,7 +523,7 @@ class WebrtcHost {
   }
   async startPeer(room, peerId) {
     const { RTCPeerConnection } = await loadRTC(this.log);
-    const ice = await hostIceServers(this.log);
+    const ice = await hostIceServers(this.log, process.env, room.cred.ice ?? []);
     const pc = new RTCPeerConnection({ iceServers: ice });
     let keysReady;
     const keys = new Promise((r) => keysReady = r);
@@ -539,7 +547,7 @@ class WebrtcHost {
         a.abort();
       this.closePeer(room, peerId);
     };
-    channel.onFrame = (frame) => void this.onFrame(channel, room.cred.token, aborts, frame);
+    channel.onFrame = (frame) => void this.onFrame(channel, room.cred.token, aborts, frame, room.cred.listener);
     dc.onopen = async () => {
       await channel.setKeys(room.cred.token, await keys);
       if (await channel.confirm())
@@ -557,7 +565,7 @@ class WebrtcHost {
     await pc.setLocalDescription(offer);
     send({ type: "offer", sdp: pc.localDescription.sdp, ice });
   }
-  async onFrame(channel, token, aborts, f) {
+  async onFrame(channel, token, aborts, f, listener) {
     if (f?.t === "abort") {
       aborts.get(f.id)?.abort();
       aborts.delete(f.id);
@@ -574,7 +582,7 @@ class WebrtcHost {
         body: f.body != null && !["GET", "HEAD"].includes(f.method) ? f.body : undefined,
         signal: ac.signal
       });
-      const res = await this.handler(req, token);
+      const res = await this.handler(req, token, listener);
       await channel.sendFrame({ t: "res", id: f.id, status: res.status, ct: res.headers.get("content-type") ?? "" });
       if (res.body) {
         const reader = res.body.getReader();

package/webrtc.ts

@@ -61,8 +61,9 @@ export function iceServersFromEnv(env = process.env): IceServer[] {
 // Short-lived Cloudflare TURN credentials from the HOST owner's own TURN key (CF_TURN_KEY_ID +
 // CF_TURN_API_TOKEN), handed to each peer in the offer. Without them: STUN only.
 let turnCache: { servers: IceServer[]; exp: number } | null = null;
-export async function hostIceServers(log: Log, env = process.env): Promise<IceServer[]> {
-  const base = iceServersFromEnv(env);
+export async function hostIceServers(log: Log, env = process.env, extra: IceServer[] = []): Promise<IceServer[]> {
+  // A listener's own STUN/TURN servers come after the base ones (RECH_ICE_SERVERS, else public STUN).
+  const base = [...iceServersFromEnv(env), ...extra];
   const keyId = env.CF_TURN_KEY_ID, apiToken = env.CF_TURN_API_TOKEN;
   if (!keyId || !apiToken) return base;
   if (turnCache && turnCache.exp > Date.now()) return [...base, ...turnCache.servers];
@@ -205,8 +206,9 @@ class SignalSocket {
 }
 
 // ---- host ------------------------------------------------------------------------------
-export type HostCredential = { token: string; signal: string; label: string };
-export type HostHandler = (req: Request, token: string) => Promise<Response>;
+// listener: the WebRTC listener this room belongs to (a share's `via` entry); ice: its STUN/TURN.
+export type HostCredential = { token: string; signal: string; label: string; listener?: string; ice?: IceServer[] };
+export type HostHandler = (req: Request, token: string, listener?: string) => Promise<Response>;
 
 /** Keeps one signal room per credential and serves each joining peer through `handler`. */
 export class WebrtcHost {
@@ -215,10 +217,13 @@ export class WebrtcHost {
 
   /** Open rooms for new credentials, close rooms for ones that are gone. */
   sync(creds: HostCredential[]): void {
-    const wanted = new Map(creds.map(c => [`${c.signal}\0${c.token}`, c]));
+    // One room per (signal server, credential): the first listener naming a signal server wins.
+    const wanted = new Map<string, HostCredential>();
+    for (const c of creds) { const key = `${c.signal}\0${c.token}`; if (!wanted.has(key)) wanted.set(key, c); }
     for (const [key, room] of this.rooms) if (!wanted.has(key)) { this.stopRoom(room); this.rooms.delete(key); }
     for (const [key, cred] of wanted) {
-      if (this.rooms.has(key)) continue;
+      const live = this.rooms.get(key);
+      if (live) { live.cred = cred; continue; } // a listener's ICE may have changed: next peer uses it
       const room = { cred, peers: new Map(), backoff: 1000, stopped: false } as any;
       this.rooms.set(key, room);
       void this.connect(room);
@@ -288,7 +293,7 @@ export class WebrtcHost {
 
   private async startPeer(room: any, peerId: string): Promise<void> {
     const { RTCPeerConnection } = await loadRTC(this.log);
-    const ice = await hostIceServers(this.log);
+    const ice = await hostIceServers(this.log, process.env, room.cred.ice ?? []);
     const pc = new RTCPeerConnection({ iceServers: ice });
     let keysReady!: (th: Uint8Array) => void;
     const keys = new Promise<Uint8Array>(r => (keysReady = r));
@@ -302,7 +307,7 @@ export class WebrtcHost {
     peer.channel = channel;
     const aborts = new Map<string, AbortController>();
     channel.onClose = () => { for (const a of aborts.values()) a.abort(); this.closePeer(room, peerId); };
-    channel.onFrame = frame => void this.onFrame(channel, room.cred.token, aborts, frame);
+    channel.onFrame = frame => void this.onFrame(channel, room.cred.token, aborts, frame, room.cred.listener);
     dc.onopen = async () => {
       await channel.setKeys(room.cred.token, await keys);
       if (await channel.confirm()) this.log(`webrtc ${room.cred.label}: peer ${peerId} connected`);
@@ -315,7 +320,7 @@ export class WebrtcHost {
     send({ type: "offer", sdp: pc.localDescription.sdp, ice });
   }
 
-  private async onFrame(channel: SealedChannel, token: string, aborts: Map<string, AbortController>, f: any): Promise<void> {
+  private async onFrame(channel: SealedChannel, token: string, aborts: Map<string, AbortController>, f: any, listener?: string): Promise<void> {
     if (f?.t === "abort") { aborts.get(f.id)?.abort(); aborts.delete(f.id); return; }
     if (f?.t !== "req" || typeof f.id !== "string" || typeof f.path !== "string" || !f.path.startsWith("/")) return;
     const ac = new AbortController();
@@ -327,7 +332,7 @@ export class WebrtcHost {
         body: f.body != null && !["GET", "HEAD"].includes(f.method) ? f.body : undefined,
         signal: ac.signal,
       });
-      const res = await this.handler(req, token);
+      const res = await this.handler(req, token, listener);
       await channel.sendFrame({ t: "res", id: f.id, status: res.status, ct: res.headers.get("content-type") ?? "" });
       if (res.body) {
         const reader = res.body.getReader();