agent-yes 1.302.2 → 1.303.0

package/ts/webrtcSignal.spec.ts

@@ -6,6 +6,10 @@ import {
   reduceSignal,
   socketError,
   timeoutError,
+  memberOf,
+  mergeMemberLs,
+  otherMembers,
+  splitMemberKeyword,
   type SignalState,
 } from "./webrtcSignal.ts";
 
@@ -118,3 +122,39 @@ describe("describeConnectFailure", () => {
     ).toContain("not a sandbox");
   });
 });
+
+describe("rooms with several hosts", () => {
+  const a = { peer: "h-aaaa", name: "alpha" };
+  const b = { peer: "h-bbbb", name: "beta" };
+
+  it("names the sender of a host frame, defaulting to the one host of an older server", () => {
+    expect(memberOf({ type: "offer", from: "h-aaaa" })).toBe("h-aaaa");
+    expect(memberOf({ type: "offer" })).toBe("host");
+  });
+
+  it("reads a leading member name off a keyword", () => {
+    expect(splitMemberKeyword("beta:1111", [a, b])).toEqual({ member: b, keyword: "1111" });
+    expect(splitMemberKeyword("h-aaaa:repo", [a, b])).toEqual({ member: a, keyword: "repo" });
+    expect(splitMemberKeyword("alpha", [a, b])).toEqual({ member: a, keyword: undefined });
+    expect(splitMemberKeyword("gamma:1111", [a, b])).toBeNull();
+    expect(splitMemberKeyword("1111", [a, b])).toBeNull();
+  });
+
+  it("leaves out this machine's own member unless it is the only one", () => {
+    expect(otherMembers([a, b], "alpha")).toEqual([b]);
+    expect(otherMembers([a], "alpha")).toEqual([a]);
+  });
+
+  it("tags every merged row with its member", () => {
+    expect(
+      mergeMemberLs([
+        { member: a, rows: [{ pid: 1111 }] },
+        { member: b, rows: [{ pid: 2222 }] },
+        { member: { peer: "h-cccc", name: "" }, rows: "not a list" },
+      ]),
+    ).toEqual([
+      { pid: 1111, member: "alpha" },
+      { pid: 2222, member: "beta" },
+    ]);
+  });
+});

package/ts/webrtcSignal.ts

@@ -133,11 +133,67 @@ export function describeConnectFailure(
       return Promise.resolve(
         `WebRTC handshake with the host behind ${host} failed: ${cause}\n` +
           `  Signaling worked and the host answered, so this is not a sandbox or proxy\n` +
-          `  problem — the two machines could not open a data channel. Usual causes: a\n` +
-          `  second host answering in the same room (on the host: \`ay serve status\`,\n` +
-          `  and kill any stray \`ayrs serve\`), or ICE blocked between the networks.`,
+          `  problem — the two machines could not open a data channel. Usual cause: a\n` +
+          `  host behind Docker Desktop or another symmetric NAT. There, publish one UDP\n` +
+          `  port and set AGENT_YES_ICE_UDP_PORT + AGENT_YES_ICE_PUBLIC_IPS, or set\n` +
+          `  AGENT_YES_SIGNAL_RELAY=1 on both ends to relay through the signaling server.`,
       );
     default:
       return sandboxHint(cause);
   }
 }
+
+// ---------------------------------------------------------------------------
+// Rooms with several hosts (lab/ui/cf/roomRouting.ts)
+// ---------------------------------------------------------------------------
+
+/** One host serving a room: its signaling peer id and display name. */
+export interface RoomMember {
+  peer: string;
+  name: string;
+}
+
+/**
+ * The sender of a host frame. A signaling server without multi-host rooms
+ * does not tag host frames; its one host is "host".
+ */
+export function memberOf(m: any): string {
+  return typeof m?.from === "string" && m.from ? m.from : "host";
+}
+
+/**
+ * Which members a `<alias>:<keyword>` reference names, when the keyword starts
+ * with a member's name (`<alias>:<member>:<keyword>`). Returns the member and
+ * the rest of the keyword, or null when the first segment names no member.
+ */
+export function splitMemberKeyword(
+  keyword: string,
+  members: RoomMember[],
+): { member: RoomMember; keyword: string | undefined } | null {
+  const i = keyword.indexOf(":");
+  const head = i === -1 ? keyword : keyword.slice(0, i);
+  const member = members.find((m) => m.name === head || m.peer === head);
+  if (!member) return null;
+  const rest = i === -1 ? "" : keyword.slice(i + 1);
+  return { member, keyword: rest || undefined };
+}
+
+/**
+ * The members a viewer should talk to: everyone but the machine it runs on
+ * (a member listing its own room would show its agents twice), unless that
+ * would leave nobody.
+ */
+export function otherMembers(members: RoomMember[], selfName: string): RoomMember[] {
+  const others = members.filter((m) => m.name !== selfName);
+  return others.length ? others : members;
+}
+
+/** `/api/ls` rows from several members, each row tagged with its member. */
+export function mergeMemberLs(parts: { member: RoomMember; rows: unknown }[]): any[] {
+  const out: any[] = [];
+  for (const { member, rows } of parts)
+    if (Array.isArray(rows))
+      for (const r of rows)
+        if (r && typeof r === "object") out.push({ ...r, member: member.name || member.peer });
+  return out;
+}

