agent-yes 1.122.2 → 1.123.0

package/dist/{serve-tn7ZetZs.js → serve-r_2v9EKc.js}

@@ -1,17 +1,19 @@
-import "./ts-CIf0uaR7.js";
+import "./ts-DgukRoEI.js";
 import "./logger-B9h0djqx.js";
-import { r as getInstalledPackage } from "./versionChecker-DjxKi4qe.js";
-import "./pidStore-B5vBu8Px.js";
-import "./globalPidIndex-gZuTvTBs.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BTu2brih.js";
-import "./remotes-D2fqaRU8.js";
-import { c as listRecords, d as renderRawLog, f as resolveOne, g as writeToIpc, m as snapshotStatus, r as controlCodeFromName, u as readNotes } from "./subcommands-D9BWZilr.js";
+import { r as getInstalledPackage } from "./versionChecker-BqOr1YqC.js";
+import "./pidStore-CGKIhaJO.js";
+import { a as updateGlobalPidStatus } from "./globalPidIndex-C7r2m6s7.js";
+import { t as pgidForWrapper } from "./reaper-BkjPN7mw.js";
+import "./configShared-C5QaNPnz.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-B4O2cFlt.js";
+import "./remotes-D8GvSbhf.js";
+import { f as readNotes, g as snapshotStatus, m as resolveOne, o as extractTaskCounts, p as renderRawLog, r as controlCodeFromName, u as listRecords, v as writeToIpc } from "./subcommands-B13Kto-u.js";
 import yargs from "yargs";
-import { mkdir, open, readFile, writeFile } from "fs/promises";
+import { mkdir, open, readFile, stat, writeFile } from "fs/promises";
 import { homedir, hostname, userInfo } from "os";
 import path from "path";
 import { fileURLToPath } from "node:url";
-import { watch } from "node:fs";
+import { renameSync, watch, writeFileSync } from "node:fs";
 import { randomBytes, timingSafeEqual } from "crypto";
 
 //#region ts/serve.ts
