agent-yes 1.97.0 → 1.99.0

package/dist/SUPPORTED_CLIS-BGUPuqya.js

@@ -0,0 +1,8 @@
+import "./ts-BECoCPV1.js";
+import "./logger-B9h0djqx.js";
+import "./versionChecker-pct2j3wR.js";
+import "./pidStore-DBjlqzo8.js";
+import "./globalPidIndex-yVd3mbsV.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-eIjVu8HF.js";
+
+export { SUPPORTED_CLIS };

package/dist/{SUPPORTED_CLIS-eD-UlqO_.js → SUPPORTED_CLIS-eIjVu8HF.js}

@@ -1,8 +1,8 @@
-import { t as CLIS_CONFIG } from "./ts-BAc4Jcrw.js";
+import { t as CLIS_CONFIG } from "./ts-BECoCPV1.js";
 
 //#region ts/SUPPORTED_CLIS.ts
 const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-eD-UlqO_.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-eIjVu8HF.js.map

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { n as logger } from "./logger-B9h0djqx.js";
-import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-MNvA73o9.js";
+import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-pct2j3wR.js";
 import { argv } from "process";
 import { execFileSync, spawn } from "child_process";
 import ms from "ms";
@@ -482,7 +482,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 {
 	const rawArg = process.argv[2];
 	const isHelpFlag = rawArg === "-h" || rawArg === "--help";
-	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-B4gXEu5I.js");
+	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-D3Z9cD9u.js");
 	if (isHelpFlag && process.argv.length === 3) {
 		cmdHelp();
 		process.exit(0);
@@ -515,7 +515,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-CNO_pj9f.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-BGUPuqya.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);

package/dist/index.js

@@ -1,6 +1,6 @@
-import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-BAc4Jcrw.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-BECoCPV1.js";
 import "./logger-B9h0djqx.js";
-import "./versionChecker-MNvA73o9.js";
+import "./versionChecker-pct2j3wR.js";
 import "./pidStore-DBjlqzo8.js";
 import "./globalPidIndex-yVd3mbsV.js";
 

package/dist/serve-SQYFRbm3.js

@@ -0,0 +1,554 @@
+import "./ts-BECoCPV1.js";
+import "./logger-B9h0djqx.js";
+import "./versionChecker-pct2j3wR.js";
+import "./pidStore-DBjlqzo8.js";
+import "./globalPidIndex-yVd3mbsV.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-eIjVu8HF.js";
+import "./remotes-C3xPRtfg.js";
+import { c as readNotes, f as snapshotStatus, l as renderRawLog, m as writeToIpc, o as listRecords, r as controlCodeFromName, u as resolveOne } from "./subcommands-z8Y8gcD_.js";
+import yargs from "yargs";
+import { mkdir, open, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+import { fileURLToPath } from "node:url";
+import { watch } from "node:fs";
+import { randomBytes, timingSafeEqual } from "crypto";
+
+//#region ts/serve.ts
+const DEFAULT_PORT = 7432;
+function agentYesHome() {
+	return process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
+}
+function tokenPath() {
+	return path.join(agentYesHome(), ".serve-token");
+}
+async function loadOrCreateToken(tokenFlag) {
+	if (tokenFlag) return tokenFlag;
+	try {
+		return (await readFile(tokenPath(), "utf-8")).trim();
+	} catch {
+		const token = randomBytes(20).toString("hex");
+		await mkdir(agentYesHome(), { recursive: true });
+		await writeFile(tokenPath(), token, { mode: 384 });
+		return token;
+	}
+}
+function tokenEqual(provided, expectedToken) {
+	const maxLen = Math.max(provided.length, expectedToken.length);
+	return timingSafeEqual(Buffer.from(provided.padEnd(maxLen, "\0")), Buffer.from(expectedToken.padEnd(maxLen, "\0"))) && provided.length === expectedToken.length;
+}
+function checkAuth(req, expectedToken) {
+	const auth = req.headers.get("authorization") ?? "";
+	if (auth.startsWith("Bearer ")) return tokenEqual(auth.slice(7), expectedToken);
+	const q = new URL(req.url).searchParams.get("token");
+	return q ? tokenEqual(q, expectedToken) : false;
+}
+const defaultOpts = (overrides = {}) => ({
+	all: false,
+	active: false,
+	json: true,
+	latest: true,
+	cwdScope: null,
+	...overrides
+});
+const DAEMON_NAME = "agent-yes";
+async function cmdServeDaemon(sub, args) {
+	const oxmgrBin = Bun.which("oxmgr");
+	if (!oxmgrBin) {
+		process.stderr.write("ay serve install: oxmgr not found\n  install with:  cargo install oxmgr\n             or: bun add -g oxmgr\n");
+		return 1;
+	}
+	if (sub === "install") {
+		const token = await loadOrCreateToken(void 0);
+		const ayBin = Bun.which("ay");
+		const serveCmd = [
+			...ayBin ? [process.execPath, ayBin] : ["ay"],
+			"serve",
+			...args
+		].join(" ");
+		const code = await Bun.spawn([
+			oxmgrBin,
+			"start",
+			serveCmd,
+			"--name",
+			DAEMON_NAME,
+			"--restart",
+			"always"
+		], { stdio: [
+			"ignore",
+			"inherit",
+			"inherit"
+		] }).exited;
+		if (code === 0) {
+			const portM = /--port[=\s](\d+)/.exec(args.join(" "));
+			const port = portM ? Number(portM[1]) : DEFAULT_PORT;
+			const webrtcish = args.some((a) => a.startsWith("--webrtc") || a.startsWith("--share"));
+			const httpish = args.some((a) => a.startsWith("--http") || a.startsWith("--share")) || !args.some((a) => a.startsWith("--webrtc"));
+			process.stdout.write(`\ninstalled '${DAEMON_NAME}' as a daemon via oxmgr\n`);
+			process.stdout.write(`token: ${token}\n\n`);
+			if (httpish) {
+				process.stdout.write(`  ay ls   ${token}@<host>:${port}\n`);
+				process.stdout.write(`  ay remote add <alias> http://${token}@<host>:${port}\n`);
+			}
+			process.stdout.write(`  ay serve logs                # view server logs\n`);
+			process.stdout.write(`  ay serve uninstall           # remove daemon\n`);
+			if (webrtcish) process.stdout.write("\nthe WebRTC share link is printed by the daemon — see: ay serve logs\n(the room persists in ~/.agent-yes/.share-room, so the link survives restarts)\n");
+		}
+		return code ?? 1;
+	}
+	if (sub === "uninstall") return await Bun.spawn([
+		oxmgrBin,
+		"delete",
+		DAEMON_NAME
+	], { stdio: [
+		"ignore",
+		"inherit",
+		"inherit"
+	] }).exited ?? 1;
+	if (sub === "logs") return await Bun.spawn([
+		oxmgrBin,
+		"logs",
+		DAEMON_NAME,
+		...args
+	], { stdio: [
+		"ignore",
+		"inherit",
+		"inherit"
+	] }).exited ?? 1;
+	return 1;
+}
+async function cmdServe(rest) {
+	if (rest.includes("-h") || rest.includes("--help")) {
+		process.stdout.write(`Usage: ay serve [options]
+
+Start an API server (HTTP and/or WebRTC) so browsers and remote machines
+can list/tail/send agents.
+
+Modes (default: --http):
+  --http            HTTP API + web console on --port; no WebRTC
+  --webrtc [URL]    Share over WebRTC (bare flag mints a room+link on
+                    agent-yes.com, or pass webrtc://room:token@host).
+                    Alone it needs NO port — combine with --http for both.
+                    The minted room persists in ~/.agent-yes/.share-room
+                    (stable link across restarts; delete the file to rotate).
+  --share [URL]     Legacy alias for --http --webrtc
+
+Options:
+  --port N          Port to listen on (default: ${DEFAULT_PORT})\n  --host HOST       Interface to bind (default: 127.0.0.1; use 0.0.0.0 to expose)\n  --token TOKEN     Auth token (auto-generated and saved if omitted)\n  -d, --daemon      Install these flags as a background daemon via oxmgr\n                    (same as: ay serve install <flags>)\n  --allow-spawn     Deprecated no-op — the console can always spawn agents\n  --tls-cert FILE   TLS certificate PEM\n  --tls-key  FILE   TLS private key PEM\n\nSubcommands:\n  ay serve install    install as background daemon via oxmgr\n  ay serve uninstall  remove daemon\n  ay serve logs       view daemon logs\n\nOnce running, connect from another machine:\n  ay ls   <token>@<host>:${DEFAULT_PORT}\n  ay remote add <alias> http://<token>@<host>:${DEFAULT_PORT}\n`);
+		return 0;
+	}
+	const sub = rest[0];
+	if (sub === "install" || sub === "uninstall" || sub === "logs") return cmdServeDaemon(sub, rest.slice(1));
+	const argv = await yargs(rest).usage("Usage: ay serve [options]").option("port", {
+		type: "number",
+		default: DEFAULT_PORT,
+		description: "Port to listen on"
+	}).option("host", {
+		type: "string",
+		default: "127.0.0.1",
+		description: "Interface to bind (use 0.0.0.0 to expose)"
+	}).option("token", {
+		type: "string",
+		description: "Auth token (auto-generated if omitted)"
+	}).option("tls-cert", {
+		type: "string",
+		description: "TLS certificate file (PEM)"
+	}).option("tls-key", {
+		type: "string",
+		description: "TLS private key file (PEM)"
+	}).option("http", {
+		type: "boolean",
+		description: "Serve the HTTP API + web console on --port (default mode)"
+	}).option("webrtc", {
+		type: "string",
+		description: "Share over WebRTC: bare flag mints a room+link, or pass webrtc://room:token@host. Needs no port unless combined with --http"
+	}).option("share", {
+		type: "string",
+		description: "Legacy alias for --http --webrtc"
+	}).option("daemon", {
+		alias: "d",
+		type: "boolean",
+		default: false,
+		description: "Install as a background daemon via oxmgr (same as: ay serve install <flags>)"
+	}).option("allow-spawn", {
+		type: "boolean",
+		default: false,
+		description: "Deprecated no-op — the console can always spawn agents"
+	}).help(false).version(false).exitProcess(false).parseAsync();
+	if (argv.daemon) return cmdServeDaemon("install", rest.filter((a) => a !== "--daemon" && a !== "-d"));
+	const port = argv.port ?? DEFAULT_PORT;
+	const host = argv.host ?? "127.0.0.1";
+	const tokenFlag = typeof argv.token === "string" ? argv.token : void 0;
+	const certPath = typeof argv["tls-cert"] === "string" ? argv["tls-cert"] : void 0;
+	const keyPath = typeof argv["tls-key"] === "string" ? argv["tls-key"] : void 0;
+	if (certPath && !keyPath || !certPath && keyPath) {
+		process.stderr.write("ay serve: --tls-cert and --tls-key must both be provided\n");
+		return 1;
+	}
+	const useHttps = !!(certPath && keyPath);
+	const scheme = useHttps ? "https" : "http";
+	const wantWebrtc = argv.webrtc !== void 0 || argv.share !== void 0;
+	const wantHttp = argv.http === true || argv.share !== void 0 || argv.webrtc === void 0;
+	if (wantHttp && host !== "127.0.0.1" && host !== "localhost") process.stderr.write("ay serve: warning: binding to non-loopback — ensure your network is trusted or use Tailscale/VPN\n");
+	const token = await loadOrCreateToken(tokenFlag);
+	const titleCache = /* @__PURE__ */ new Map();
+	const logTitle = async (logFile) => {
+		if (!logFile) return null;
+		try {
+			const fh = await open(logFile, "r");
+			try {
+				const { size, mtimeMs } = await fh.stat();
+				const hit = titleCache.get(logFile);
+				if (hit && hit.size === size && hit.mtimeMs === mtimeMs) return hit.title;
+				const len = Math.min(size, 65536);
+				const buf = Buffer.allocUnsafe(len);
+				const { bytesRead } = await fh.read(buf, 0, len, size - len);
+				const text = buf.toString("utf-8", 0, bytesRead);
+				const oscTitleRe = /\x1b\][02];([^\x07\x1b]*)(?:\x07|\x1b\\)/g;
+				let title = null;
+				for (let m; m = oscTitleRe.exec(text);) if (m[1].trim()) title = m[1].trim();
+				titleCache.set(logFile, {
+					size,
+					mtimeMs,
+					title
+				});
+				return title;
+			} finally {
+				await fh.close();
+			}
+		} catch {
+			return null;
+		}
+	};
+	const apiFetch = async (req) => {
+		if (!checkAuth(req, token)) return new Response("Unauthorized", { status: 401 });
+		const url = new URL(req.url);
+		const p = url.pathname;
+		if (req.method === "GET" && p === "/api/ls") {
+			const keyword = url.searchParams.get("keyword") ?? void 0;
+			const opts = defaultOpts({
+				all: url.searchParams.get("all") === "1",
+				active: url.searchParams.get("active") === "1"
+			});
+			try {
+				const records = await listRecords(keyword, opts);
+				const withTitles = await Promise.all(records.map(async (r) => ({
+					...r,
+					title: await logTitle(r.log_file)
+				})));
+				return Response.json(withTitles);
+			} catch (e) {
+				return new Response(e.message, { status: 500 });
+			}
+		}
+		if (req.method === "GET" && p === "/api/notes") {
+			const notes = await readNotes();
+			return Response.json(Object.fromEntries(notes));
+		}
+		const statusM = /^\/api\/status\/(.+)$/.exec(p);
+		if (req.method === "GET" && statusM) {
+			const keyword = decodeURIComponent(statusM[1]);
+			try {
+				const snap = await snapshotStatus(await resolveOne(keyword, defaultOpts({ all: true })));
+				return Response.json(snap);
+			} catch (e) {
+				return new Response(e.message, { status: 404 });
+			}
+		}
+		const readM = /^\/api\/read\/(.+)$/.exec(p);
+		if (req.method === "GET" && readM) {
+			const keyword = decodeURIComponent(readM[1]);
+			const mode = url.searchParams.get("mode") ?? "tail";
+			const n = parseInt(url.searchParams.get("n") ?? "96", 10) || 96;
+			try {
+				const record = await resolveOne(keyword, defaultOpts());
+				if (!record.log_file) return new Response(`pid ${record.pid}: no log_file`, { status: 404 });
+				const text = await renderRawLog(await readFile(record.log_file), {
+					mode,
+					n
+				});
+				return new Response(text, { headers: { "Content-Type": "text/plain; charset=utf-8" } });
+			} catch (e) {
+				return new Response(e.message, { status: 404 });
+			}
+		}
+		const sizeM = /^\/api\/size\/(.+)$/.exec(p);
+		if (req.method === "GET" && sizeM) {
+			const keyword = decodeURIComponent(sizeM[1]);
+			try {
+				const record = await resolveOne(keyword, defaultOpts());
+				const ayHome = process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
+				let cols = null;
+				let rows = null;
+				try {
+					const [c = 0, r = 0] = (await readFile(path.join(ayHome, "ptysize", String(record.pid)), "utf-8")).trim().split(/\s+/).map(Number);
+					if (c > 0 && r > 0) {
+						cols = c;
+						rows = r;
+					}
+				} catch {}
+				return Response.json({
+					pid: record.pid,
+					cols,
+					rows
+				});
+			} catch (e) {
+				return new Response(e.message, { status: 404 });
+			}
+		}
+		const tailM = /^\/api\/tail\/(.+)$/.exec(p);
+		if (req.method === "GET" && tailM) {
+			const keyword = decodeURIComponent(tailM[1]);
+			const raw = url.searchParams.get("raw") === "1";
+			try {
+				const record = await resolveOne(keyword, defaultOpts());
+				if (!record.log_file) return new Response(`pid ${record.pid}: no log_file`, { status: 404 });
+				const logPath = record.log_file;
+				const stream = new ReadableStream({ async start(ctrl) {
+					const enc = new TextEncoder();
+					const send = (text) => ctrl.enqueue(enc.encode(`data: ${JSON.stringify(text)}\n\n`));
+					const ping = () => ctrl.enqueue(enc.encode(": ping\n\n"));
+					const initBuf = await readFile(logPath).catch(() => Buffer.alloc(0));
+					if (raw) send(new TextDecoder().decode(initBuf.slice(Math.max(0, initBuf.length - 65536))));
+					else send(await renderRawLog(initBuf, {
+						mode: "tail",
+						n: 96
+					}));
+					let offset = initBuf.length;
+					let closed = false;
+					const heartbeat = setInterval(() => {
+						if (closed) {
+							clearInterval(heartbeat);
+							return;
+						}
+						ping();
+					}, 15e3);
+					const ansiRe = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g;
+					const ctrlRe = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
+					const fh = await open(logPath, "r").catch(() => null);
+					let reading = false;
+					const flush = async () => {
+						if (closed || reading || !fh) return;
+						reading = true;
+						try {
+							const { size } = await fh.stat();
+							if (size < offset) offset = size;
+							if (size > offset) {
+								const len = size - offset;
+								const buf = Buffer.allocUnsafe(len);
+								const { bytesRead } = await fh.read(buf, 0, len, offset);
+								offset += bytesRead;
+								const chunk = buf.subarray(0, bytesRead);
+								if (raw) send(new TextDecoder().decode(chunk));
+								else {
+									const text = new TextDecoder().decode(chunk).replace(ansiRe, "").replace(ctrlRe, "");
+									if (text.trim()) send(text.trimStart());
+								}
+							}
+						} catch {} finally {
+							reading = false;
+						}
+					};
+					let watcher = null;
+					try {
+						watcher = watch(logPath, () => void flush());
+					} catch {}
+					const poller = setInterval(() => void flush(), 60);
+					req.signal.addEventListener("abort", () => {
+						closed = true;
+						clearInterval(heartbeat);
+						clearInterval(poller);
+						try {
+							watcher?.close();
+						} catch {}
+						fh?.close().catch(() => {});
+						try {
+							ctrl.close();
+						} catch {}
+					});
+				} });
+				return new Response(stream, { headers: {
+					"Content-Type": "text/event-stream",
+					"Cache-Control": "no-cache",
+					Connection: "keep-alive"
+				} });
+			} catch (e) {
+				return new Response(e.message, { status: 404 });
+			}
+		}
+		if (req.method === "POST" && p === "/api/send") {
+			let body;
+			try {
+				body = await req.json();
+			} catch {
+				return new Response("invalid JSON body", { status: 400 });
+			}
+			const { keyword, msg = "", code = "enter" } = body;
+			if (!keyword || typeof keyword !== "string") return new Response("missing keyword", { status: 400 });
+			try {
+				const record = await resolveOne(keyword, defaultOpts());
+				if (!record.fifo_file) return new Response(`pid ${record.pid}: no fifo_file`, { status: 409 });
+				const trailing = controlCodeFromName(code.toLowerCase());
+				if (msg && trailing) {
+					await writeToIpc(record.fifo_file, msg);
+					await new Promise((r) => setTimeout(r, 200));
+					await writeToIpc(record.fifo_file, trailing);
+				} else await writeToIpc(record.fifo_file, msg + trailing);
+				return Response.json({
+					ok: true,
+					pid: record.pid
+				});
+			} catch (e) {
+				return new Response(e.message, { status: 404 });
+			}
+		}
+		const resizeM = /^\/api\/resize\/(.+)$/.exec(p);
+		if (req.method === "POST" && resizeM) {
+			const keyword = decodeURIComponent(resizeM[1]);
+			let body;
+			try {
+				body = await req.json();
+			} catch {
+				return new Response("invalid JSON body", { status: 400 });
+			}
+			const cols = Math.max(1, Math.floor(Number(body.cols) || 0));
+			const rows = Math.max(1, Math.floor(Number(body.rows) || 0));
+			if (!cols || !rows) return new Response("missing cols/rows", { status: 400 });
+			try {
+				const record = await resolveOne(keyword, defaultOpts());
+				const ayHome = process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
+				const winsizeDir = path.join(ayHome, "winsize");
+				await mkdir(winsizeDir, { recursive: true });
+				await writeFile(path.join(winsizeDir, String(record.pid)), `${cols} ${rows} ${Date.now()}\n`);
+				try {
+					process.kill(record.pid, "SIGWINCH");
+				} catch {}
+				return Response.json({
+					ok: true,
+					pid: record.pid,
+					cols,
+					rows
+				});
+			} catch (e) {
+				return new Response(e.message, { status: 404 });
+			}
+		}
+		if (req.method === "POST" && p === "/api/spawn") {
+			let body;
+			try {
+				body = await req.json();
+			} catch {
+				return new Response("invalid JSON body", { status: 400 });
+			}
+			const cli = String(body.cli ?? "claude");
+			if (!SUPPORTED_CLIS.includes(cli)) return new Response(`unsupported cli: ${cli}`, { status: 400 });
+			const cwd = typeof body.cwd === "string" && body.cwd ? body.cwd : process.cwd();
+			const prompt = String(body.prompt ?? "");
+			process.stderr.write(`→ console spawned:  ay ${cli}${prompt ? ` -- "${prompt.slice(0, 60)}"` : ""}  (cwd: ${cwd})\n`);
+			try {
+				const child = Bun.spawn([
+					"ay",
+					cli,
+					...prompt ? ["--", prompt] : []
+				], {
+					cwd,
+					stdin: "ignore",
+					stdout: "ignore",
+					stderr: "ignore"
+				});
+				child.unref();
+				return Response.json({
+					ok: true,
+					pid: child.pid,
+					cli,
+					cwd
+				});
+			} catch (e) {
+				return new Response(e.message, { status: 500 });
+			}
+		}
+		return new Response("Not Found", { status: 404 });
+	};
+	const uiDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "lab", "ui");
+	const serveUiFile = async (name, type) => {
+		try {
+			const buf = await readFile(path.join(uiDir, name));
+			return new Response(buf, { headers: { "Content-Type": type } });
+		} catch {
+			return new Response("UI assets not found in this install — use the /api endpoints", { status: 404 });
+		}
+	};
+	const httpFetch = async (req) => {
+		const p = new URL(req.url).pathname;
+		if (req.method === "GET" && (p === "/" || p === "/index.html")) return serveUiFile("index.html", "text/html; charset=utf-8");
+		if (req.method === "GET" && p === "/room-client.js") return serveUiFile("room-client.js", "text/javascript; charset=utf-8");
+		if (req.method === "GET" && p === "/favicon.ico") return new Response(null, { status: 204 });
+		return apiFetch(req);
+	};
+	const serverOpts = {
+		hostname: host,
+		port,
+		idleTimeout: 0,
+		fetch: httpFetch
+	};
+	if (useHttps) serverOpts.tls = {
+		cert: Bun.file(certPath),
+		key: Bun.file(keyPath)
+	};
+	let server = null;
+	if (wantHttp) {
+		try {
+			server = Bun.serve(serverOpts);
+		} catch (e) {
+			if (e.code === "EADDRINUSE") {
+				process.stderr.write(`ay serve: port ${port} is already in use — pick another with --port N,\nor run a port-free WebRTC-only share with: ay serve --webrtc\n`);
+				return 1;
+			}
+			throw e;
+		}
+		const uiHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+		process.stdout.write(`ay serve  ${scheme}://${host}:${port}\n`);
+		process.stdout.write(`token:    ${token}\n\n`);
+		process.stdout.write(`web console (token in the # is eaten on open):\n`);
+		process.stdout.write(`  ${scheme}://${uiHost}:${port}/#k=${token}\n\n`);
+		process.stdout.write(`connect from another machine:\n`);
+		process.stdout.write(`  ay ls   ${token}@<host>:${port}\n`);
+		process.stdout.write(`  ay tail ${token}@<host>:${port}:<keyword>\n`);
+		process.stdout.write(`  ay send ${token}@<host>:${port}:<keyword> "message"\n\n`);
+		process.stdout.write(`save as alias:\n`);
+		process.stdout.write(`  ay remote add <alias> ${scheme}://${token}@<host>:${port}\n\n`);
+		if (!useHttps) process.stdout.write("for HTTPS: ay serve --tls-cert cert.pem --tls-key key.pem\n  openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes -subj '/CN=localhost'\n\n");
+	}
+	if (wantWebrtc) {
+		const webrtcVal = argv.webrtc ?? argv.share;
+		const explicitUrl = typeof webrtcVal === "string" && webrtcVal.startsWith("webrtc://") ? webrtcVal : void 0;
+		try {
+			const { startShare, loadOrCreateShareRoom } = await import("./share-BsCeIfQM.js");
+			const { link } = await startShare({
+				url: explicitUrl ?? await loadOrCreateShareRoom(),
+				localFetch: apiFetch,
+				apiToken: token
+			});
+			process.stdout.write(`${wantHttp ? "\n" : ""}shared over WebRTC — open this link (the token is eaten from the URL on open):\n  ${link}\n` + (explicitUrl ? "\n" : `  (persistent room — same link across restarts; delete ~/.agent-yes/.share-room to rotate)\n\n`));
+		} catch (e) {
+			process.stderr.write(`ay serve --webrtc failed: ${e.message}\n`);
+			if (!wantHttp) return 1;
+		}
+	}
+	process.stdout.write(`(Ctrl-C to stop)\n`);
+	await new Promise((resolve) => {
+		process.on("SIGINT", () => {
+			server?.stop();
+			resolve();
+		});
+		process.on("SIGTERM", () => {
+			server?.stop();
+			resolve();
+		});
+	});
+	return 0;
+}
+
+//#endregion
+export { cmdServe };
+//# sourceMappingURL=serve-SQYFRbm3.js.map