package/dist/trayApp-F_Xs3C2N.js

@@ -1,5 +0,0 @@
-import "./versionChecker-DrjMn-XI.js";
-import "./rustBinary-Btf18sk5.js";
-import { a as trayHiddenMarker, i as launchTray, n as hasDesktop, r as isTrayHidden, t as cmdTray } from "./trayApp-DWVdr0Pr.js";
-
-export { cmdTray };

package/dist/webrtcLink-CAdvnRM0.js

@@ -1,4 +0,0 @@
-import "./e2e-BdLf8DvY.js";
-import { a as toWebrtcUrl, i as parseWebrtcLink, n as SIGNAL_SUBPROTOCOL, r as isWebrtcSpec, t as DEFAULT_SIGHOST } from "./webrtcLink-CKnjNGaV.js";
-
-export { parseWebrtcLink };

package/dist/webrtcRemote-BYy2lTTl.js

@@ -1,408 +0,0 @@
-import { a as computeTranscriptHash, c as open, d as randomHex, f as seal, l as packEnvelope, n as FLAG_CONFIRM, o as deriveAuthToken, p as unpackEnvelope, s as deriveDirKeys } from "./e2e-BdLf8DvY.js";
-import { i as parseWebrtcLink, n as SIGNAL_SUBPROTOCOL, r as isWebrtcSpec } from "./webrtcLink-CKnjNGaV.js";
-import { RTCPeerConnection } from "node-datachannel/polyfill";
-
-//#region ts/signalingHint.ts
-/**
-* Reach the signaling host over ordinary HTTPS. ANY HTTP response counts as
-* reachable — a 404 or a 400 still proves egress, TLS and DNS all worked, which
-* is the whole question. Never throws; a failure IS the answer.
-*/
-async function probeSignalingHost(host, timeoutMs = 4e3, doFetch = fetch) {
-	try {
-		await doFetch(`https://${host}/`, {
-			method: "HEAD",
-			signal: AbortSignal.timeout(timeoutMs),
-			redirect: "manual"
-		});
-		return "https-ok";
-	} catch {
-		return "https-failed";
-	}
-}
-/**
-* The operator-facing explanation, given the original error and what the probe
-* found. Pure, so the wording is testable without a network.
-*
-* Every branch keeps the original error text: it is the only part that is
-* certainly true, and a hint that replaces evidence is worse than no hint.
-*/
-function signalingFailureHint(cause, probe, host) {
-	const head = `cannot reach the signaling host ${host}: ${cause}`;
-	switch (probe) {
-		case "https-ok": return `${head}\n  HTTPS to ${host} works from here, so DNS, TLS and egress are fine and the\n  server is up — only the WebSocket did not connect. Something in between is\n  allowing HTTPS and refusing the upgrade, which is what a coding-agent\n  sandbox or an intercepting proxy does.\n  If you are running inside a sandbox (Codex and similar): re-run with\n  escalated / external-network permission. If you are behind a corporate\n  proxy: it must allow WebSocket upgrades to ${host}.`;
-		case "https-failed": return `${head}\n  HTTPS to ${host} does not work from here either, so this is not specific to\n  WebSockets — either this environment has no outbound network, or the host\n  is genuinely unreachable.\n  If you are running inside a sandbox (Codex and similar): re-run with\n  escalated / external-network permission. Otherwise check connectivity and\n  whether ${host} is up.`;
-		default: return `${head}\n  If you are running inside a coding-agent sandbox, outbound WebSockets are\n  often blocked — re-run with escalated / external-network permission.`;
-	}
-}
-
-//#endregion
-//#region ts/webrtcSignal.ts
-var ConnectError = class extends Error {
-	constructor(phase, message) {
-		super(message);
-		this.phase = phase;
-		this.name = "ConnectError";
-	}
-};
-/** Classify one signaling frame against the current state. */
-function reduceSignal(state, m) {
-	if (!m || typeof m !== "object") return { kind: "ignore" };
-	switch (m.type) {
-		case "welcome":
-			if (m.hostPresent === false) return {
-				kind: "fail",
-				error: new ConnectError("no-host", "the room is open but no host is attached to it")
-			};
-			return { kind: "ignore" };
-		case "offer":
-			if (state.offered) return { kind: "duplicate-offer" };
-			return {
-				kind: "offer",
-				sdp: m.sdp,
-				iceServers: m.iceServers || [],
-				from: m.from
-			};
-		case "candidate": return {
-			kind: "candidate",
-			candidate: m.candidate,
-			queue: !state.offered
-		};
-		default: return { kind: "ignore" };
-	}
-}
-/** The error for a socket that closed before the channel was confirmed. */
-function closeError(state, code, reason) {
-	const why = `signaling closed (code ${code}${reason ? `: ${reason}` : ""})`;
-	if (!state.opened) return new ConnectError("ws-not-open", `${why} before the socket opened`);
-	if (code === 1008 || reason) return new ConnectError("rejected", why);
-	if (!state.offered) return new ConnectError("no-host", `${why} before the host offered`);
-	return new ConnectError("ice-timeout", `${why} during the WebRTC handshake`);
-}
-/** The error for the connect deadline expiring. */
-function timeoutError(state, timeoutMs) {
-	const s = `${Math.round(timeoutMs / 1e3)}s`;
-	if (!state.opened) return new ConnectError("ws-not-open", `signaling did not open within ${s}`);
-	if (!state.offered) return new ConnectError("no-host", `no host answered the join within ${s}`);
-	return new ConnectError("ice-timeout", `no WebRTC data channel came up within ${s}`);
-}
-/** The error for a WebSocket `error` event. */
-function socketError(state, detail) {
-	return state.opened ? new ConnectError("rejected", `signaling error after connect: ${detail}`) : new ConnectError("ws-not-open", `signaling error: ${detail}`);
-}
-/**
-* The operator-facing explanation. `sandboxHint` is the HTTPS-probe-derived
-* note from signalingHint.ts and is consulted ONLY for a socket that never
-* opened: every later phase proves the WebSocket upgrade worked, so blaming a
-* sandbox or proxy there would be wrong — and sent one reader down exactly
-* that path.
-*/
-function describeConnectFailure(err, host, sandboxHint) {
-	const phase = err instanceof ConnectError ? err.phase : "ws-not-open";
-	const cause = err.message;
-	switch (phase) {
-		case "no-host": return Promise.resolve(`no host in the room at ${host}: ${cause}\n  The signaling server is reachable and accepted the join — the daemon on the\n  other machine is not attached to this room. There, run \`ay share status\`:\n  if it prints a different link, the room rotated (or the daemon was\n  reinstalled) and this saved remote is stale — re-add it with the new link.`);
-		case "rejected": return Promise.resolve(`join rejected by the signaling host ${host}: ${cause}\n  The room id or secret in this saved remote no longer matches what the host\n  serves (it rotated, or the link was copied from a different machine).\n  On the host run \`ay share status\` and re-add the remote with that link.`);
-		case "ice-timeout": return Promise.resolve(`WebRTC handshake with the host behind ${host} failed: ${cause}\n  Signaling worked and the host answered, so this is not a sandbox or proxy\n  problem — the two machines could not open a data channel. Usual causes: a\n  second host answering in the same room (on the host: \`ay serve status\`,\n  and kill any stray \`ayrs serve\`), or ICE blocked between the networks.`);
-		default: return sandboxHint(cause);
-	}
-}
-
-//#endregion
-//#region ts/webrtcRemote.ts
-const CONNECT_TIMEOUT_MS = 25e3;
-/** A live, key-confirmed WebRTC connection to a single share room. */
-var WebRtcConn = class {
-	ws;
-	pc = null;
-	dc = null;
-	send = { sendCtr: 0n };
-	recv = { lastSeen: -1n };
-	keyC2H = null;
-	keyH2C = null;
-	th = null;
-	hostPeer = null;
-	myNonce = randomHex(16);
-	confirmedIn = false;
-	confirmedOut = false;
-	confirmed = false;
-	sig = {
-		opened: false,
-		offered: false,
-		confirmed: false
-	};
-	earlyCandidates = [];
-	warnedDuplicateHost = false;
-	sendChain = Promise.resolve();
-	recvChain = Promise.resolve();
-	idCounter = 0;
-	pending = /* @__PURE__ */ new Map();
-	ready;
-	resolveReady;
-	rejectReady;
-	constructor(link) {
-		this.link = link;
-		this.ready = new Promise((res, rej) => {
-			this.resolveReady = res;
-			this.rejectReady = rej;
-		});
-		const timer = setTimeout(() => this.rejectReady(timeoutError(this.sig, CONNECT_TIMEOUT_MS)), CONNECT_TIMEOUT_MS);
-		this.ready.then(() => clearTimeout(timer), () => clearTimeout(timer));
-		this.ws = this.dial();
-	}
-	dial() {
-		const { room, host } = this.link;
-		const ws = new WebSocket(`wss://${host}/${room}`, [SIGNAL_SUBPROTOCOL]);
-		ws.onopen = async () => {
-			this.sig.opened = true;
-			const authToken = await deriveAuthToken(this.link.s, room, host);
-			ws.send(JSON.stringify({
-				type: "hello",
-				role: "client",
-				v: 2,
-				token: authToken
-			}));
-		};
-		ws.onerror = (e) => this.rejectReady(socketError(this.sig, String(e?.message ?? e)));
-		ws.onclose = (ev) => {
-			if (!this.confirmed) this.rejectReady(closeError(this.sig, Number(ev?.code ?? 0), String(ev?.reason ?? "")));
-		};
-		ws.onmessage = (ev) => void this.onSignal(ev);
-		return ws;
-	}
-	async onSignal(ev) {
-		const m = JSON.parse(typeof ev.data === "string" ? ev.data : await ev.data.text());
-		const action = reduceSignal(this.sig, m);
-		if (action.kind === "fail") {
-			this.rejectReady(action.error);
-			return;
-		}
-		if (action.kind === "duplicate-offer") {
-			if (!this.warnedDuplicateHost) {
-				this.warnedDuplicateHost = true;
-				process.stderr.write(`[webrtc] a second host offered in room ${this.link.room} — two hosts serve this room; on the host, stop the stray one (\`ay serve status\`)\n`);
-			}
-			return;
-		}
-		if (action.kind === "candidate") {
-			if (action.queue) this.earlyCandidates.push(action.candidate);
-			else if (this.pc) await this.pc.addIceCandidate(action.candidate).catch(() => {});
-			return;
-		}
-		if (action.kind === "offer") {
-			this.sig.offered = true;
-			this.hostPeer = action.from ?? null;
-			const pc = new RTCPeerConnection({ iceServers: action.iceServers || [] });
-			this.pc = pc;
-			let held = [];
-			const sendCandidate = (candidate) => this.ws.send(JSON.stringify({
-				type: "candidate",
-				to: this.hostPeer,
-				candidate
-			}));
-			pc.onicecandidate = (e) => {
-				if (!e.candidate) return;
-				if (held) held.push(e.candidate);
-				else sendCandidate(e.candidate);
-			};
-			pc.ondatachannel = (e) => {
-				const dc = e.channel;
-				this.dc = dc;
-				dc.binaryType = "arraybuffer";
-				dc.onopen = () => this.enqueueSeal(FLAG_CONFIRM, {
-					t: "confirm",
-					nonce: this.myNonce
-				});
-				dc.onmessage = (ev2) => {
-					this.recvChain = this.recvChain.then(() => this.onFrame(ev2.data)).catch(() => {});
-				};
-			};
-			await pc.setRemoteDescription({
-				type: "offer",
-				sdp: action.sdp
-			});
-			const early = this.earlyCandidates;
-			this.earlyCandidates = [];
-			for (const c of early) await pc.addIceCandidate(c).catch(() => {});
-			const answer = await pc.createAnswer();
-			await pc.setLocalDescription(answer);
-			this.th = await computeTranscriptHash(action.sdp, pc.localDescription.sdp);
-			const keys = await deriveDirKeys(this.link.s, this.th);
-			this.keyC2H = keys.keyC2H;
-			this.keyH2C = keys.keyH2C;
-			this.ws.send(JSON.stringify({
-				type: "answer",
-				to: this.hostPeer,
-				sdp: pc.localDescription.sdp
-			}));
-			const queued = held;
-			held = null;
-			for (const c of queued) sendCandidate(c);
-		}
-	}
-	enqueueSeal(flags, obj) {
-		this.sendChain = this.sendChain.then(async () => {
-			if (!this.dc || this.dc.readyState !== "open" || !this.keyC2H || !this.th) return;
-			const frame = await seal(this.keyC2H, this.send, flags, this.th, packEnvelope(obj));
-			try {
-				this.dc.send(frame);
-			} catch {}
-		});
-		return this.sendChain;
-	}
-	async onFrame(data) {
-		if (typeof data === "string" || !this.keyH2C || !this.th) return;
-		let env;
-		try {
-			const { plaintext } = await open(this.keyH2C, data, this.th, this.recv);
-			env = unpackEnvelope(plaintext);
-		} catch {
-			return;
-		}
-		if (!this.confirmed) {
-			if (!env || env.t !== "confirm") return;
-			if (typeof env.nonce === "string" && !this.confirmedOut) {
-				await this.enqueueSeal(FLAG_CONFIRM, {
-					t: "confirm",
-					nonce: this.myNonce,
-					echo: env.nonce
-				});
-				this.confirmedOut = true;
-			}
-			if (env.echo && env.echo === this.myNonce) this.confirmedIn = true;
-			if (this.confirmedIn && this.confirmedOut) {
-				this.confirmed = true;
-				this.sig.confirmed = true;
-				this.resolveReady();
-			}
-			return;
-		}
-		if (!env || env.t === "confirm") return;
-		const p = this.pending.get(env.id);
-		if (!p) return;
-		if (env.t === "res") p.onRes(env.status, env.ct);
-		else if (env.t === "data") p.onData(env.chunk);
-		else if (env.t === "end") p.onEnd(env.error);
-	}
-	/**
-	* Issue one request over the channel. Resolves once the response head (status,
-	* content-type) arrives; the body is a ReadableStream fed by `data` frames as
-	* they land, so streaming endpoints (SSE `tail`) flow without buffering.
-	*/
-	request(method, path, body) {
-		const id = String(++this.idCounter);
-		return new Promise((resolve, reject) => {
-			let controller;
-			const enc = new TextEncoder();
-			let head = false;
-			const stream = new ReadableStream({
-				start: (c) => {
-					controller = c;
-				},
-				cancel: () => {
-					this.pending.delete(id);
-					this.enqueueSeal(0, {
-						t: "abort",
-						id
-					});
-				}
-			});
-			this.pending.set(id, {
-				onRes: (status, ct) => {
-					if (!head) {
-						head = true;
-						resolve({
-							status,
-							ct,
-							stream
-						});
-					}
-				},
-				onData: (chunk) => {
-					try {
-						controller.enqueue(enc.encode(chunk));
-					} catch {}
-				},
-				onEnd: (error) => {
-					this.pending.delete(id);
-					if (error) {
-						if (!head) {
-							head = true;
-							reject(new Error(error));
-						}
-						try {
-							controller.error(new Error(error));
-						} catch {}
-					} else try {
-						controller.close();
-					} catch {}
-				}
-			});
-			this.enqueueSeal(0, {
-				t: "req",
-				id,
-				method,
-				path,
-				body
-			});
-		});
-	}
-	close() {
-		try {
-			this.ws.close();
-		} catch {}
-		try {
-			this.pc?.close();
-		} catch {}
-	}
-};
-/**
-* Connect to a share room and start a local HTTP server that forwards every
-* request over the encrypted DataChannel. Returns the loopback base URL the
-* existing remote commands can `fetch()` against. The process owns teardown:
-* `ay` subcommands `process.exit()` when done, which closes the socket/peer.
-*/
-async function startWebrtcBridge(link) {
-	const parsed = parseWebrtcLink(link);
-	if (!parsed) throw new Error(`not a WebRTC share link: ${link}`);
-	const conn = new WebRtcConn(parsed);
-	try {
-		await conn.ready;
-	} catch (e) {
-		const err = e instanceof Error ? e : new Error(String(e));
-		throw new Error(await describeConnectFailure(err, parsed.host, async (cause) => signalingFailureHint(cause, await probeSignalingHost(parsed.host), parsed.host)));
-	}
-	const server = Bun.serve({
-		port: 0,
-		hostname: "127.0.0.1",
-		idleTimeout: 0,
-		async fetch(req) {
-			const u = new URL(req.url);
-			const pathWithQuery = u.pathname + u.search;
-			const body = req.method !== "GET" && req.method !== "HEAD" ? await req.text() : void 0;
-			try {
-				const { status, ct, stream } = await conn.request(req.method, pathWithQuery, body);
-				return new Response(stream, {
-					status,
-					headers: ct ? { "content-type": ct } : {}
-				});
-			} catch (e) {
-				return new Response(String(e?.message ?? e), { status: 502 });
-			}
-		}
-	});
-	return {
-		baseUrl: `http://127.0.0.1:${server.port}`,
-		token: "webrtc",
-		close: () => {
-			try {
-				server.stop(true);
-			} catch {}
-			conn.close();
-		}
-	};
-}
-
-//#endregion
-export { startWebrtcBridge };
-//# sourceMappingURL=webrtcRemote-BYy2lTTl.js.map