@@ -22,6 +24,11 @@ function agentYesHome() {
 function tokenPath() {
 	return path.join(agentYesHome(), ".serve-token");
 }
+function heartbeatPath() {
+	return path.join(agentYesHome(), ".serve-heartbeat");
+}
+const HEARTBEAT_WRITE_MS = 5e3;
+const HEARTBEAT_STALE_MS = 15e3;
 async function loadOrCreateToken(tokenFlag) {
 	if (tokenFlag) return tokenFlag;
 	try {
@@ -244,6 +251,16 @@ async function cmdServeDaemon(sub, args) {
 			]);
 		}
 		const serveArgv = ayServeArgv(effArgs);
+		const oxmgrHealth = effArgs.some((a) => a.startsWith("--webrtc") || a.startsWith("--share")) && mgr.id === "oxmgr" ? [
+			"--health-cmd",
+			ayServeArgv(["healthcheck"]).join(" "),
+			"--health-interval",
+			"10",
+			"--health-timeout",
+			"5",
+			"--health-max-failures",
+			"3"
+		] : [];
 		const startArgv = mgr.id === "oxmgr" ? [
 			mgr.bin,
 			"start",
@@ -251,7 +268,10 @@ async function cmdServeDaemon(sub, args) {
 			"--name",
 			DAEMON_NAME,
 			"--restart",
-			"always"
+			"always",
+			"--max-restarts",
+			"1000000",
+			...oxmgrHealth
 		] : [
 			mgr.bin,
 			"start",
@@ -395,6 +415,18 @@ Options:
 	}
 	const sub = rest[0];
 	if (sub === "status") return cmdServeStatus(rest.slice(1));
+	if (sub === "healthcheck") {
+		try {
+			const raw = (await readFile(heartbeatPath(), "utf-8")).trim();
+			const ts = Number(raw);
+			const age = Date.now() - ts;
+			if (raw.length > 0 && Number.isFinite(ts) && ts > 0 && age > HEARTBEAT_STALE_MS) {
+				process.stderr.write(`unhealthy: serve heartbeat stale by ${age}ms\n`);
+				return 1;
+			}
+		} catch {}
+		return 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",
@@ -482,21 +514,29 @@ Options:
 			return null;
 		}
 	};
-	const GIT_TTL_MS = 5e3;
-	const gitCache = /* @__PURE__ */ new Map();
-	const gitStatus = async (cwd) => {
-		if (!cwd) return null;
-		const now = Date.now();
-		const hit = gitCache.get(cwd);
-		if (hit && now - hit.at < GIT_TTL_MS) return hit.val;
-		let val = null;
+	const taskCache = /* @__PURE__ */ new Map();
+	const logTasks = async (logFile) => {
+		if (!logFile) return null;
 		try {
-			const proc = Bun.spawn([
-				"git",
-				"status",
-				"--porcelain",
-				"--branch"
-			], {
+			const { size, mtimeMs } = await stat(logFile);
+			const hit = taskCache.get(logFile);
+			if (hit && hit.size === size && hit.mtimeMs === mtimeMs) return hit.tasks;
+			const tasks = await extractTaskCounts(logFile);
+			taskCache.set(logFile, {
+				size,
+				mtimeMs,
+				tasks
+			});
+			return tasks;
+		} catch {
+			return null;
+		}
+	};
+	const GIT_DEBOUNCE_MS = 800;
+	const GIT_SAFETY_MS = 6e4;
+	const runGit = async (args, cwd) => {
+		try {
+			const proc = Bun.spawn(["git", ...args], {
 				cwd,
 				stdout: "pipe",
 				stderr: "ignore",
@@ -504,35 +544,89 @@ Options:
 			});
 			const out = await new Response(proc.stdout).text();
 			await proc.exited;
-			if (proc.exitCode === 0) {
-				const lines = out.split("\n");
-				const h = /^## (.+)$/.exec(lines[0] ?? "")?.[1] ?? "";
-				const unborn = /^No commits yet on (.+)$/.exec(h);
-				const branch = unborn ? unborn[1] : /^(.+?)(?:\.\.\.|\s|$)/.exec(h)?.[1] || null;
-				const ahead = Number(/\bahead (\d+)/.exec(h)?.[1] ?? 0);
-				const behind = Number(/\bbehind (\d+)/.exec(h)?.[1] ?? 0);
-				const changed = lines.slice(1).filter((l) => l.trim().length > 0).length;
-				val = {
-					branch,
-					dirty: changed > 0,
-					changed,
-					ahead,
-					behind
-				};
+			return proc.exitCode === 0 ? out : null;
+		} catch {
+			return null;
+		}
+	};
+	const parseGitStatus = (out) => {
+		const lines = out.split("\n");
+		const h = /^## (.+)$/.exec(lines[0] ?? "")?.[1] ?? "";
+		const unborn = /^No commits yet on (.+)$/.exec(h);
+		const branch = unborn ? unborn[1] : /^(.+?)(?:\.\.\.|\s|$)/.exec(h)?.[1] || null;
+		const ahead = Number(/\bahead (\d+)/.exec(h)?.[1] ?? 0);
+		const behind = Number(/\bbehind (\d+)/.exec(h)?.[1] ?? 0);
+		const changed = lines.slice(1).filter((l) => l.trim().length > 0).length;
+		return {
+			branch,
+			dirty: changed > 0,
+			changed,
+			ahead,
+			behind
+		};
+	};
+	const rootOfCwd = /* @__PURE__ */ new Map();
+	const resolveRoot = async (cwd) => {
+		const cached = rootOfCwd.get(cwd);
+		if (cached !== void 0) return cached;
+		const root = (await runGit(["rev-parse", "--show-toplevel"], cwd) ?? "").trim();
+		rootOfCwd.set(cwd, root);
+		return root;
+	};
+	const repoWatch = /* @__PURE__ */ new Map();
+	const recompute = (root, rw) => {
+		if (rw.timer) return;
+		rw.timer = setTimeout(async () => {
+			rw.timer = null;
+			if (rw.busy) return void recompute(root, rw);
+			rw.busy = true;
+			try {
+				const out = await runGit([
+					"status",
+					"--porcelain",
+					"--branch"
+				], root);
+				if (out != null) rw.val = parseGitStatus(out);
+			} finally {
+				rw.busy = false;
 			}
+		}, GIT_DEBOUNCE_MS);
+	};
+	const ensureRepoWatch = (root) => {
+		const existing = repoWatch.get(root);
+		if (existing) return existing;
+		const rw = {
+			val: null,
+			busy: false,
+			timer: null
+		};
+		repoWatch.set(root, rw);
+		recompute(root, rw);
+		const onChange = (file) => {
+			if (file.includes(".agent-yes") || file.includes("node_modules") || file.endsWith(".lock")) return;
+			recompute(root, rw);
+		};
+		try {
+			watch(root, { recursive: true }, (_e, f) => onChange(String(f ?? "")));
 		} catch {
-			val = null;
+			try {
+				watch(path.join(root, ".git"), (_e, f) => onChange(".git/" + String(f ?? "")));
+			} catch {}
 		}
-		gitCache.set(cwd, {
-			at: now,
-			val
-		});
-		return val;
+		setInterval(() => recompute(root, rw), GIT_SAFETY_MS);
+		return rw;
+	};
+	const gitStatus = async (cwd) => {
+		if (!cwd) return null;
+		const root = await resolveRoot(cwd);
+		if (!root) return null;
+		return ensureRepoWatch(root).val;
 	};
 	const withMeta = async (r) => ({
 		...r,
 		title: await logTitle(r.log_file),
-		git: r.status === "exited" ? null : await gitStatus(r.cwd)
+		git: r.status === "exited" ? null : await gitStatus(r.cwd),
+		tasks: r.status === "exited" ? null : await logTasks(r.log_file)
 	});
 	const apiFetch = async (req) => {
 		if (!checkAuth(req, token)) return new Response("Unauthorized", { status: 401 });
@@ -791,6 +885,46 @@ Options:
 				return new Response(e.message, { status: 404 });
 			}
 		}
+		if (req.method === "POST" && p === "/api/kill") {
+			let body;
+			try {
+				body = await req.json();
+			} catch {
+				return new Response("invalid JSON body", { status: 400 });
+			}
+			const keyword = body.keyword;
+			if (!keyword || typeof keyword !== "string") return new Response("missing keyword", { status: 400 });
+			if (process.platform === "win32") return new Response("force-kill unsupported on a Windows serve", { status: 501 });
+			try {
+				const record = await resolveOne(keyword, defaultOpts({ all: true }));
+				const killed = [];
+				const sig = (target, label) => {
+					if (!target || target <= 1) return;
+					try {
+						process.kill(target, "SIGKILL");
+						killed.push(label);
+					} catch {}
+				};
+				const pgid = await pgidForWrapper(record.wrapper_pid ?? 0);
+				if (pgid && pgid > 1) try {
+					process.kill(-pgid, "SIGKILL");
+					killed.push(`group ${pgid}`);
+				} catch {}
+				sig(record.pid, `pid ${record.pid}`);
+				if (record.wrapper_pid && record.wrapper_pid !== record.pid) sig(record.wrapper_pid, `wrapper ${record.wrapper_pid}`);
+				await updateGlobalPidStatus(record.pid, {
+					status: "exited",
+					exit_reason: "force-killed via console"
+				}).catch(() => {});
+				return Response.json({
+					ok: true,
+					pid: record.pid,
+					killed
+				});
+			} 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]);
@@ -918,7 +1052,7 @@ Options:
 		const webrtcVal = argv.webrtc ?? argv.share;
 		const explicitUrl = typeof webrtcVal === "string" && webrtcVal.startsWith("webrtc://") ? webrtcVal : void 0;
 		try {
-			const { startShare, loadOrCreateShareRoom } = await import("./share-CksllWW-.js");
+			const { startShare, loadOrCreateShareRoom } = await import("./share-YuM6-Q6A.js");
 			const linkFile = path.join(process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes"), ".share-link");
 			const announce = async (room, link, rotated) => {
 				const lead = rotated ? "the room was rejected by signaling (stale generation) — rotated to a fresh link" : "shared over WebRTC — open this link (the token is eaten from the URL on open)";
@@ -945,22 +1079,32 @@ Options:
 			if (!wantHttp) return 1;
 		}
 	}
+	let heartbeat;
+	if (wantWebrtc) {
+		const stamp = () => {
+			try {
+				const tmp = `${heartbeatPath()}.tmp`;
+				writeFileSync(tmp, String(Date.now()));
+				renameSync(tmp, heartbeatPath());
+			} catch {}
+		};
+		stamp();
+		heartbeat = setInterval(stamp, HEARTBEAT_WRITE_MS);
+	}
 	process.stdout.write(`(Ctrl-C to stop)\n`);
+	const shutdown = (resolve) => {
+		if (heartbeat) clearInterval(heartbeat);
+		closeShare?.();
+		server?.stop();
+		resolve();
+	};
 	await new Promise((resolve) => {
-		process.on("SIGINT", () => {
-			closeShare?.();
-			server?.stop();
-			resolve();
-		});
-		process.on("SIGTERM", () => {
-			closeShare?.();
-			server?.stop();
-			resolve();
-		});
+		process.on("SIGINT", () => shutdown(resolve));
+		process.on("SIGTERM", () => shutdown(resolve));
 	});
 	return 0;
 }
 
 //#endregion
 export { cmdServe };
-//# sourceMappingURL=serve-tn7ZetZs.js.map
+//# sourceMappingURL=serve-r_2v9EKc.js.map

package/dist/{setup-dZhgpNse.js → setup-DHa6fX8M.js}

@@ -1,4 +1,4 @@
-import { r as setWorkspaceRoot, t as getWorkspaceRoot } from "./workspaceConfig-XP2NEWmV.js";
+import { r as setWorkspaceRoot, t as getWorkspaceRoot } from "./workspaceConfig-BJO4fzEn.js";
 import { existsSync } from "node:fs";
 import { stdin, stdout } from "node:process";
 import { createInterface } from "node:readline/promises";
@@ -32,7 +32,7 @@ async function cmdSetup(rest) {
 	if (!existsSync(abs)) process.stderr.write(`  note: that directory doesn't exist yet — create it, or agents spawned there will fail\n`);
 	if (noShare) return 0;
 	process.stdout.write(`\nsharing this machine to agent-yes.com…\n`);
-	const { cmdServe } = await import("./serve-tn7ZetZs.js");
+	const { cmdServe } = await import("./serve-r_2v9EKc.js");
 	return cmdServe([
 		"install",
 		"--share",
@@ -42,4 +42,4 @@ async function cmdSetup(rest) {
 
 //#endregion
 export { cmdSetup };
-//# sourceMappingURL=setup-dZhgpNse.js.map
+//# sourceMappingURL=setup-DHa6fX8M.js.map

package/dist/{share-CksllWW-.js → share-YuM6-Q6A.js}

@@ -181,6 +181,13 @@ const SUB = "ay-signal-1";
 const DEFAULT_SIGHOST = "s.agent-yes.com";
 const HOST_HEARTBEAT_MS = 2e4;
 const SIG_REFRESH_MS = 4 * 6e4;
+const MAX_PEER_SETUP_FAILURES = 3;
+const PEER_JOIN_GAP_MS = 300;
+const STARTPEER_TIMEOUT_MS = 1e4;
+const MAX_PEER_JOIN_QUEUE = 50;
+const IDLE_RESTART_UPTIME_MS = 25 * 6e4;
+const HARD_RESTART_UPTIME_MS = 45 * 6e4;
+const IDLE_RESTART_CHECK_MS = 6e4;
 const STUN = [{ urls: "stun:stun.l.google.com:19302" }];
 let iceCache = null;
 async function getIceServers() {
@@ -313,7 +320,7 @@ async function startShare(opts) {
 	if (!v2) throw new Error("refusing to host an unencrypted room — delete ~/.agent-yes/.share-room to rotate to an encrypted link");
 	let S = firstS;
 	const wsScheme = host.startsWith("localhost") || host.startsWith("127.") ? "ws" : "wss";
-	const ui = host === "s.agent-yes.com" ? "https://agent-yes.com" : "http://localhost:7778";
+	const ui = host === "s.agent-yes.com" ? "https://agent-yes.com/w" : "http://localhost:7778/w";
 	const suffix = host === "s.agent-yes.com" ? "" : "@" + host;
 	const mkLink = () => `${ui}/#${room}:${MARKER}${S}${suffix}`;
 	let authToken = await deriveAuthToken(S, room, host);
@@ -342,6 +349,40 @@ async function startShare(opts) {
 	const peers = /* @__PURE__ */ new Map();
 	let closed = false;
 	let currentWs;
+	let peerSetupFailures = 0;
+	const peerJoinQueue = [];
+	let drainingPeerJoins = false;
+	const drainPeerJoins = async () => {
+		if (drainingPeerJoins) return;
+		drainingPeerJoins = true;
+		try {
+			while (!closed && peerJoinQueue.length) {
+				const peerId = peerJoinQueue.shift();
+				const ws = currentWs;
+				if (!ws) continue;
+				try {
+					let timer;
+					const setup = startPeer(ws, peerId);
+					setup.catch(() => {});
+					await Promise.race([setup, new Promise((_, reject) => {
+						timer = setTimeout(() => reject(/* @__PURE__ */ new Error("startPeer timeout")), STARTPEER_TIMEOUT_MS);
+					})]).finally(() => clearTimeout(timer));
+					peerSetupFailures = 0;
+				} catch (err) {
+					peerSetupFailures++;
+					process.stderr.write(`[share] peer setup failed (${peerSetupFailures}/${MAX_PEER_SETUP_FAILURES}): ${err?.message ?? err}\n`);
+					closePeer(peerId);
+					if (peerSetupFailures >= MAX_PEER_SETUP_FAILURES) {
+						process.stderr.write("[share] WebRTC stack wedged after repeated peer-setup failures — exiting so the service manager restarts with a fresh stack\n");
+						process.exit(1);
+					}
+				}
+				if (peerJoinQueue.length) await new Promise((r) => setTimeout(r, PEER_JOIN_GAP_MS));
+			}
+		} finally {
+			drainingPeerJoins = false;
+		}
+	};
 	const connectSignaling = (onReady) => {
 		if (closed) return;
 		const ws = new WebSocket(`${wsScheme}://${host}/${room}`, [SUB]);
@@ -394,8 +435,13 @@ async function startShare(opts) {
 			lastRecv = Date.now();
 			const m = JSON.parse(ev.data);
 			if (m.type === "pong") return;
-			if (m.type === "peer-join") startPeer(ws, m.peer).catch(() => {});
-			else if (m.type === "answer") {
+			if (m.type === "peer-join") {
+				const pid = String(m.peer);
+				if (!peers.has(pid) && !peerJoinQueue.includes(pid) && peerJoinQueue.length < MAX_PEER_JOIN_QUEUE) {
+					peerJoinQueue.push(pid);
+					drainPeerJoins();
+				}
+			} else if (m.type === "answer") {
 				const peer = peers.get(m.from);
 				if (!peer) return;
 				try {
@@ -490,6 +536,16 @@ async function startShare(opts) {
 		};
 		const offer = await pc.createOffer();
 		await pc.setLocalDescription(offer);
+		if (peers.get(peerId) !== peer) {
+			try {
+				peer.pc.close();
+			} catch {}
+			return;
+		}
+		if (ws.readyState !== WebSocket.OPEN) {
+			closePeer(peerId);
+			return;
+		}
 		ws.send(JSON.stringify({
 			type: "offer",
 			to: peerId,
@@ -609,8 +665,26 @@ async function startShare(opts) {
 		}
 	}
 	await new Promise((resolve) => connectSignaling(resolve));
+	const startedAt = Date.now();
+	const proactiveRestart = process.stdout.isTTY ? void 0 : setInterval(() => {
+		if (closed) return;
+		const up = Date.now() - startedAt;
+		if (peers.size === 0 && up > IDLE_RESTART_UPTIME_MS) {
+			process.stderr.write("[share] proactive restart (idle): refreshing the WebRTC stack\n");
+			process.exit(0);
+		} else if (up > HARD_RESTART_UPTIME_MS) {
+			process.stderr.write("[share] proactive restart (max uptime): closing peers, refreshing the WebRTC stack\n");
+			try {
+				close();
+			} finally {
+				setTimeout(() => process.exit(0), 250);
+			}
+		}
+	}, IDLE_RESTART_CHECK_MS);
+	proactiveRestart?.unref?.();
 	const close = () => {
 		closed = true;
+		if (proactiveRestart) clearInterval(proactiveRestart);
 		try {
 			currentWs?.close();
 		} catch {}
@@ -625,4 +699,4 @@ async function startShare(opts) {
 
 //#endregion
 export { loadOrCreateShareRoom, startShare };
-//# sourceMappingURL=share-CksllWW-.js.map
+//# sourceMappingURL=share-YuM6-Q6A.js.map