agent-yes 1.164.0 → 1.166.0

package/dist/{subcommands-XvqBWxtm.js → subcommands-CuuiDKr0.js}

@@ -3,7 +3,7 @@ import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
 import { a as updateGlobalPidStatus, i as readGlobalPids } from "./globalPidIndex-DlmmJlO8.js";
 import { t as loadSharedCliDefaults } from "./configShared-CEyhl0WH.js";
 import { n as isWebrtcSpec } from "./webrtcLink-CBZkZ-LT.js";
-import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-DBCvpp3B.js";
+import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-T6nf0t3K.js";
 import ms from "ms";
 import yargs from "yargs";
 import { appendFile, mkdir, open, readFile, stat, writeFile } from "fs/promises";
@@ -183,6 +183,43 @@ function classifyNeedsInput(lines, cfg) {
 	const end = Math.min(lines.length, last + 6);
 	return { question: lines.slice(start, end).map((l) => l.trim()).filter((l) => l && !isChromeLine(l)).join(" • ").slice(0, 400) };
 }
+const OPTION_LINE = /^[\s❯›>▶◉○●·*\-]*?(\d+)\.\s/;
+/**
+* Parse the selection menu a `needs_input` agent is parked on into a cursor
+* position + the available option numbers, so a caller can compute how far the
+* cursor must move (Down/Up) to reach a target option. Returns null when the
+* screen isn't a menu (delegates that judgement to {@link classifyNeedsInput},
+* so `working` still wins) or no numbered cursor line is found. Pure — the
+* `ay select` action reuses the exact detection `ay ls` renders with.
+*/
+function parseMenu(lines, cfg) {
+	const ni = classifyNeedsInput(lines, cfg);
+	if (!ni) return null;
+	const patterns = cfg.needsInput ?? [];
+	let cursorLine = -1;
+	for (let i = 0; i < lines.length; i++) if (patterns.some((re) => reTest(re, lines[i]))) cursorLine = i;
+	if (cursorLine < 0) return null;
+	const cm = /(\d+)\./.exec(lines[cursorLine]);
+	if (!cm) return null;
+	const cursor = parseInt(cm[1], 10);
+	const start = Math.max(0, cursorLine - 12);
+	const end = Math.min(lines.length, cursorLine + 12);
+	const options = [];
+	for (let i = start; i < end; i++) {
+		const m = OPTION_LINE.exec(lines[i]);
+		if (m) {
+			const v = parseInt(m[1], 10);
+			if (!options.includes(v)) options.push(v);
+		}
+	}
+	if (!options.includes(cursor)) options.push(cursor);
+	options.sort((a, b) => a - b);
+	return {
+		cursor,
+		options,
+		question: ni.question
+	};
+}
 /**
 * True when the rendered screen still shows a "busy" marker (config `working`,
 * e.g. claude's `esc to interrupt`). Paired with a long-quiet log this is the
@@ -500,6 +537,8 @@ const SUBCOMMANDS = new Set([
 	"tail",
 	"head",
 	"send",
+	"key",
+	"select",
 	"spawn",
 	"attach",
 	"stop",
@@ -549,6 +588,8 @@ async function runSubcommand(argv) {
 			case "tail": return await cmdRead(rest, { mode: "tail" });
 			case "head": return await cmdRead(rest, { mode: "head" });
 			case "send": return await cmdSend(rest);
+			case "key": return await cmdKey(rest);
+			case "select": return await cmdSelect(rest);
 			case "spawn": return await cmdSpawn(rest);
 			case "attach": return await cmdAttach(rest);
 			case "stop": return await cmdStop(rest);
@@ -556,19 +597,19 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "serve": {
-				const { cmdServe } = await import("./serve-CMNGOlQ3.js");
+				const { cmdServe } = await import("./serve-BtJDjoPO.js");
 				return cmdServe(rest);
 			}
 			case "setup": {
-				const { cmdSetup } = await import("./setup-NJ4_GFXO.js");
+				const { cmdSetup } = await import("./setup-CK6lH0UM.js");
 				return cmdSetup(rest);
 			}
 			case "schedule": {
-				const { cmdSchedule } = await import("./schedule-mKjjuT1M.js");
+				const { cmdSchedule } = await import("./schedule-BkUFuCvW.js");
 				return cmdSchedule(rest);
 			}
 			case "remote": {
-				const { cmdRemote } = await import("./remotes-DkNuq417.js");
+				const { cmdRemote } = await import("./remotes-ClT1bq16.js");
 				return cmdRemote(rest);
 			}
 			case "reap":
@@ -585,7 +626,7 @@ async function runSubcommand(argv) {
 }
 function cmdHelp(managerCommands = true) {
 	const setupLine = managerCommands ? `  ay setup                            guided setup: pick a workspace, share to agent-yes.com\n` : ``;
-	process.stdout.write("ay - agent-yes CLI\n\nManagement:\n  ay ls [keyword]                     list running agents\n  ay tail [-f] [-n N] <keyword>       last N lines (96), -f to follow\n  ay read <keyword> [page opts]       paginate: --last/--head N, --range A:B,\n                                        --before-line L [--limit N]\n  ay cat <keyword>                    full log\n  ay head <keyword>                   first N lines\n  ay send <keyword> <msg>             send a message\n  ay attach <keyword>                 interactive attach (detach: Ctrl-\\)\n  ay stop <keyword>                   graceful shutdown (/exit for claude/codex)\n  ay exit <keyword> [reason]          graceful shutdown, recording who/why (= 'ay send <kw> exit')\n  ay restart <keyword> [--fresh]      stop (if live) + relaunch resuming the session; --fresh replays the prompt\n  ay status <keyword>                 agent status snapshot\n  ay result <keyword> [--wait]        pull an agent's structured result envelope\n  ay result set '<json>'              (inside an agent) deposit your result envelope\n  ay reap                             kill process groups leaked by dead agents\n\nRemote:\n" + setupLine + "  ay schedule <when> <cli> -- <msg>   run an agent on a schedule (HH:MM or cron)\n  ay serve [--port N]                 start HTTP API server (prints token)\n  ay serve status                     show serve daemon/server status\n  ay remote add <alias> http://<token>@<host>:<port>\n  ay remote ls / rm <alias>           manage saved remotes\n  ay ls   <token>@<host>:<port>       connect inline (no alias needed)\n  ay send <token>@<host>:<port>:<kw> <msg>\n\nRun an agent:\n  ay [claude|codex|gemini|...] [options] -- [prompt]\n  ay claude -- \"fix the bug in auth.ts\"\n  ay claude --help                    full agent-runner options\n\nLabs (examples at https://github.com/snomiao/agent-yes/tree/main/lab):\n  local-role-play/   designer + builder on one machine\n  http-remote/       ay serve remote access demo\n  p2p-pairing/       libp2p P2P  (needs: cargo build --features swarm)\n");
+	process.stdout.write("ay - agent-yes CLI\n\nManagement:\n  ay ls [keyword]                     list running agents\n  ay tail [-f] [-n N] <keyword>       last N lines (96), -f to follow\n  ay read <keyword> [page opts]       paginate: --last/--head N, --range A:B,\n                                        --before-line L [--limit N]\n  ay cat <keyword>                    full log\n  ay head <keyword>                   first N lines\n  ay send <keyword> <msg>             send a message\n  ay key <keyword> <key...>           send raw keystrokes (down/up/enter/esc/…) — drives menus\n  ay select <keyword> <N>             pick option N of a needs_input selection menu\n  ay attach <keyword>                 interactive attach (detach: Ctrl-\\)\n  ay stop <keyword>                   graceful shutdown (/exit for claude/codex)\n  ay exit <keyword> [reason]          graceful shutdown, recording who/why (= 'ay send <kw> exit')\n  ay restart <keyword> [--fresh]      stop (if live) + relaunch resuming the session; --fresh replays the prompt\n  ay status <keyword>                 agent status snapshot\n  ay result <keyword> [--wait]        pull an agent's structured result envelope\n  ay result set '<json>'              (inside an agent) deposit your result envelope\n  ay reap                             kill process groups leaked by dead agents\n\nRemote:\n" + setupLine + "  ay schedule <when> <cli> -- <msg>   run an agent on a schedule (HH:MM or cron)\n  ay serve [--port N]                 start HTTP API server (prints token)\n  ay serve status                     show serve daemon/server status\n  ay remote add <alias> http://<token>@<host>:<port>\n  ay remote ls / rm <alias>           manage saved remotes\n  ay ls   <token>@<host>:<port>       connect inline (no alias needed)\n  ay send <token>@<host>:<port>:<kw> <msg>\n\nRun an agent:\n  ay [claude|codex|gemini|...] [options] -- [prompt]\n  ay claude -- \"fix the bug in auth.ts\"\n  ay claude --help                    full agent-runner options\n\nLabs (examples at https://github.com/snomiao/agent-yes/tree/main/lab):\n  local-role-play/   designer + builder on one machine\n  http-remote/       ay serve remote access demo\n  p2p-pairing/       libp2p P2P  (needs: cargo build --features swarm)\n");
 	return 0;
 }
 function matchKeyword(record, keyword) {
@@ -941,7 +982,7 @@ async function fetchRemoteRecordsRaw(url, token, opts) {
 		let base = url;
 		let bearer = token;
 		if (isWebrtcSpec(url)) {
-			const { startWebrtcBridge } = await import("./webrtcRemote-Ccdzmuc-.js");
+			const { startWebrtcBridge } = await import("./webrtcRemote-GAgF5K45.js");
 			bridge = await startWebrtcBridge(url);
 			base = bridge.baseUrl;
 			bearer = bridge.token;
@@ -1895,6 +1936,71 @@ async function cmdSpawn(rest) {
 		prompt: prompt || void 0
 	});
 }
+/**
+* Shared safety gate for every command that writes to a live agent's stdin
+* (`send`, `key`, `select`): refuse a self-targeting loop, and require that THIS
+* sender actually looked at THIS target recently — an agent is blocked, an
+* interactive human is only warned — unless `force`. Returns the sender context
+* so a caller can reuse it (e.g. `send`'s `[from …]` prefix). Extracted from
+* cmdSend so the action commands enforce the identical guard.
+*/
+async function enforceSendGuards(record, force) {
+	const sender = await senderContext();
+	if (sender.agent && sender.agent.pid === record.pid && !force) throw new Error(`refusing to send to yourself (pid ${record.pid}) — pass --force if you really mean it.`);
+	const last = await lastReadAt(sender.key, record.pid);
+	if (!(last !== null && Date.now() - last <= READ_WINDOW_MS) && !force) {
+		const ago = last === null ? "never read" : `last read ${Math.round((Date.now() - last) / 1e3)}s ago`;
+		const what = `pid ${record.pid} (${record.cli}, ${shortenPath(record.cwd)}) — ${ago}, not within ${READ_WINDOW_MS / 1e3}s`;
+		if (sender.agent) throw new Error(`${what}.\n  Confirm it's the right agent first:  ay tail ${record.pid}\n  then resend, or pass --force to override.`);
+		process.stderr.write(`warning: ${what} — make sure this is the agent you meant (ay tail ${record.pid}).\n`);
+	}
+	return sender;
+}
+const KEY_PACE_MS = 40;
+/**
+* The named-key sequence that moves a menu cursor from `cursor` to option
+* `target` and confirms: |Δ| Downs (target below) or Ups (target above), then
+* Enter. Pure so the arrow arithmetic is unit-tested independent of any live PTY.
+*/
+function menuSelectKeys(cursor, target) {
+	const delta = target - cursor;
+	return [...Array(Math.abs(delta)).fill(delta > 0 ? "down" : "up"), "enter"];
+}
+/** Write each already-encoded key sequence to the FIFO with a pace gap between
+* them (no gap after the last). Raw bytes, no `[from]` framing, no auto-Enter. */
+async function writeKeysPaced(fifoPath, byteSeqs, paceMs) {
+	for (let i = 0; i < byteSeqs.length; i++) {
+		if (byteSeqs[i] === "") continue;
+		await writeToIpc(fifoPath, byteSeqs[i]);
+		if (i < byteSeqs.length - 1 && paceMs > 0) await new Promise((r) => setTimeout(r, paceMs));
+	}
+}
+/**
+* The selection menu a needs_input agent is parked on, or null when it isn't on
+* one. Mirrors extractNeedsInput (same 32 KB tail render + config patterns) but
+* returns the cursor position + option numbers so `ay select` can compute the
+* cursor delta.
+*/
+async function extractMenu(logPath, cli) {
+	const cfg = (await cliDefaults())[cli];
+	if (!cfg?.needsInput?.length) return null;
+	const lines = await renderLogTailLines(logPath, 40);
+	if (!lines) return null;
+	return parseMenu(lines, {
+		needsInput: cfg.needsInput,
+		working: cfg.working
+	});
+}
+/** Poll until the agent is no longer parked on a menu (selection accepted → it
+* resumed / moved on) or the deadline passes. Returns true if it cleared. */
+async function waitForNeedsInputClear(record, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		await new Promise((r) => setTimeout(r, 250));
+		if ((await snapshotStatus(record)).state !== "needs_input") return true;
+	}
+	return false;
+}
 async function cmdSend(rest) {
 	const argv = await yargs(rest).usage("Usage: ay send <keyword> <msg|-> [options]").option("code", {
 		type: "string",
@@ -1941,16 +2047,7 @@ async function cmdSend(rest) {
 		for await (const chunk of process.stdin) chunks.push(chunk);
 		body = Buffer.concat(chunks).toString("utf-8").trimEnd();
 	} else body = rawMessage;
-	const sender = await senderContext();
-	const force = Boolean(argv.force) || process.env.AGENT_YES_FORCE_SEND === "1";
-	if (sender.agent && sender.agent.pid === record.pid && !force) throw new Error(`refusing to send to yourself (pid ${record.pid}) — pass --force if you really mean it.`);
-	const last = await lastReadAt(sender.key, record.pid);
-	if (!(last !== null && Date.now() - last <= READ_WINDOW_MS) && !force) {
-		const ago = last === null ? "never read" : `last read ${Math.round((Date.now() - last) / 1e3)}s ago`;
-		const what = `pid ${record.pid} (${record.cli}, ${shortenPath(record.cwd)}) — ${ago}, not within ${READ_WINDOW_MS / 1e3}s`;
-		if (sender.agent) throw new Error(`${what}.\n  Confirm it's the right agent first:  ay tail ${record.pid}\n  then resend, or pass --force to override.`);
-		process.stderr.write(`warning: ${what} — make sure this is the agent you meant (ay tail ${record.pid}).\n`);
-	}
+	const sender = await enforceSendGuards(record, Boolean(argv.force) || process.env.AGENT_YES_FORCE_SEND === "1");
 	if (isExitRequest(body)) {
 		const reason = sender.agent ? `requested by ${sender.agent.cli} #${sender.agent.pid} @ ${shortenPath(sender.agent.cwd)}` : `requested via 'ay send ${keyword} exit'`;
 		const { strategy } = await gracefulExitAgent(record, reason);
@@ -1973,6 +2070,104 @@ async function cmdSend(rest) {
 	}
 	return 0;
 }
+async function resolveWritableAgent(keyword, opts) {
+	const record = await resolveOne(keyword, opts);
+	if (!record.fifo_file) throw new Error(`pid ${record.pid}: no fifo_file recorded — this agent didn't register a stdin FIFO (an older agent, or one not started with --stdpush). Restarting it (ay restart ${record.pid}) re-registers one.`);
+	return record;
+}
+async function cmdKey(rest) {
+	const argv = await yargs(rest).usage("Usage: ay key <keyword> <key...> [options]\n\nSend raw named keystrokes to a live agent's TUI — no message framing, no\nauto-Enter. Drives selection menus and other interactive prompts that a\nplain `ay send` (text + Enter) can't. Keys are paced so the CLI registers\neach as a discrete event, not a paste.\n\nKeys: up down left right enter esc tab space backspace delete home end\n      pageup pagedown ctrl-c ctrl-d ctrl-y  raw:0xNN\n\nExamples:\n  ay key 1234 down down enter    # move the menu cursor down twice, confirm\n  ay key 1234 esc                # dismiss a menu\n  ay key 1234 raw:0x1b           # a literal ESC byte").option("pace", {
+		type: "number",
+		default: KEY_PACE_MS,
+		description: "ms between keystrokes"
+	}).option("all", {
+		type: "boolean",
+		default: false,
+		description: "Include exited agents"
+	}).option("latest", {
+		type: "boolean",
+		default: false,
+		description: "Use most recent match"
+	}).option("cwd", {
+		type: "string",
+		description: "Restrict to agents under this dir"
+	}).option("force", {
+		type: "boolean",
+		default: false,
+		description: "Skip the recency/self-send guard (also: AGENT_YES_FORCE_SEND=1)"
+	}).help(false).version(false).exitProcess(false).parseAsync();
+	const keyword = argv._[0] !== void 0 ? String(argv._[0]) : void 0;
+	const keyNames = argv._.slice(1).map(String);
+	if (!keyword || keyNames.length === 0) throw new Error("usage: ay key <keyword> <key...>   (e.g. ay key 1234 down down enter)");
+	const byteSeqs = keyNames.map((n) => controlCodeFromName(n.toLowerCase()));
+	const record = await resolveWritableAgent(keyword, {
+		all: argv.all,
+		active: false,
+		json: false,
+		latest: argv.latest,
+		cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
+	});
+	await enforceSendGuards(record, Boolean(argv.force) || process.env.AGENT_YES_FORCE_SEND === "1");
+	await writeKeysPaced(record.fifo_file, byteSeqs, Math.max(0, argv.pace));
+	process.stdout.write(`sent to pid ${record.pid} (${record.cli}): ${keyNames.join(" ")}\n`);
+	return 0;
+}
+async function cmdSelect(rest) {
+	const argv = await yargs(rest).usage("Usage: ay select <keyword> <N> [options]\n\nPick option N of the selection menu a needs_input agent is parked on.\nRe-parses the live menu (the same ❯-cursor detection `ay ls` uses), computes\nhow far the cursor must move, and sends that many Down/Up keys + Enter — so\nit's robust to a pre-highlighted default (never assumes the cursor starts at 1)\nand doesn't rely on numeric hotkeys (arrow-driven menus ignore them).\n\nExamples:\n  ay select 1234 2           # choose option 2\n  ay select 1234 2 --wait    # …and block until the menu clears").option("pace", {
+		type: "number",
+		default: KEY_PACE_MS,
+		description: "ms between keystrokes"
+	}).option("wait", {
+		type: "boolean",
+		default: false,
+		description: "Block until the agent leaves needs_input (or --timeout)"
+	}).option("timeout", {
+		type: "number",
+		default: 10,
+		description: "Seconds to wait with --wait"
+	}).option("all", {
+		type: "boolean",
+		default: false,
+		description: "Include exited agents"
+	}).option("latest", {
+		type: "boolean",
+		default: false,
+		description: "Use most recent match"
+	}).option("cwd", {
+		type: "string",
+		description: "Restrict to agents under this dir"
+	}).option("force", {
+		type: "boolean",
+		default: false,
+		description: "Skip the recency/self-send guard (also: AGENT_YES_FORCE_SEND=1)"
+	}).help(false).version(false).exitProcess(false).parseAsync();
+	const keyword = argv._[0] !== void 0 ? String(argv._[0]) : void 0;
+	const n = Number(argv._[1]);
+	if (!keyword || !Number.isInteger(n) || n < 1) throw new Error("usage: ay select <keyword> <N>   (N = the 1-based option number to choose)");
+	const record = await resolveWritableAgent(keyword, {
+		all: argv.all,
+		active: false,
+		json: false,
+		latest: argv.latest,
+		cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
+	});
+	if (!record.log_file) throw new Error(`pid ${record.pid}: no log_file recorded — can't read the menu to select from.`);
+	await enforceSendGuards(record, Boolean(argv.force) || process.env.AGENT_YES_FORCE_SEND === "1");
+	const menu = await extractMenu(record.log_file, record.cli);
+	if (!menu) throw new Error(`pid ${record.pid} (${record.cli}) is not parked on a selection menu (not needs_input).\n  Check with:  ay status ${record.pid}`);
+	if (menu.options.length > 0 && !menu.options.includes(n)) throw new Error(`option ${n} is out of range — this menu offers ${menu.options.join(", ")}.`);
+	const byteSeqs = menuSelectKeys(menu.cursor, n).map((k) => controlCodeFromName(k));
+	await writeKeysPaced(record.fifo_file, byteSeqs, Math.max(0, argv.pace));
+	const delta = n - menu.cursor;
+	const moved = delta === 0 ? "cursor already there" : `${Math.abs(delta)}× ${delta > 0 ? "down" : "up"}`;
+	process.stdout.write(`pid ${record.pid} (${record.cli}): selected option ${n} (${moved} + enter)\n`);
+	if (argv.wait) {
+		const ok = await waitForNeedsInputClear(record, Math.max(1, argv.timeout) * 1e3);
+		process.stdout.write(ok ? `  menu cleared — selection accepted.\n` : `  still needs_input after ${argv.timeout}s — re-check with 'ay status ${record.pid}'.\n`);
+		return ok ? 0 : 1;
+	}
+	return 0;
+}
 function stopTipForCli(cli, pid) {
 	const cmd = GRACEFUL_EXIT_COMMANDS[cli];
 	if (cmd) return `  tip: ${cli} ignores a single Ctrl+C — try 'ay stop ${pid}' (sends '${cmd}') or double Ctrl+C.\n`;
@@ -2000,12 +2195,27 @@ function controlCodeFromName(name) {
 		case "ctrl\\":
 		case "ctrl-backslash": return "";
 		case "tab": return "	";
+		case "up": return "\x1B[A";
+		case "down": return "\x1B[B";
+		case "right": return "\x1B[C";
+		case "left": return "\x1B[D";
+		case "home": return "\x1B[H";
+		case "end": return "\x1B[F";
+		case "pageup":
+		case "pgup": return "\x1B[5~";
+		case "pagedown":
+		case "pgdn": return "\x1B[6~";
+		case "space": return " ";
+		case "backspace":
+		case "bs": return "";
+		case "delete":
+		case "del": return "\x1B[3~";
 		case "none":
 		case "": return "";
 		default:
 			const m = /^raw:0x([0-9a-f]+)$/i.exec(name);
 			if (m) return String.fromCharCode(parseInt(m[1], 16));
-			throw new Error(`unknown --code=${name}`);
+			throw new Error(`unknown key/code: ${name}`);
 	}
 }
 async function writeToIpc(ipcPath, payload) {
@@ -2794,5 +3004,5 @@ async function cmdResultSet(rest) {
 }
 
 //#endregion
-export { restartHintLines as C, writeToIpc as D, stopTipForCli as E, resolveResumeArgs as S, snapshotStatus as T, readPtysize as _, cursorAbs as a, resolveOne as b, extractTaskCounts as c, isExitRequest as d, isPidAlive as f, readNotes as g, matchKeyword as h, controlCodeFromName as i, finalizedLines as l, listRecords as m, READ_PAGE_DEFAULT as n, deriveLiveStatus as o, isSubcommand as p, cmdHelp as r, extractNeedsInput as s, GRACEFUL_EXIT_COMMANDS as t, isAgentStuck as u, renderRawLog as v, runSubcommand as w, resolveReadWindow as x, renderRawLogLines as y };
-//# sourceMappingURL=subcommands-XvqBWxtm.js.map
+export { writeToIpc as A, resolveReadWindow as C, snapshotStatus as D, runSubcommand as E, stopTipForCli as O, resolveOne as S, restartHintLines as T, menuSelectKeys as _, cursorAbs as a, renderRawLog as b, extractNeedsInput as c, isAgentStuck as d, isExitRequest as f, matchKeyword as g, listRecords as h, controlCodeFromName as i, writeKeysPaced as k, extractTaskCounts as l, isSubcommand as m, READ_PAGE_DEFAULT as n, deriveLiveStatus as o, isPidAlive as p, cmdHelp as r, extractMenu as s, GRACEFUL_EXIT_COMMANDS as t, finalizedLines as u, readNotes as v, resolveResumeArgs as w, renderRawLogLines as x, readPtysize as y };
+//# sourceMappingURL=subcommands-CuuiDKr0.js.map

package/dist/subcommands-lQ3cyReU.js

@@ -0,0 +1,9 @@
+import "./logger-CDIsZ-Pp.js";
+import "./globalPidIndex-DlmmJlO8.js";
+import "./configShared-CEyhl0WH.js";
+import "./e2e-Bfw7qL9O.js";
+import "./webrtcLink-CBZkZ-LT.js";
+import "./remotes-T6nf0t3K.js";
+import { A as writeToIpc, C as resolveReadWindow, D as snapshotStatus, E as runSubcommand, O as stopTipForCli, S as resolveOne, T as restartHintLines, _ as menuSelectKeys, a as cursorAbs, b as renderRawLog, c as extractNeedsInput, d as isAgentStuck, f as isExitRequest, g as matchKeyword, h as listRecords, i as controlCodeFromName, k as writeKeysPaced, l as extractTaskCounts, m as isSubcommand, n as READ_PAGE_DEFAULT, o as deriveLiveStatus, p as isPidAlive, r as cmdHelp, s as extractMenu, t as GRACEFUL_EXIT_COMMANDS, u as finalizedLines, v as readNotes, w as resolveResumeArgs, x as renderRawLogLines, y as readPtysize } from "./subcommands-CuuiDKr0.js";
+
+export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{tray-BMzpUSfa.js → tray-CZarCA2Q.js}

@@ -187,4 +187,4 @@ async function startTray() {
 
 //#endregion
 export { ensureTray, startTray };
-//# sourceMappingURL=tray-BMzpUSfa.js.map
+//# sourceMappingURL=tray-CZarCA2Q.js.map

package/dist/{ts-Bjfd09LQ.js → ts-YJSzO6hM.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-DiNfz39j.js";
+import { r as getInstalledPackage } from "./versionChecker-DwkNjj7n.js";
 import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-V4qvXgAw.js";
 import { t as PidStore } from "./pidStore-BfoBWUjc.js";
@@ -1803,4 +1803,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-Bjfd09LQ.js.map
+//# sourceMappingURL=ts-YJSzO6hM.js.map

package/dist/{versionChecker-DiNfz39j.js → versionChecker-DwkNjj7n.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "agent-yes";
-var version = "1.164.0";
+var version = "1.166.0";
 
 //#endregion
 //#region ts/versionChecker.ts
@@ -215,4 +215,4 @@ async function displayVersion() {
 
 //#endregion
 export { versionString as i, displayVersion as n, getInstalledPackage as r, checkAndAutoUpdate as t };
-//# sourceMappingURL=versionChecker-DiNfz39j.js.map
+//# sourceMappingURL=versionChecker-DwkNjj7n.js.map

package/dist/{webrtcRemote-Ccdzmuc-.js → webrtcRemote-GAgF5K45.js}

@@ -256,4 +256,4 @@ async function startWebrtcBridge(link) {
 
 //#endregion
 export { startWebrtcBridge };
-//# sourceMappingURL=webrtcRemote-Ccdzmuc-.js.map
+//# sourceMappingURL=webrtcRemote-GAgF5K45.js.map

package/dist/{workspaceConfig-B0Q9-q2B.js → workspaceConfig-D3OH7and.js}

@@ -96,6 +96,45 @@ function getSpawnHook() {
 function hasSpawnHook() {
 	return getSpawnHook() !== null;
 }
+/**
+* Cap on concurrently-live agents admitted via `/api/spawn`. Env
+* `AGENT_YES_MAX_AGENTS` overrides the config `maxAgents`. A non-positive,
+* missing, or unparseable value means **unlimited** (returns undefined), which
+* preserves the historical no-cap behavior. Exists to stop an unbounded fan-out
+* of agents from exhausting host RAM and tripping the OOM-killer.
+*/
+function getMaxAgents() {
+	const raw = process.env.AGENT_YES_MAX_AGENTS?.trim();
+	const n = raw !== void 0 && raw !== "" ? Number(raw) : readConfig().maxAgents;
+	const v = typeof n === "number" && Number.isFinite(n) ? Math.floor(n) : NaN;
+	return v > 0 ? v : void 0;
+}
+/**
+* Minimum system MemAvailable (MB) required to admit a new spawn. Env
+* `AGENT_YES_MIN_FREE_MB` overrides config `minFreeMb`. Non-positive/unset =
+* no floor (undefined). Complements {@link getMaxAgents}: a count cap alone
+* can't stop OOM when individual agents are large, so we also refuse to spawn
+* when free memory is already low.
+*/
+function getMinFreeMb() {
+	const raw = process.env.AGENT_YES_MIN_FREE_MB?.trim();
+	const n = raw !== void 0 && raw !== "" ? Number(raw) : readConfig().minFreeMb;
+	const v = typeof n === "number" && Number.isFinite(n) ? Math.floor(n) : NaN;
+	return v > 0 ? v : void 0;
+}
+/**
+* Max time (ms) a CLI spawn blocks waiting for capacity before failing open.
+* Env `AGENT_YES_SPAWN_WAIT_MS` overrides config `spawnWaitMs`. A non-negative
+* finite value is used as-is (0 = don't wait, check once then proceed); anything
+* missing/garbage falls back to the 10-minute default. Bounded fail-open is
+* deliberate: recursive spawns must never deadlock permanently on each other.
+*/
+function getSpawnWaitMs() {
+	const DEFAULT = 6e5;
+	const raw = process.env.AGENT_YES_SPAWN_WAIT_MS?.trim();
+	const n = raw !== void 0 && raw !== "" ? Number(raw) : readConfig().spawnWaitMs;
+	return typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.floor(n) : DEFAULT;
+}
 /** Persist the workspace root, tilde-expanded and resolved to an absolute path. */
 function setWorkspaceRoot(dir) {
 	const abs = path.resolve(expandTilde(dir));
@@ -122,5 +161,5 @@ function resolveSpawnCwd(input) {
 }
 
 //#endregion
-export { isProvisionAllowed as a, hasSpawnHook as i, getSpawnHook as n, resolveSpawnCwd as o, getWorkspaceRoot as r, setWorkspaceRoot as s, getProvisionRoot as t };
-//# sourceMappingURL=workspaceConfig-B0Q9-q2B.js.map
+export { getSpawnWaitMs as a, isProvisionAllowed as c, getSpawnHook as i, resolveSpawnCwd as l, getMinFreeMb as n, getWorkspaceRoot as o, getProvisionRoot as r, hasSpawnHook as s, getMaxAgents as t, setWorkspaceRoot as u };
+//# sourceMappingURL=workspaceConfig-D3OH7and.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.164.0",
+  "version": "1.166.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

package/ts/cli.ts

@@ -62,6 +62,27 @@ if (config.tray) {
   ensureTray(); // fire-and-forget, don't await
 }
 
+// Spawn admission control — applies to a REAL agent launch only (subcommands,
+// --version, --tray already handled/exited above; --append-prompt / --version
+// below are not launches). Sits BEFORE the --rust dispatch so it gates BOTH the
+// Rust and the TypeScript runtimes. Blocks with φ-backoff until there's capacity
+// (or fails open after a timeout) so a burst of recursive `ay <cli>` spawns gets
+// spaced out instead of storming the host into the OOM-killer. No-op (instant)
+// unless maxAgents/minFreeMb is configured — see ts/spawnGate.ts.
+if (!config.showVersion && !config.appendPrompt && !config.tray) {
+  const { waitForSpawnCapacity } = await import("./spawnGate.ts");
+  await waitForSpawnCapacity({
+    onWait: (reason, waitedMs) => {
+      if (config.verbose || waitedMs === 0)
+        console.error(`[agent-yes] spawn gate: ${reason} — waiting…`);
+    },
+    onProceedAnyway: (reason, waitedMs) =>
+      console.error(
+        `[agent-yes] spawn gate: ${reason} — waited ${Math.round(waitedMs / 1000)}s, proceeding anyway`,
+      ),
+  });
+}
+
 // Handle --rust: spawn the Rust binary instead, fall back to TypeScript if unavailable
 if (config.useRust) {
   let rustBinary: string | undefined;

package/ts/needsInput.spec.ts

@@ -1,5 +1,5 @@
 import { expect, test } from "vitest";
-import { classifyNeedsInput, isWorkingScreen } from "./needsInput.ts";
+import { classifyNeedsInput, isWorkingScreen, parseMenu } from "./needsInput.ts";
 import { loadSharedCliDefaults } from "./configShared.ts";
 
 // Use the REAL shipped claude/codex patterns so the test guards the actual config.
@@ -72,3 +72,44 @@ test("detects a codex selection menu (› cursor)", () => {
 test("no patterns configured → always null", () => {
   expect(classifyNeedsInput(["❯ 1. anything"], { needsInput: [], working: [] })).toBeNull();
 });
+
+test("parseMenu: cursor on option 1, all options collected (for ay select)", () => {
+  const screen = [
+    "Which auth method should we use?",
+    "",
+    "❯ 1. Session tokens",
+    "  2. JWT",
+    "  3. OAuth",
+    "",
+    "? for shortcuts",
+  ];
+  const menu = parseMenu(screen, claude);
+  expect(menu).not.toBeNull();
+  expect(menu!.cursor).toBe(1);
+  expect(menu!.options).toEqual([1, 2, 3]);
+});
+
+test("parseMenu: reads a pre-highlighted non-first default (cursor delta, not blind N-1)", () => {
+  const screen = ["Proceed?", "  1. Yes", "❯ 2. No, ask again", "  3. Cancel"];
+  const menu = parseMenu(screen, claude);
+  expect(menu!.cursor).toBe(2);
+  expect(menu!.options).toEqual([1, 2, 3]);
+});
+
+test("parseMenu: codex › cursor", () => {
+  const menu = parseMenu(["Pick a branch", "  1. main", "› 2. develop"], codex);
+  expect(menu!.cursor).toBe(2);
+  expect(menu!.options).toEqual([1, 2]);
+});
+
+test("parseMenu: null when not on a menu (idle prompt / working)", () => {
+  expect(parseMenu(['❯ Try "fix the bug"', "? for shortcuts"], claude)).toBeNull();
+  expect(parseMenu(["❯ 1. Session tokens", "✻ Working… (esc to interrupt)"], claude)).toBeNull();
+});
+
+test("parseMenu: a 'N.M' version in an option label isn't mistaken for another option", () => {
+  const screen = ["Cleanup?", "❯ 1. Delete 3.5GB of cache", "  2. Keep"];
+  const menu = parseMenu(screen, claude);
+  expect(menu!.cursor).toBe(1);
+  expect(menu!.options).toEqual([1, 2]);
+});

package/ts/needsInput.ts

@@ -67,6 +67,60 @@ export function classifyNeedsInput(
   return { question: block.join(" • ").slice(0, 400) };
 }
 
+export interface MenuState {
+  /** The 1-based option number the menu cursor (❯/›/>) currently sits on. */
+  cursor: number;
+  /** Every visible option number, ascending — for range-checking a requested N. */
+  options: number[];
+  /** Same compact menu rendering as {@link classifyNeedsInput}. */
+  question: string;
+}
+
+// An option row: an optional cursor glyph / bullet, then "N. " (the trailing
+// space rejects version-like "3.5GB" that isn't a menu option).
+const OPTION_LINE = /^[\s❯›>▶◉○●·*\-]*?(\d+)\.\s/;
+
+/**
+ * Parse the selection menu a `needs_input` agent is parked on into a cursor
+ * position + the available option numbers, so a caller can compute how far the
+ * cursor must move (Down/Up) to reach a target option. Returns null when the
+ * screen isn't a menu (delegates that judgement to {@link classifyNeedsInput},
+ * so `working` still wins) or no numbered cursor line is found. Pure — the
+ * `ay select` action reuses the exact detection `ay ls` renders with.
+ */
+export function parseMenu(
+  lines: string[],
+  cfg: { needsInput?: RegExp[]; working?: RegExp[] },
+): MenuState | null {
+  const ni = classifyNeedsInput(lines, cfg);
+  if (!ni) return null;
+  const patterns = cfg.needsInput ?? [];
+  // The cursor line is the last one carrying a needsInput match (matches how
+  // classifyNeedsInput anchors its question window).
+  let cursorLine = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (patterns.some((re) => reTest(re, lines[i]!))) cursorLine = i;
+  }
+  if (cursorLine < 0) return null;
+  const cm = /(\d+)\./.exec(lines[cursorLine]!);
+  if (!cm) return null;
+  const cursor = parseInt(cm[1]!, 10);
+  // Gather option numbers from the rows around the cursor (a menu is contiguous).
+  const start = Math.max(0, cursorLine - 12);
+  const end = Math.min(lines.length, cursorLine + 12);
+  const options: number[] = [];
+  for (let i = start; i < end; i++) {
+    const m = OPTION_LINE.exec(lines[i]!);
+    if (m) {
+      const v = parseInt(m[1]!, 10);
+      if (!options.includes(v)) options.push(v);
+    }
+  }
+  if (!options.includes(cursor)) options.push(cursor);
+  options.sort((a, b) => a - b);
+  return { cursor, options, question: ni.question };
+}
+
 /**
  * True when the rendered screen still shows a "busy" marker (config `working`,
  * e.g. claude's `esc to interrupt`). Paired with a long-quiet log this is the

package/ts/serve.ts

@@ -21,6 +21,7 @@ import {
   type CommonOpts,
 } from "./subcommands.ts";
 import { updateGlobalPidStatus } from "./globalPidIndex.ts";
+import { spawnRejectionReason } from "./spawnGate.ts";
 import { pgidForWrapper } from "./reaper.ts";
 import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
 import { getInstalledPackage } from "./versionChecker.ts";
@@ -1705,6 +1706,13 @@ export async function cmdServe(rest: string[]): Promise<number> {
         return new Response(`unsupported cli: ${cli}`, { status: 400 });
       const prompt = String(body.prompt ?? "");
 
+      // Admission control BEFORE any provisioning (clone/worktree) so a capped
+      // request fails fast without doing expensive work. Enforces the optional
+      // concurrency cap + memory floor that keep a fan-out of agents from
+      // driving the host into the OOM-killer. 429 = back-pressure, retry later.
+      const reject = await spawnRejectionReason();
+      if (reject) return new Response(reject, { status: 429 });
+
       // Resolve the working directory. A `from` source is provisioned (clone /
       // worktree) through codehost/provision; a plain `cwd` is resolved to the
       // workspace root and mkdir-p'd so a missing dir no longer ENOENTs.