agent-yes 1.84.0 → 1.86.0

package/dist/{subcommands-DjO8lthH.js → subcommands-BpGEGOQM.js}

@@ -1,5 +1,6 @@
-import "./logger-B9h0djqx.js";
 import { r as readGlobalPids } from "./globalPidIndex-Cr-g75QF.js";
+import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-CFrho898.js";
+import yargs from "yargs";
 import { appendFile, mkdir, open, readFile, stat, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
@@ -125,7 +126,9 @@ const SUBCOMMANDS = new Set([
 	"head",
 	"send",
 	"restart",
-	"note"
+	"note",
+	"serve",
+	"remote"
 ]);
 const IDLE_THRESHOLD_MS = 60 * 1e3;
 function isSubcommand(name) {
@@ -152,6 +155,14 @@ async function runSubcommand(argv) {
 			case "send": return await cmdSend(rest);
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
+			case "serve": {
+				const { cmdServe } = await import("./serve-D0NnTXRD.js");
+				return cmdServe(rest);
+			}
+			case "remote": {
+				const { cmdRemote } = await import("./remotes-kfUzk-JT.js");
+				return cmdRemote(rest);
+			}
 			default: return null;
 		}
 	} catch (err) {
@@ -160,50 +171,6 @@ async function runSubcommand(argv) {
 		return 1;
 	}
 }
-function parseArgs(rest) {
-	const flags = {};
-	const positional = [];
-	for (let i = 0; i < rest.length; i++) {
-		const arg = rest[i];
-		if (arg.startsWith("--")) {
-			const eq = arg.indexOf("=");
-			if (eq >= 0) flags[arg.slice(2, eq)] = arg.slice(eq + 1);
-			else {
-				const key = arg.slice(2);
-				const next = rest[i + 1];
-				if ([
-					"all",
-					"active",
-					"follow",
-					"json",
-					"latest",
-					"watch"
-				].includes(key) || !next || next.startsWith("-")) flags[key] = true;
-				else {
-					flags[key] = next;
-					i++;
-				}
-			}
-		} else if (arg.startsWith("-") && arg.length > 1) if (arg === "-n") {
-			flags["n"] = rest[i + 1] ?? "";
-			i++;
-		} else flags[arg.slice(1)] = true;
-		else positional.push(arg);
-	}
-	return {
-		flags,
-		positional
-	};
-}
-function commonOpts(flags) {
-	return {
-		all: !!flags.all,
-		active: !!flags.active,
-		cwdScope: typeof flags.cwd === "string" ? path.resolve(flags.cwd) : flags.cwd === true ? process.cwd() : null,
-		latest: !!flags.latest,
-		json: !!flags.json
-	};
-}
 function matchKeyword(record, keyword) {
 	if (!keyword) return true;
 	const kw = keyword.toLowerCase();
@@ -242,10 +209,309 @@ async function resolveOne(keyword, opts) {
 	const lines = matches.slice(0, 10).map((r) => `  ${r.pid}  ${r.cli}  ${r.cwd}`).join("\n");
 	throw new Error(`keyword "${keyword}" matched ${matches.length} agents — disambiguate by pid or pass --latest:\n${lines}`);
 }
+async function remoteGet(remote, pathname) {
+	return fetch(`${remote.url}${pathname}`, { headers: { Authorization: `Bearer ${remote.token}` } });
+}
+async function remotePost(remote, pathname, body) {
+	return fetch(`${remote.url}${pathname}`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${remote.token}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(body)
+	});
+}
+async function runRemoteLs(remote, opts) {
+	const params = new URLSearchParams();
+	if (remote.keyword) params.set("keyword", remote.keyword);
+	if (opts.all) params.set("all", "1");
+	if (opts.active) params.set("active", "1");
+	const res = await remoteGet(remote, `/api/ls?${params}`);
+	if (!res.ok) {
+		process.stderr.write(`remote error ${res.status}: ${await res.text()}\n`);
+		return 1;
+	}
+	const records = await res.json();
+	if (records.length === 0) {
+		process.stderr.write(remote.keyword ? `no agents matched "${remote.keyword}" on ${remote.url}\n` : `no running agents on ${remote.url}\n`);
+		return 0;
+	}
+	process.stderr.write(`[remote ${remote.url}]\n`);
+	const termWidth = process.stdout.columns ?? 120;
+	const widths = {
+		pid: Math.max(3, ...records.map((r) => String(r.pid).length)),
+		cli: Math.max(3, ...records.map((r) => String(r.cli).length)),
+		status: Math.max(6, ...records.map((r) => String(r.status).length)),
+		cwd: Math.max(3, ...records.map((r) => String(r.cwd).length))
+	};
+	const fixedWidth = widths.pid + widths.cli + widths.status + widths.cwd + 8;
+	const promptBudget = Math.max(20, termWidth - fixedWidth - 1);
+	const header = [
+		"PID".padEnd(widths.pid),
+		"CLI".padEnd(widths.cli),
+		"STATUS".padEnd(widths.status),
+		"CWD".padEnd(widths.cwd),
+		"PROMPT"
+	].join("  ") + "\n";
+	process.stdout.write(header);
+	for (const r of records) {
+		const label = r.prompt ? truncate(`→ ${r.prompt}`, promptBudget) : "";
+		process.stdout.write([
+			String(r.pid).padEnd(widths.pid),
+			String(r.cli).padEnd(widths.cli),
+			String(r.status).padEnd(widths.status),
+			String(r.cwd).padEnd(widths.cwd),
+			label
+		].join("  ") + "\n");
+	}
+	return 0;
+}
+async function runRemoteRead(remote, mode, follow, n, reconnectTimeoutMs = 12e4) {
+	const keyword = remote.keyword ?? "";
+	if (!keyword) {
+		process.stderr.write("remote tail/cat/head requires a keyword (e.g. token@host:port:keyword)\n");
+		return 1;
+	}
+	if (mode === "tail" && follow) {
+		const ac = new AbortController();
+		process.on("SIGINT", () => ac.abort());
+		const deadline = Date.now() + reconnectTimeoutMs;
+		let delay = 1e3;
+		let attempt = 0;
+		process.stderr.write(`[remote ${remote.url}  ${keyword}]\nfollowing... (Ctrl-C to stop, timeout: ${Math.round(reconnectTimeoutMs / 1e3)}s)\n`);
+		while (!ac.signal.aborted) try {
+			const res = await fetch(`${remote.url}/api/tail/${encodeURIComponent(keyword)}`, {
+				headers: {
+					Authorization: `Bearer ${remote.token}`,
+					Accept: "text/event-stream"
+				},
+				signal: ac.signal
+			});
+			if (!res.ok) {
+				if (res.status === 401 || res.status === 404) {
+					process.stderr.write(`remote error ${res.status}: ${await res.text()}\n`);
+					return 1;
+				}
+				throw new Error(`HTTP ${res.status}`);
+			}
+			if (attempt > 0) process.stderr.write("remote: reconnected\n");
+			delay = 1e3;
+			const reader = res.body.getReader();
+			const dec = new TextDecoder();
+			let buf = "";
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				buf += dec.decode(value, { stream: true });
+				const lines = buf.split("\n");
+				buf = lines.pop() ?? "";
+				for (const line of lines) {
+					if (!line.startsWith("data: ")) continue;
+					try {
+						const text = JSON.parse(line.slice(6));
+						process.stdout.write(text);
+						if (!text.endsWith("\n")) process.stdout.write("\n");
+					} catch {}
+				}
+			}
+			break;
+		} catch (e) {
+			if (e.name === "AbortError" || ac.signal.aborted) return 0;
+			if (Date.now() >= deadline) {
+				process.stderr.write(`remote: timeout after ${Math.round(reconnectTimeoutMs / 1e3)}s, giving up\n`);
+				return 1;
+			}
+			process.stderr.write(`remote: disconnected (${e.message}), retrying in ${delay / 1e3}s…\n`);
+			await new Promise((resolve, reject) => {
+				const t = setTimeout(resolve, delay);
+				ac.signal.addEventListener("abort", () => {
+					clearTimeout(t);
+					reject(/* @__PURE__ */ new Error("abort"));
+				});
+			}).catch(() => {});
+			if (ac.signal.aborted) return 0;
+			delay = Math.min(delay * 2, 3e4);
+			attempt++;
+		}
+		return 0;
+	}
+	const params = new URLSearchParams({
+		mode,
+		n: String(n)
+	});
+	const res = await remoteGet(remote, `/api/read/${encodeURIComponent(keyword)}?${params}`);
+	if (!res.ok) {
+		process.stderr.write(`remote error ${res.status}: ${await res.text()}\n`);
+		return 1;
+	}
+	const text = await res.text();
+	process.stderr.write(`[remote ${remote.url}  ${keyword}]\n`);
+	process.stdout.write(text);
+	if (!text.endsWith("\n")) process.stdout.write("\n");
+	return 0;
+}
+async function runRemoteSend(remote, msg, code) {
+	const keyword = remote.keyword ?? "";
+	if (!keyword) {
+		process.stderr.write("remote send requires a keyword (e.g. token@host:port:keyword)\n");
+		return 1;
+	}
+	const res = await remotePost(remote, "/api/send", {
+		keyword,
+		msg,
+		code
+	});
+	if (!res.ok) {
+		process.stderr.write(`remote error ${res.status}: ${await res.text()}\n`);
+		return 1;
+	}
+	const data = await res.json();
+	process.stdout.write(`sent to remote pid ${data.pid} (${remote.url}  ${keyword})\n`);
+	return 0;
+}
+async function runRemoteStatus(remote) {
+	const keyword = remote.keyword ?? "";
+	if (!keyword) {
+		process.stderr.write("remote status requires a keyword (e.g. token@host:port:keyword)\n");
+		return 1;
+	}
+	const res = await remoteGet(remote, `/api/status/${encodeURIComponent(keyword)}`);
+	if (!res.ok) {
+		process.stderr.write(`remote error ${res.status}: ${await res.text()}\n`);
+		return 1;
+	}
+	process.stdout.write(JSON.stringify(await res.json(), null, 2) + "\n");
+	return 0;
+}
+async function fetchRemoteRecordsRaw(url, token, opts) {
+	const params = new URLSearchParams();
+	if (opts.all) params.set("all", "1");
+	if (opts.active) params.set("active", "1");
+	if (opts.keyword) params.set("keyword", opts.keyword);
+	try {
+		const res = await fetch(`${url}/api/ls?${params}`, {
+			headers: { Authorization: `Bearer ${token}` },
+			signal: AbortSignal.timeout(5e3)
+		});
+		if (!res.ok) return [];
+		return await res.json();
+	} catch {
+		return [];
+	}
+}
+async function runAllRemotesLs(opts) {
+	const remotes = await readRemotes();
+	const localOpts = {
+		all: opts.all,
+		active: opts.active,
+		json: true,
+		latest: false,
+		cwdScope: null
+	};
+	const [localResult, ...remoteResults] = await Promise.allSettled([listRecords(opts.keyword, localOpts).then((recs) => ({
+		host: "local",
+		records: recs
+	})), ...Array.from(remotes.entries()).map(([alias, cfg]) => fetchRemoteRecordsRaw(cfg.url, cfg.token, opts).then((records) => ({
+		host: alias,
+		records
+	})))]);
+	const rows = [];
+	if (localResult.status === "fulfilled") for (const r of localResult.value.records) rows.push({
+		host: "local",
+		rec: r
+	});
+	for (const res of remoteResults) if (res.status === "fulfilled") for (const r of res.value.records) rows.push({
+		host: res.value.host,
+		rec: r
+	});
+	if (rows.length === 0) {
+		process.stderr.write("no running agents\n");
+		return 0;
+	}
+	const termWidth = process.stdout.columns ?? 120;
+	const hostW = Math.max(4, ...rows.map((r) => r.host.length));
+	const pidW = Math.max(3, ...rows.map((r) => String(r.rec.pid).length));
+	const cliW = Math.max(3, ...rows.map((r) => String(r.rec.cli).length));
+	const statusW = Math.max(6, ...rows.map((r) => String(r.rec.status).length));
+	const cwdW = Math.max(3, ...rows.map((r) => shortenPath(String(r.rec.cwd)).length));
+	const promptBudget = Math.max(20, termWidth - hostW - pidW - cliW - statusW - cwdW - 10 - 1);
+	process.stdout.write([
+		"HOST".padEnd(hostW),
+		"PID".padEnd(pidW),
+		"CLI".padEnd(cliW),
+		"STATUS".padEnd(statusW),
+		"CWD".padEnd(cwdW),
+		"PROMPT"
+	].join("  ") + "\n");
+	for (const { host, rec } of rows) {
+		const label = rec.prompt ? truncate(`→ ${rec.prompt}`, promptBudget) : "";
+		process.stdout.write([
+			host.padEnd(hostW),
+			String(rec.pid).padEnd(pidW),
+			String(rec.cli).padEnd(cliW),
+			String(rec.status).padEnd(statusW),
+			shortenPath(String(rec.cwd)).padEnd(cwdW),
+			label
+		].join("  ") + "\n");
+	}
+	return 0;
+}
 async function cmdLs(rest) {
-	const { flags, positional } = parseArgs(rest);
-	const opts = commonOpts(flags);
-	const keyword = positional[0];
+	const y = yargs(rest).usage("Usage: ay ls [keyword] [options]\n       ay list [keyword] [options]\n       ay ps   [keyword] [options]\n\nList running agents. Optionally filter by keyword (pid, cwd substring, or prompt substring).").option("all", {
+		type: "boolean",
+		default: false,
+		description: "Show all agents including exited ones"
+	}).option("active", {
+		type: "boolean",
+		default: false,
+		description: "Only show agents with an alive process"
+	}).option("json", {
+		type: "boolean",
+		default: false,
+		description: "Output as JSON array"
+	}).option("latest", {
+		type: "boolean",
+		default: false,
+		description: "Show only the most recent agent"
+	}).option("cwd", {
+		type: "string",
+		description: "Restrict to agents whose cwd starts with dir"
+	}).option("all-remotes", {
+		type: "boolean",
+		default: false,
+		description: "Include agents from all configured remotes (remotes.yaml)"
+	}).option("help", {
+		alias: "h",
+		type: "boolean",
+		default: false,
+		description: "Show this help"
+	}).example("ay ls", "list running agents").example("ay ls --all-remotes", "include all configured remote machines").example("ay ls --all", "include exited agents").example("ay ls --json", "machine-readable output").example("ay ls symval", "filter by cwd/prompt keyword").help(false).version(false).exitProcess(false);
+	const argv = await y.parseAsync();
+	if (argv.help || argv.h) {
+		process.stdout.write(await y.getHelp() + "\n");
+		return 0;
+	}
+	if (argv["all-remotes"]) return runAllRemotesLs({
+		all: argv.all,
+		active: argv.active,
+		keyword: argv._[0] !== void 0 ? String(argv._[0]) : void 0
+	});
+	const keyword = argv._[0] !== void 0 ? String(argv._[0]) : void 0;
+	if (keyword) {
+		const remote = await resolveRemoteSpec(keyword);
+		if (remote) return runRemoteLs(remote, {
+			all: argv.all,
+			active: argv.active
+		});
+	}
+	const opts = {
+		all: argv.all,
+		active: argv.active,
+		json: argv.json,
+		latest: argv.latest,
+		cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
+	};
 	const records = await listRecords(keyword, opts);
 	if (opts.json) {
 		process.stdout.write(JSON.stringify(records, null, 2) + "\n");
@@ -349,11 +615,47 @@ function truncate(s, n) {
 	return s.slice(0, n - 1) + "…";
 }
 async function cmdRead(rest, { mode }) {
-	const { flags, positional } = parseArgs(rest);
-	const opts = commonOpts(flags);
-	const keyword = positional[0];
-	const follow = !!(flags.f || flags.follow);
-	const nFlag = typeof flags.n === "string" ? Number(flags.n) : void 0;
+	const argv = await yargs(rest).usage("Usage: ay read/cat/tail/head <keyword> [options]").option("follow", {
+		alias: "f",
+		type: "boolean",
+		default: false,
+		description: "Follow log output (Ctrl-C to stop)"
+	}).option("n", {
+		type: "number",
+		description: "Number of lines (default: 96 for tail/head)"
+	}).option("all", {
+		type: "boolean",
+		default: false,
+		description: "Include exited agents"
+	}).option("latest", {
+		type: "boolean",
+		default: false,
+		description: "Use most recent match when multiple match"
+	}).option("cwd", {
+		type: "string",
+		description: "Restrict to agents under this dir"
+	}).option("reconnect-timeout", {
+		type: "number",
+		default: 120,
+		description: "Seconds before giving up reconnecting remote SSE (default: 120)"
+	}).help(false).version(false).exitProcess(false).parseAsync();
+	const opts = {
+		all: argv.all,
+		active: false,
+		json: false,
+		latest: argv.latest,
+		cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
+	};
+	const keyword = argv._[0] !== void 0 ? String(argv._[0]) : void 0;
+	if (keyword) {
+		const remote = await resolveRemoteSpec(keyword);
+		const nFlag2 = argv.n;
+		const n2 = nFlag2 !== void 0 && Number.isFinite(nFlag2) && nFlag2 > 0 ? Math.floor(nFlag2) : mode === "cat" ? 0 : 96;
+		const reconnectTimeoutMs = (argv["reconnect-timeout"] ?? 120) * 1e3;
+		if (remote) return runRemoteRead(remote, mode, argv.follow, n2, reconnectTimeoutMs);
+	}
+	const follow = argv.follow;
+	const nFlag = argv.n;
 	const n = nFlag !== void 0 && Number.isFinite(nFlag) && nFlag > 0 ? Math.floor(nFlag) : mode === "cat" ? 0 : 96;
 	const record = await resolveOne(keyword, opts);
 	const logPath = record.log_file;
@@ -512,12 +814,38 @@ function extractActivityFromLines(lines) {
 	return null;
 }
 async function cmdSend(rest) {
-	const { flags, positional } = parseArgs(rest);
-	const opts = commonOpts(flags);
-	const keyword = positional[0];
-	const rawMessage = positional.slice(1).join(" ");
+	const argv = await yargs(rest).usage("Usage: ay send <keyword> <msg|-> [options]").option("code", {
+		type: "string",
+		default: "enter",
+		description: "Trailing control code (enter|esc|ctrl-c|ctrl-y|tab|none)"
+	}).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"
+	}).help(false).version(false).exitProcess(false).parseAsync();
+	const opts = {
+		all: argv.all,
+		active: false,
+		json: false,
+		latest: argv.latest,
+		cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
+	};
+	const keyword = argv._[0] !== void 0 ? String(argv._[0]) : void 0;
+	const rawMessage = argv._.slice(1).map(String).join(" ");
 	if (!keyword) throw new Error("usage: ay send <keyword> <msg|-> [--code=enter|esc|ctrl-c|ctrl-y|tab|none]");
-	const trailing = controlCodeFromName(typeof flags.code === "string" ? flags.code.toLowerCase() : "enter");
+	const codeName = argv.code.toLowerCase();
+	{
+		const remote = await resolveRemoteSpec(keyword);
+		if (remote) return runRemoteSend(remote, rawMessage, codeName);
+	}
+	const trailing = controlCodeFromName(codeName);
 	const record = await resolveOne(keyword, opts);
 	const fifoPath = record.fifo_file;
 	if (!fifoPath) throw new Error(`pid ${record.pid}: no fifo_file recorded — agent was not started with --stdpush (or was spawned by Rust which doesn't yet support FIFO IPC; see ROADMAP item 10)`);
@@ -594,13 +922,22 @@ async function writeToIpc(ipcPath, payload) {
 	}
 }
 async function cmdRestart(rest) {
-	const { flags, positional } = parseArgs(rest);
+	const argv = await yargs(rest).usage("Usage: ay restart <keyword>").option("latest", {
+		type: "boolean",
+		default: false,
+		description: "Use most recent match"
+	}).option("cwd", {
+		type: "string",
+		description: "Restrict to agents under this dir"
+	}).help(false).version(false).exitProcess(false).parseAsync();
 	const opts = {
-		...commonOpts(flags),
-		all: true
+		all: true,
+		active: false,
+		json: false,
+		latest: argv.latest,
+		cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
 	};
-	const keyword = positional[0];
-	const record = await resolveOne(keyword, opts);
+	const record = await resolveOne(argv._[0] !== void 0 ? String(argv._[0]) : void 0, opts);
 	if (isPidAlive(record.pid)) {
 		process.stderr.write(`pid ${record.pid} is still running — stop it first or use ay send\n`);
 		return 1;
@@ -621,14 +958,16 @@ async function cmdRestart(rest) {
 	return 0;
 }
 async function cmdNote(rest) {
-	const { flags, positional } = parseArgs(rest);
-	const opts = commonOpts(flags);
-	const keyword = positional[0];
-	const note = positional.slice(1).join(" ");
+	const argv = await yargs(rest).usage("Usage: ay note <keyword> [\"note text\"]").help(false).version(false).exitProcess(false).parseAsync();
+	const keyword = argv._[0] !== void 0 ? String(argv._[0]) : void 0;
+	const note = argv._.slice(1).map(String).join(" ");
 	if (!keyword) throw new Error("usage: ay note <keyword> [\"note text\"]  (omit text to clear)");
 	const record = await resolveOne(keyword, {
-		...opts,
-		all: true
+		all: true,
+		active: false,
+		json: false,
+		latest: false,
+		cwdScope: null
 	});
 	if (!note) {
 		await writeNote(record.pid, "");
@@ -668,15 +1007,38 @@ async function snapshotStatus(record) {
 	};
 }
 async function cmdStatus(rest) {
-	const { flags, positional } = parseArgs(rest);
+	const argv = await yargs(rest).usage("Usage: ay status <keyword> [options]").option("watch", {
+		alias: "w",
+		type: "boolean",
+		default: false,
+		description: "Stream changes as JSON"
+	}).option("interval", {
+		type: "number",
+		default: 2,
+		description: "Poll interval in seconds"
+	}).option("latest", {
+		type: "boolean",
+		default: false,
+		description: "Use most recent match"
+	}).option("cwd", {
+		type: "string",
+		description: "Restrict to agents under this dir"
+	}).help(false).version(false).exitProcess(false).parseAsync();
 	const opts = {
-		...commonOpts(flags),
-		all: true
+		all: true,
+		active: false,
+		json: false,
+		latest: argv.latest,
+		cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
 	};
-	const keyword = positional[0];
+	const keyword = argv._[0] !== void 0 ? String(argv._[0]) : void 0;
 	if (!keyword) throw new Error("usage: ay status <keyword> [--watch] [--interval=N]");
-	const watch = !!(flags.watch || flags.w);
-	const intervalFlag = typeof flags.interval === "string" ? Number(flags.interval) : 2;
+	{
+		const remote = await resolveRemoteSpec(keyword);
+		if (remote) return runRemoteStatus(remote);
+	}
+	const watch = argv.watch;
+	const intervalFlag = argv.interval;
 	const intervalMs = Math.max(500, (Number.isFinite(intervalFlag) ? intervalFlag : 2) * 1e3);
 	const record = await resolveOne(keyword, opts);
 	const emit = (snap, ts) => {
@@ -715,5 +1077,5 @@ async function cmdStatus(rest) {
 }
 
 //#endregion
-export { isSubcommand, runSubcommand };
-//# sourceMappingURL=subcommands-DjO8lthH.js.map
+export { matchKeyword as a, resolveOne as c, writeToIpc as d, listRecords as i, runSubcommand as l, isPidAlive as n, readNotes as o, isSubcommand as r, renderRawLog as s, controlCodeFromName as t, snapshotStatus as u };
+//# sourceMappingURL=subcommands-BpGEGOQM.js.map

package/dist/{tray-CH_G7aXM.js → tray-DHuD0nEk.js}

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

package/dist/{ts-DP0dIeoe.js → ts-DWuvdSWr.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-B9h0djqx.js";
-import { r as getInstalledPackage } from "./versionChecker-DtDqoy3L.js";
+import { r as getInstalledPackage } from "./versionChecker-BCrJk4Zj.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-C22d9SRJ.js";
 import { t as PidStore } from "./pidStore-C1JXxoPi.js";
 import { r as readGlobalPids } from "./globalPidIndex-Cr-g75QF.js";
@@ -1693,4 +1693,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-DP0dIeoe.js.map
+//# sourceMappingURL=ts-DWuvdSWr.js.map

package/dist/{versionChecker-DtDqoy3L.js → versionChecker-BCrJk4Zj.js}

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

package/package.json

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