rechrome 1.47.0 → 1.48.1

package/shares.ts

@@ -31,6 +31,8 @@ export type Share = {
   expiresAt?: number;
   maxDevices: number;
   approve: boolean;          // each new device waits for `rech share approve`
+  reusable?: boolean;        // the invite is not used up by one device: many redeem it (up to maxDevices) until it expires or is rotated
+  redeemed?: number;         // how many times the invite was redeemed (devices removed since still count)
   devices: Device[];
   revokedAt?: number;
 };
@@ -112,9 +114,14 @@ export function findShare(config: ShareConfig, name: string): Share {
 
 export type NewShareOptions = {
   label: string; profiles: string[]; via: string[]; signal?: string;
-  expiresAt?: number; inviteTtlMs?: number; maxDevices?: number; approve?: boolean; now?: number;
+  expiresAt?: number; inviteTtlMs?: number; maxDevices?: number; approve?: boolean; reusable?: boolean; now?: number;
 };
 
+/** Device cap of a reusable invite when --devices isn't given: bounds what a leaked link can enroll. */
+export const REUSABLE_MAX_DEVICES = 100;
+/** Invite lifetime of a reusable invite when --ttl isn't given. */
+export const REUSABLE_DEFAULT_TTL = "7d";
+
 export function createShare(config: ShareConfig, opts: NewShareOptions): Share {
   const now = opts.now ?? Date.now();
   if (!LABEL.test(opts.label)) throw new Error(`Share names use a-z, 0-9, "-" and "_" (up to 40), e.g. alice or ci-bot; got "${opts.label}"`);
@@ -134,10 +141,11 @@ export function createShare(config: ShareConfig, opts: NewShareOptions): Share {
     signal: opts.via.includes(WEBRTC) ? normalizeSignal(opts.signal ?? DEFAULT_SIGNAL) : undefined,
     createdAt: now,
     expiresAt: opts.expiresAt,
-    maxDevices: opts.maxDevices ?? 1,
+    maxDevices: opts.maxDevices ?? (opts.reusable ? REUSABLE_MAX_DEVICES : 1),
     approve: !!opts.approve,
     devices: [],
   };
+  if (opts.reusable) { share.reusable = true; share.redeemed = 0; }
   config.shares.push(share);
   return share;
 }
@@ -190,11 +198,34 @@ export function shareProblem(share: Share, now = Date.now()): string | null {
 
 /** Why an unused invite can't be redeemed right now, or null. */
 export function inviteProblem(share: Share, now = Date.now()): string | null {
-  if (share.inviteExpiresAt && now >= share.inviteExpiresAt) return `This invite expired unused. Ask the host for a fresh one: rech share rotate ${share.label}`;
+  if (share.inviteExpiresAt && now >= share.inviteExpiresAt) return `This invite expired${share.reusable ? "" : " unused"}. Ask the host for a fresh one: rech share rotate ${share.label}`;
+  if (share.reusable) {
+    if (share.devices.length >= share.maxDevices) return `This reusable invite reached its limit of ${share.maxDevices} devices. Ask the host to remove unused devices (rech share devices ${share.label} --rm <id>) or to rotate it.`;
+    return null;
+  }
   if (share.devices.length >= share.maxDevices) return `This invite was already used${share.maxDevices > 1 ? ` by ${share.maxDevices} devices` : ""}. Ask the host for a fresh one (rech share rotate ${share.label}); if you didn't use it, tell them, since someone else did.`;
   return null;
 }
 
+/** What an invite's holder is told about it before redeeming (the /ping of an invite). */
+export function inviteState(share: Share, now = Date.now()): { state: "open" | "used" | "expired"; maxDevices: number; used: number; expiresAt?: number } {
+  const used = share.devices.length;
+  const state = used >= share.maxDevices ? "used" : share.inviteExpiresAt && now >= share.inviteExpiresAt ? "expired" : "open";
+  return { state, maxDevices: share.maxDevices, used, ...(share.inviteExpiresAt ? { expiresAt: share.inviteExpiresAt } : {}) };
+}
+
+/** A share's live browser sessions: names and device names only, none of another share's. */
+export function shareSessions(share: Share, owners: Iterable<[string, { owner: string; name: string }]>, live: ReadonlySet<string>): { name: string; device: string }[] {
+  const prefix = `share:${share.id}:`;
+  const out: { name: string; device: string }[] = [];
+  for (const [session, o] of owners) {
+    if (!o.owner.startsWith(prefix) || !live.has(session)) continue;
+    const device = share.devices.find(d => d.id === o.owner.slice(prefix.length));
+    if (device) out.push({ name: o.name, device: device.name });
+  }
+  return out;
+}
+
 /**
  * Whether a credential may make this request. Invites may only ping and redeem; a device may
  * do everything its share allows once approved. `via` is the transport the request came in on.
@@ -228,6 +259,7 @@ export function redeemInvite(config: ShareConfig, shareId: string, name: string,
     token, addedAt: now, approved: !share.approve,
   };
   share.devices.push(device);
+  if (share.reusable) share.redeemed = (share.redeemed ?? 0) + 1;
   return device;
 }
 
@@ -254,9 +286,10 @@ export function webrtcCredentials(config: ShareConfig, now = Date.now(), rtcName
   const out: Credential[] = [];
   for (const share of config.shares) {
     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 });
+    // A used-up or expired invite keeps its room while the share lives, so whoever tries it hears
+    // "already used" (a sign the link leaked) or "expired" rather than "host offline". Such a
+    // room only ever answers with that refusal (see inviteProblem).
+    out.push({ share, kind: "invite", token: share.invite });
     for (const device of share.devices) out.push({ share, kind: "device", token: device.token, device });
   }
   return out;

package/token.js

@@ -0,0 +1,88 @@
+// @bun
+// token.ts
+var TOKEN_PREFIX = "rech1_";
+var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var B58 = "[1-9A-HJ-NP-Za-km-z]";
+var BODY_LEN = 22;
+var SUM_LEN = 6;
+var SECRET_BYTES = 16;
+var TOKEN_PATTERN = new RegExp(`\\brech1_${B58}{${BODY_LEN + SUM_LEN}}\\b`, "g");
+var EXACT = new RegExp(`^rech1_(${B58}{${BODY_LEN}})(${B58}{${SUM_LEN}})$`);
+function base58(bytes, width) {
+  let n = 0n;
+  for (const b of bytes)
+    n = n << 8n | BigInt(b);
+  let s = "";
+  while (n > 0n) {
+    s = ALPHABET[Number(n % 58n)] + s;
+    n /= 58n;
+  }
+  if (s.length > width)
+    throw new Error("base58 value wider than its field");
+  return s.padStart(width, "1");
+}
+function unbase58(text, length) {
+  let n = 0n;
+  for (const c of text) {
+    const i = ALPHABET.indexOf(c);
+    if (i < 0)
+      return null;
+    n = n * 58n + BigInt(i);
+  }
+  const out = new Uint8Array(length);
+  for (let i = length - 1;i >= 0; i--) {
+    out[i] = Number(n & 0xffn);
+    n >>= 8n;
+  }
+  return n === 0n ? out : null;
+}
+var CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let i = 0;i < 256; i++) {
+    let c = i;
+    for (let k = 0;k < 8; k++)
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    t[i] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(bytes) {
+  let c = 4294967295;
+  for (const b of bytes)
+    c = CRC_TABLE[(c ^ b) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+var u32 = (n) => new Uint8Array([n >>> 24, n >>> 16 & 255, n >>> 8 & 255, n & 255]);
+function formatToken(secret) {
+  if (secret.length !== SECRET_BYTES)
+    throw new Error(`a share secret is ${SECRET_BYTES} bytes`);
+  return `${TOKEN_PREFIX}${base58(secret, BODY_LEN)}${base58(u32(crc32(secret)), SUM_LEN)}`;
+}
+function parseToken(token) {
+  const m = EXACT.exec(token.trim());
+  if (!m)
+    return { ok: false, reason: "format" };
+  const secret = unbase58(m[1], SECRET_BYTES), sum = unbase58(m[2], 4);
+  if (!secret || !sum)
+    return { ok: false, reason: "format" };
+  const expected = u32(crc32(secret));
+  return sum.every((b, i) => b === expected[i]) ? { ok: true, secret } : { ok: false, reason: "checksum" };
+}
+function isToken(text) {
+  return parseToken(text).ok;
+}
+function looksLikeToken(text) {
+  return EXACT.test(text.trim());
+}
+export {
+  SECRET_BYTES,
+  TOKEN_PATTERN,
+  TOKEN_PREFIX,
+  base58,
+  crc32,
+  formatToken,
+  isToken,
+  looksLikeToken,
+  parseToken,
+  unbase58
+};

package/token.ts

@@ -0,0 +1,74 @@
+// The rech1_ token format, with no Node imports: the invite page (public/invite.js) runs this too.
+// Derivations and everything else about shares are in secret.ts, which re-exports all of this.
+
+export const TOKEN_PREFIX = "rech1_";
+const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const B58 = "[1-9A-HJ-NP-Za-km-z]";
+const BODY_LEN = 22, SUM_LEN = 6;
+export const SECRET_BYTES = 16;
+/** Matches a token anywhere in text (logs, files); for scanners and redaction. */
+export const TOKEN_PATTERN = new RegExp(`\\brech1_${B58}{${BODY_LEN + SUM_LEN}}\\b`, "g");
+const EXACT = new RegExp(`^rech1_(${B58}{${BODY_LEN}})(${B58}{${SUM_LEN}})$`);
+
+export function base58(bytes: Uint8Array, width: number): string {
+  let n = 0n;
+  for (const b of bytes) n = (n << 8n) | BigInt(b);
+  let s = "";
+  while (n > 0n) { s = ALPHABET[Number(n % 58n)] + s; n /= 58n; }
+  if (s.length > width) throw new Error("base58 value wider than its field");
+  return s.padStart(width, "1");
+}
+
+export function unbase58(text: string, length: number): Uint8Array | null {
+  let n = 0n;
+  for (const c of text) {
+    const i = ALPHABET.indexOf(c);
+    if (i < 0) return null;
+    n = n * 58n + BigInt(i);
+  }
+  const out = new Uint8Array(length);
+  for (let i = length - 1; i >= 0; i--) { out[i] = Number(n & 0xffn); n >>= 8n; }
+  return n === 0n ? out : null; // leftover bits: not a fixed-width encoding of `length` bytes
+}
+
+const CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    t[i] = c >>> 0;
+  }
+  return t;
+})();
+export function crc32(bytes: Uint8Array): number {
+  let c = 0xffffffff;
+  for (const b of bytes) c = CRC_TABLE[(c ^ b) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+const u32 = (n: number) => new Uint8Array([n >>> 24, (n >>> 16) & 255, (n >>> 8) & 255, n & 255]);
+
+export function formatToken(secret: Uint8Array): string {
+  if (secret.length !== SECRET_BYTES) throw new Error(`a share secret is ${SECRET_BYTES} bytes`);
+  return `${TOKEN_PREFIX}${base58(secret, BODY_LEN)}${base58(u32(crc32(secret)), SUM_LEN)}`;
+}
+
+export type ParsedToken = { ok: true; secret: Uint8Array } | { ok: false; reason: "format" | "checksum" };
+
+/** Parse a token, telling a non-token apart from a damaged one (a truncated paste, a typo). */
+export function parseToken(token: string): ParsedToken {
+  const m = EXACT.exec(token.trim());
+  if (!m) return { ok: false, reason: "format" };
+  const secret = unbase58(m[1], SECRET_BYTES), sum = unbase58(m[2], 4);
+  if (!secret || !sum) return { ok: false, reason: "format" };
+  const expected = u32(crc32(secret));
+  return sum.every((b, i) => b === expected[i]) ? { ok: true, secret } : { ok: false, reason: "checksum" };
+}
+
+export function isToken(text: string): boolean {
+  return parseToken(text).ok;
+}
+
+/** Looks like a token (prefix and shape) whether or not its checksum holds. */
+export function looksLikeToken(text: string): boolean {
+  return EXACT.test(text.trim());
+}

package/webrtc.js

@@ -7,6 +7,8 @@ import { randomBytes as randomBytes2 } from "crypto";
 
 // secret.ts
 import { hkdfSync, randomBytes, timingSafeEqual } from "crypto";
+
+// token.ts
 var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 var B58 = "[1-9A-HJ-NP-Za-km-z]";
 var BODY_LEN = 22;
@@ -69,15 +71,16 @@ function parseToken(token) {
   const expected = u32(crc32(secret));
   return sum.every((b, i) => b === expected[i]) ? { ok: true, secret } : { ok: false, reason: "checksum" };
 }
-function secretOf(token) {
-  const parsed = parseToken(token);
+// secret.ts
+function secretOf(token2) {
+  const parsed = parseToken(token2);
   if (!parsed.ok)
     throw new Error(parsed.reason === "checksum" ? "This rech1_ link is damaged (checksum mismatch): it was copied incompletely or mistyped." : "Not a rech1_ link.");
   return parsed.secret;
 }
-var derive = (token, label, bytes) => new Uint8Array(hkdfSync("sha256", secretOf(token), new Uint8Array(0), `rech/${label}`, bytes));
-var roomOf = (token) => base58(derive(token, "room", 12), 17);
-var roomAuthOf = (token) => Buffer.from(derive(token, "auth", 32)).toString("hex");
+var derive = (token2, label, bytes) => new Uint8Array(hkdfSync("sha256", secretOf(token2), new Uint8Array(0), `rech/${label}`, bytes));
+var roomOf = (token2) => base58(derive(token2, "room", 12), 17);
+var roomAuthOf = (token2) => Buffer.from(derive(token2, "auth", 32)).toString("hex");
 
 // e2e.ts
 var PROTO = "rech-e2e-1";
@@ -174,88 +177,13 @@ async function open(key, frame, th, state) {
 var pack = (obj) => enc.encode(JSON.stringify(obj));
 var unpack = (bytes) => JSON.parse(dec.decode(bytes));
 function randomHex(n) {
-  return Buffer.from(globalThis.crypto.getRandomValues(new Uint8Array(n))).toString("hex");
+  return Array.from(globalThis.crypto.getRandomValues(new Uint8Array(n)), (b) => b.toString(16).padStart(2, "0")).join("");
 }
 
-// webrtc.ts
+// rtc-channel.ts
 var SIGNAL_PROTO = "rech-signal-1";
 var PING = '{"type":"ping"}';
 var KEEPALIVE_MS = 25000;
-var CONNECT_TIMEOUT_MS = 25000;
-var MAX_PEERS_PER_ROOM = 8;
-var DEFAULT_STUN = [{ urls: "stun:stun.cloudflare.com:3478" }, { urls: "stun:stun.l.google.com:19302" }];
-var WEBRTC_RUNTIME_DIR = join(homedir(), ".rechrome", "webrtc");
-var rtcModule;
-function loadRTC(log = (m) => console.error(m)) {
-  return rtcModule ??= (async () => {
-    try {
-      return await import("node-datachannel/polyfill");
-    } catch {}
-    const entry = () => {
-      try {
-        return Bun.resolveSync("node-datachannel/polyfill", WEBRTC_RUNTIME_DIR);
-      } catch {
-        return null;
-      }
-    };
-    let path = entry();
-    if (path)
-      try {
-        return await import(path);
-      } catch {
-        path = null;
-      }
-    log(`[rech] one-time setup: installing WebRTC support (node-datachannel) into ${WEBRTC_RUNTIME_DIR}`);
-    mkdirSync(WEBRTC_RUNTIME_DIR, { recursive: true });
-    writeFileSync(join(WEBRTC_RUNTIME_DIR, "package.json"), JSON.stringify({
-      private: true,
-      dependencies: { "node-datachannel": "^0.32.3" },
-      trustedDependencies: ["node-datachannel"]
-    }, null, 2));
-    const proc = Bun.spawn([process.execPath, "install"], { cwd: WEBRTC_RUNTIME_DIR, stdout: "ignore", stderr: "pipe", env: { ...process.env, BUN_BE_BUN: "1" } });
-    const [status, stderr] = await Promise.all([proc.exited, new Response(proc.stderr).text()]);
-    path = entry();
-    if (status !== 0 || !path)
-      throw new Error(`Could not install WebRTC support (node-datachannel): ${stderr.trim().slice(-400) || `bun install exited ${status}`}`);
-    return import(path);
-  })();
-}
-function iceServersFromEnv(env = process.env) {
-  if (env.RECH_ICE_SERVERS) {
-    try {
-      return JSON.parse(env.RECH_ICE_SERVERS);
-    } catch {
-      throw new Error("RECH_ICE_SERVERS must be a JSON array of {urls, username?, credential?}");
-    }
-  }
-  return DEFAULT_STUN;
-}
-var turnCache = null;
-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;
-  if (turnCache && turnCache.exp > Date.now())
-    return [...base, ...turnCache.servers];
-  try {
-    const r = await fetch(`https://rtc.live.cloudflare.com/v1/turn/keys/${keyId}/credentials/generate-ice-servers`, {
-      method: "POST",
-      headers: { Authorization: `Bearer ${apiToken}`, "Content-Type": "application/json" },
-      body: JSON.stringify({ ttl: 3600 }),
-      signal: AbortSignal.timeout(5000)
-    });
-    if (!r.ok)
-      throw new Error(`HTTP ${r.status}`);
-    const body = await r.json();
-    const servers = [body.iceServers].flat();
-    turnCache = { servers, exp: Date.now() + 3000000 };
-    return [...base, ...servers];
-  } catch (error) {
-    log(`Cloudflare TURN credentials unavailable, using STUN only: ${error}`);
-    return base;
-  }
-}
 function signalSocketUrl(signal, room) {
   const u = new URL(signal);
   u.protocol = u.protocol === "https:" ? "wss:" : "ws:";
@@ -295,6 +223,8 @@ class SealedChannel {
     this.keysSet();
   }
   confirm() {
+    if (this.closed)
+      return Promise.resolve(false);
     const done = new Promise((resolve) => {
       this.confirmWaiters.push(resolve);
       setTimeout(() => resolve(false), CONFIRM_TIMEOUT_MS);
@@ -307,7 +237,7 @@ class SealedChannel {
       if (this.closed || !this.keys || this.dc.readyState !== "open")
         return;
       const frame = await seal(this.keys.mine, this.send, flags, this.keys.th, pack(obj));
-      while (this.dc.bufferedAmount > 4194304 && this.dc.readyState === "open")
+      while (this.dc.bufferedAmount > 4 * 1024 * 1024 && this.dc.readyState === "open")
         await new Promise((r) => setTimeout(r, 10));
       try {
         this.dc.send(new Uint8Array(frame));
@@ -412,6 +342,83 @@ class SignalSocket {
   }
 }
 
+// webrtc.ts
+var CONNECT_TIMEOUT_MS = 25000;
+var MAX_PEERS_PER_ROOM = 8;
+var DEFAULT_STUN = [{ urls: "stun:stun.cloudflare.com:3478" }, { urls: "stun:stun.l.google.com:19302" }];
+var WEBRTC_RUNTIME_DIR = join(homedir(), ".rechrome", "webrtc");
+var rtcModule;
+function loadRTC(log = (m) => console.error(m)) {
+  return rtcModule ??= (async () => {
+    try {
+      return await import("node-datachannel/polyfill");
+    } catch {}
+    const entry = () => {
+      try {
+        return Bun.resolveSync("node-datachannel/polyfill", WEBRTC_RUNTIME_DIR);
+      } catch {
+        return null;
+      }
+    };
+    let path = entry();
+    if (path)
+      try {
+        return await import(path);
+      } catch {
+        path = null;
+      }
+    log(`[rech] one-time setup: installing WebRTC support (node-datachannel) into ${WEBRTC_RUNTIME_DIR}`);
+    mkdirSync(WEBRTC_RUNTIME_DIR, { recursive: true });
+    writeFileSync(join(WEBRTC_RUNTIME_DIR, "package.json"), JSON.stringify({
+      private: true,
+      dependencies: { "node-datachannel": "^0.32.3" },
+      trustedDependencies: ["node-datachannel"]
+    }, null, 2));
+    const proc = Bun.spawn([process.execPath, "install"], { cwd: WEBRTC_RUNTIME_DIR, stdout: "ignore", stderr: "pipe", env: { ...process.env, BUN_BE_BUN: "1" } });
+    const [status, stderr] = await Promise.all([proc.exited, new Response(proc.stderr).text()]);
+    path = entry();
+    if (status !== 0 || !path)
+      throw new Error(`Could not install WebRTC support (node-datachannel): ${stderr.trim().slice(-400) || `bun install exited ${status}`}`);
+    return import(path);
+  })();
+}
+function iceServersFromEnv(env = process.env) {
+  if (env.RECH_ICE_SERVERS) {
+    try {
+      return JSON.parse(env.RECH_ICE_SERVERS);
+    } catch {
+      throw new Error("RECH_ICE_SERVERS must be a JSON array of {urls, username?, credential?}");
+    }
+  }
+  return DEFAULT_STUN;
+}
+var turnCache = null;
+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;
+  if (turnCache && turnCache.exp > Date.now())
+    return [...base, ...turnCache.servers];
+  try {
+    const r = await fetch(`https://rtc.live.cloudflare.com/v1/turn/keys/${keyId}/credentials/generate-ice-servers`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiToken}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ ttl: 3600 }),
+      signal: AbortSignal.timeout(5000)
+    });
+    if (!r.ok)
+      throw new Error(`HTTP ${r.status}`);
+    const body = await r.json();
+    const servers = [body.iceServers].flat();
+    turnCache = { servers, exp: Date.now() + 3000000 };
+    return [...base, ...servers];
+  } catch (error) {
+    log(`Cloudflare TURN credentials unavailable, using STUN only: ${error}`);
+    return base;
+  }
+}
+
 class WebrtcHost {
   handler;
   log;
@@ -632,7 +639,7 @@ class WebrtcClient {
       sock = new SignalSocket(signalSocketUrl(this.signal, roomOf(token)), { role: "client", auth: roomAuthOf(token) }, async (m) => {
         try {
           if (m.type === "welcome" && m.hostPresent === false)
-            fail("the host is offline (its rech daemon isn't connected to the signal server)");
+            fail("nobody is answering this link: the host's rech daemon may be down, or the link was revoked. Ask the host to check, or for a fresh link");
           else if (m.type === "host-leave" && !this.connected)
             fail("the host left before the connection finished");
           else if (m.type === "offer" && typeof m.sdp === "string" && !this.pc) {
@@ -681,7 +688,7 @@ class WebrtcClient {
         }
       }, (code, reason) => {
         if (!this.connected)
-          fail(code === 4404 ? "the host is offline (its rech daemon isn't connected to the signal server)" : code === 1008 ? `the signal server refused this link (${reason || "forbidden"})` : `signal server closed the connection (${reason || code})`);
+          fail(code === 4404 ? "nobody is answering this link: the host's rech daemon may be down, or the link was revoked. Ask the host to check, or for a fresh link" : code === 1008 ? `the signal server refused this link (${reason || "forbidden"})` : `signal server closed the connection (${reason || code})`);
       });
       sock.open().catch((e) => fail(e.message));
     });

package/webrtc.ts

@@ -14,11 +14,11 @@ import { join } from "path";
 import { homedir } from "os";
 import { randomBytes } from "crypto";
 import { roomAuthOf, roomOf } from "./secret.ts";
-import { CONFIRM_TIMEOUT_MS, FLAG_CONFIRM, MAX_CHUNK, deriveDirKeys, newRecvState, newSendState, open, pack, randomHex, seal, transcriptHash, unpack, type RecvState, type SendState } from "./e2e.ts";
+import { MAX_CHUNK, randomHex, transcriptHash } from "./e2e.ts";
+import { SealedChannel, SignalSocket, signalSocketUrl } from "./rtc-channel.ts";
+
+export { SIGNAL_PROTO, signalSocketUrl } from "./rtc-channel.ts";
 
-export const SIGNAL_PROTO = "rech-signal-1";
-const PING = '{"type":"ping"}';
-const KEEPALIVE_MS = 25_000;
 const CONNECT_TIMEOUT_MS = 25_000;
 const MAX_PEERS_PER_ROOM = 8;
 const DEFAULT_STUN = [{ urls: "stun:stun.cloudflare.com:3478" }, { urls: "stun:stun.l.google.com:19302" }];
@@ -83,128 +83,6 @@ export async function hostIceServers(log: Log, env = process.env, extra: IceServ
   }
 }
 
-export function signalSocketUrl(signal: string, room: string): string {
-  const u = new URL(signal);
-  u.protocol = u.protocol === "https:" ? "wss:" : "ws:";
-  u.pathname = `${u.pathname.replace(/\/+$/, "")}/${room}`;
-  u.search = ""; u.hash = "";
-  return u.toString();
-}
-
-// ---- sealed channel (shared by both ends) -------------------------------------------------
-type Role = "host" | "client";
-
-/** A DataChannel with the e2e seal/open and confirmation handshake on top. */
-class SealedChannel {
-  private send = newSendState() as SendState;
-  private recv = newRecvState() as RecvState;
-  private sendChain = Promise.resolve();
-  private recvChain = Promise.resolve();
-  private keys?: { mine: CryptoKey; theirs: CryptoKey; th: Uint8Array };
-  // Frames can arrive the moment the channel opens, before this side has derived its keys
-  // (an async HKDF): hold them until then rather than dropping the connection.
-  private keysSet!: () => void;
-  private keysReady = new Promise<void>(r => (this.keysSet = r));
-  confirmed = false;
-  private confirmWaiters: Array<(ok: boolean) => void> = [];
-  onFrame: (frame: any) => void = () => {};
-  onClose: () => void = () => {};
-  private closed = false;
-
-  constructor(private dc: any, private role: Role) {
-    dc.binaryType = "arraybuffer";
-    dc.onmessage = (e: { data: ArrayBuffer | Uint8Array | string }) => {
-      this.recvChain = this.recvChain.then(() => this.receive(e.data)).catch(() => this.close());
-    };
-    dc.onclose = () => this.close();
-  }
-
-  async setKeys(token: string, th: Uint8Array): Promise<void> {
-    const { h2c, c2h } = await deriveDirKeys(token, th);
-    this.keys = this.role === "host" ? { mine: h2c, theirs: c2h, th } : { mine: c2h, theirs: h2c, th };
-    this.keysSet();
-  }
-
-  /** Send our confirm frame (counter 0) and wait for the peer's; false on timeout or failure. */
-  confirm(): Promise<boolean> {
-    const done = new Promise<boolean>(resolve => {
-      this.confirmWaiters.push(resolve);
-      setTimeout(() => resolve(false), CONFIRM_TIMEOUT_MS);
-    });
-    void this.sendFrame({ t: "confirm", nonce: randomHex(16), proto: "rech-e2e-1" }, FLAG_CONFIRM);
-    return done;
-  }
-
-  sendFrame(obj: unknown, flags = 0): Promise<void> {
-    this.sendChain = this.sendChain.then(async () => {
-      if (this.closed || !this.keys || this.dc.readyState !== "open") return;
-      const frame = await seal(this.keys.mine, this.send, flags, this.keys.th, pack(obj));
-      // A DataChannel queues without bound; wait out a large backlog (screenshots) instead.
-      while (this.dc.bufferedAmount > 4 * 1024 * 1024 && this.dc.readyState === "open") await new Promise(r => setTimeout(r, 10));
-      try { this.dc.send(new Uint8Array(frame)); } catch { this.close(); }
-    }).catch(() => this.close());
-    return this.sendChain;
-  }
-
-  private async receive(data: ArrayBuffer | Uint8Array | string): Promise<void> {
-    if (this.closed) return;
-    if (typeof data === "string") return this.close(); // plaintext is never accepted
-    await Promise.race([this.keysReady, new Promise(r => setTimeout(r, CONFIRM_TIMEOUT_MS))]);
-    if (!this.keys) return this.close();
-    const { plaintext } = await open(this.keys.theirs, data, this.keys.th, this.recv);
-    const frame = unpack(plaintext);
-    if (!this.confirmed) {
-      // The first frame must be the peer's confirm: decrypting it proves the same secret and the
-      // same DTLS transcript (no relay in the middle); the transcript makes it unreplayable.
-      if (frame?.t !== "confirm") return this.close();
-      this.confirmed = true;
-      for (const w of this.confirmWaiters.splice(0)) w(true);
-      return;
-    }
-    if (frame?.t === "confirm") return;
-    this.onFrame(frame);
-  }
-
-  get open(): boolean { return !this.closed && this.dc.readyState === "open"; }
-
-  close(): void {
-    if (this.closed) return;
-    this.closed = true;
-    for (const w of this.confirmWaiters.splice(0)) w(false);
-    try { this.dc.close(); } catch {}
-    this.onClose();
-  }
-}
-
-// Wire frames inside the sealed channel:
-//   client → host : {t:"req", id, method, path, ct?, body?} | {t:"abort", id}
-//   host → client : {t:"res", id, status, ct} | {t:"data", id, b64} | {t:"end", id, error?}
-
-// ---- signal socket ---------------------------------------------------------------------
-class SignalSocket {
-  ws?: WebSocket;
-  private timer?: ReturnType<typeof setInterval>;
-  constructor(private url: string, private hello: { role: Role; auth: string }, private onMessage: (m: any) => void, private onClose: (code: number, reason: string) => void) {}
-  open(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const ws = new WebSocket(this.url, [SIGNAL_PROTO]);
-      this.ws = ws;
-      let opened = false;
-      ws.onopen = () => {
-        opened = true;
-        ws.send(JSON.stringify({ type: "hello", ...this.hello }));
-        this.timer = setInterval(() => { try { ws.send(PING); } catch {} }, KEEPALIVE_MS);
-        resolve();
-      };
-      ws.onmessage = e => { try { const m = JSON.parse(String(e.data)); if (m?.type !== "pong") this.onMessage(m); } catch {} };
-      ws.onclose = e => { clearInterval(this.timer); if (!opened) reject(new Error(`signal server ${new URL(this.url).host}: ${e.reason || `closed (${e.code})`}`)); this.onClose(e.code, e.reason); };
-      ws.onerror = () => {};
-    });
-  }
-  send(obj: unknown): void { try { this.ws?.send(JSON.stringify(obj)); } catch {} }
-  close(): void { clearInterval(this.timer); try { this.ws?.close(); } catch {} }
-}
-
 // ---- host ------------------------------------------------------------------------------
 // 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[] };
@@ -372,7 +250,7 @@ export class WebrtcClient {
       const timer = setTimeout(() => fail("timed out connecting to the host over WebRTC (no direct path; the host may be behind a strict NAT: ask them to enable TURN, or use a Tailscale/LAN share)"), CONNECT_TIMEOUT_MS);
       sock = new SignalSocket(signalSocketUrl(this.signal, roomOf(token)), { role: "client", auth: roomAuthOf(token) }, async m => {
         try {
-          if (m.type === "welcome" && m.hostPresent === false) fail("the host is offline (its rech daemon isn't connected to the signal server)");
+          if (m.type === "welcome" && m.hostPresent === false) fail("nobody is answering this link: the host's rech daemon may be down, or the link was revoked. Ask the host to check, or for a fresh link");
           else if (m.type === "host-leave" && !this.connected) fail("the host left before the connection finished");
           else if (m.type === "offer" && typeof m.sdp === "string" && !this.pc) {
             const pc = new RTCPeerConnection({ iceServers: Array.isArray(m.ice) ? m.ice : iceServersFromEnv() });
@@ -404,7 +282,7 @@ export class WebrtcClient {
             await this.pc.addIceCandidate(m.candidate).catch(() => {});
           }
         } catch (error) { fail(String(error)); }
-      }, (code, reason) => { if (!this.connected) fail(code === 4404 ? "the host is offline (its rech daemon isn't connected to the signal server)" : code === 1008 ? `the signal server refused this link (${reason || "forbidden"})` : `signal server closed the connection (${reason || code})`); });
+      }, (code, reason) => { if (!this.connected) fail(code === 4404 ? "nobody is answering this link: the host's rech daemon may be down, or the link was revoked. Ask the host to check, or for a fresh link" : code === 1008 ? `the signal server refused this link (${reason || "forbidden"})` : `signal server closed the connection (${reason || code})`); });
       sock.open().catch(e => fail(e.message));
     });
     try { await result; }