package/dist/{share-DUhUA1Pi.js → share-BsCeIfQM.js}

@@ -1,3 +1,6 @@
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
 import { randomBytes } from "crypto";
 
 //#region ts/share.ts
@@ -5,6 +8,20 @@ const SUB = "ay-signal-1";
 const ICE = [{ urls: "stun:stun.l.google.com:19302" }];
 const MAX_CHUNK = 15e3;
 const DEFAULT_SIGHOST = "s.agent-yes.com";
+function shareRoomPath() {
+	const home = process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
+	return path.join(home, ".share-room");
+}
+async function loadOrCreateShareRoom(sighost = DEFAULT_SIGHOST) {
+	try {
+		const url = (await readFile(shareRoomPath(), "utf-8")).trim();
+		if (url.startsWith("webrtc://")) return url;
+	} catch {}
+	const url = `webrtc://${"r" + randomBytes(3).toString("hex")}:${randomBytes(32).toString("hex")}@${sighost}`;
+	await mkdir(path.dirname(shareRoomPath()), { recursive: true });
+	await writeFile(shareRoomPath(), url, { mode: 384 });
+	return url;
+}
 function parseShareUrl(s) {
 	const m = /^webrtc:\/\/([^:@/]+):([^@/]+)@(.+)$/.exec(s);
 	if (!m) throw new Error(`bad --share url: ${s} (want webrtc://room:token@host)`);
@@ -131,7 +148,7 @@ async function startShare(opts) {
 		const ac = new AbortController();
 		aborts.set(id, ac);
 		try {
-			const res = await fetch(opts.apiUrl + p, {
+			const res = await opts.localFetch(new Request(`http://ay.local${p}`, {
 				method,
 				headers: {
 					Authorization: `Bearer ${opts.apiToken}`,
@@ -139,7 +156,7 @@ async function startShare(opts) {
 				},
 				body: body ?? void 0,
 				signal: ac.signal
-			});
+			}));
 			send(dc, {
 				t: "res",
 				id,
@@ -180,5 +197,5 @@ async function startShare(opts) {
 }
 
 //#endregion
-export { startShare };
-//# sourceMappingURL=share-DUhUA1Pi.js.map
+export { loadOrCreateShareRoom, startShare };
+//# sourceMappingURL=share-BsCeIfQM.js.map

package/dist/{subcommands-B4gXEu5I.js → subcommands-D3Z9cD9u.js}

@@ -1,6 +1,6 @@
 import "./logger-B9h0djqx.js";
 import "./globalPidIndex-yVd3mbsV.js";
 import "./remotes-C3xPRtfg.js";
-import { a as isSubcommand, c as readNotes, d as runSubcommand, f as snapshotStatus, i as isPidAlive, l as renderRawLog, m as writeToIpc, n as cmdHelp, o as listRecords, p as stopTipForCli, r as controlCodeFromName, s as matchKeyword, t as GRACEFUL_EXIT_COMMANDS, u as resolveOne } from "./subcommands-K242usI5.js";
+import { a as isSubcommand, c as readNotes, d as runSubcommand, f as snapshotStatus, i as isPidAlive, l as renderRawLog, m as writeToIpc, n as cmdHelp, o as listRecords, p as stopTipForCli, r as controlCodeFromName, s as matchKeyword, t as GRACEFUL_EXIT_COMMANDS, u as resolveOne } from "./subcommands-z8Y8gcD_.js";
 
 export { cmdHelp, isSubcommand, runSubcommand };