claude-yes 1.73.2 → 1.74.0

package/dist/SUPPORTED_CLIS-BCn8YIi2.js

@@ -0,0 +1,11 @@
+import { t as CLIS_CONFIG } from "./ts-C8vuG5y-.js";
+import "./logger-B9h0djqx.js";
+import "./pidStore-CHLHMBEM.js";
+import "./globalPidIndex-DNEh8a_O.js";
+
+//#region ts/SUPPORTED_CLIS.ts
+const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
+
+//#endregion
+export { SUPPORTED_CLIS };
+//# sourceMappingURL=SUPPORTED_CLIS-BCn8YIi2.js.map

package/dist/{agent-yes.config-CyP5iRZf.js → agent-yes.config-1LMoK18R.js}

@@ -288,4 +288,4 @@ async function getDefaultConfig() {
 
 //#endregion
 export { agent_yes_config_default as default };
-//# sourceMappingURL=agent-yes.config-CyP5iRZf.js.map
+//# sourceMappingURL=agent-yes.config-1LMoK18R.js.map

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { n as logger } from "./logger-B9h0djqx.js";
-import { n as version, t as name } from "./package-DpfHTSW2.js";
+import { n as version, t as name } from "./package-Bn0B_jWZ.js";
 import { argv } from "process";
 import { execFileSync, spawn } from "child_process";
 import ms from "ms";
@@ -634,16 +634,23 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 		process.exit(0);
 	}
 }
+{
+	const { isSubcommand, runSubcommand } = await import("./subcommands-CR1i1sjy.js");
+	if (isSubcommand(process.argv[2])) {
+		const code = await runSubcommand(process.argv);
+		process.exit(code ?? 0);
+	}
+}
 await checkAndAutoUpdate();
 logger.info(versionString());
 const config = parseCliArgs(process.argv);
 if (config.tray) {
-	const { startTray } = await import("./tray-Bzb1owBN.js");
+	const { startTray } = await import("./tray-D5deJPjk.js");
 	await startTray();
 	await new Promise(() => {});
 }
 {
-	const { ensureTray } = await import("./tray-Bzb1owBN.js");
+	const { ensureTray } = await import("./tray-D5deJPjk.js");
 	ensureTray();
 }
 if (config.useRust) {
@@ -657,7 +664,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-C7sGMdKJ.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-BCn8YIi2.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);
@@ -687,7 +694,7 @@ if (config.showVersion) {
 	process.exit(0);
 }
 if (config.appendPrompt) {
-	const { PidStore } = await import("./pidStore-B4yDm3TL.js");
+	const { PidStore } = await import("./pidStore-DR1yPY3t.js");
 	const ipcPath = await PidStore.findActiveFifo(process.cwd());
 	if (!ipcPath) {
 		console.error("No active agent with IPC found in current directory.");

package/dist/globalPidIndex-DNEh8a_O.js

@@ -0,0 +1,103 @@
+import { n as logger } from "./logger-B9h0djqx.js";
+import { appendFile, mkdir, readFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+import { lock } from "proper-lockfile";
+
+//#region ts/globalPidIndex.ts
+const GLOBAL_DIR = path.join(homedir(), ".agent-yes");
+const GLOBAL_FILE = path.join(GLOBAL_DIR, "pids.jsonl");
+async function ensureDir() {
+	await mkdir(GLOBAL_DIR, { recursive: true });
+}
+async function withLock(fn) {
+	await ensureDir();
+	let release;
+	try {
+		release = await lock(GLOBAL_DIR, {
+			lockfilePath: GLOBAL_FILE + ".lock",
+			retries: {
+				retries: 5,
+				minTimeout: 50,
+				maxTimeout: 500
+			}
+		});
+		return await fn();
+	} finally {
+		await release?.();
+	}
+}
+/** Append one full record line. Caller must provide all required fields. */
+async function appendGlobalPid(record) {
+	try {
+		await withLock(async () => {
+			await appendFile(GLOBAL_FILE, JSON.stringify(record) + "\n");
+		});
+	} catch (error) {
+		logger.debug("[globalPidIndex] append failed:", error);
+	}
+}
+/** Append a partial status update by pid (status, exit_code, exit_reason). */
+async function updateGlobalPidStatus(pid, patch) {
+	try {
+		await withLock(async () => {
+			const existing = (await readGlobalPidsRaw()).find((r) => r.pid === pid);
+			if (!existing) return;
+			const merged = {
+				...existing,
+				...patch
+			};
+			await appendFile(GLOBAL_FILE, JSON.stringify(merged) + "\n");
+		});
+	} catch (error) {
+		logger.debug("[globalPidIndex] updateStatus failed:", error);
+	}
+}
+/**
+* Read the file once without merge logic — internal helper for status updates.
+*/
+async function readGlobalPidsRaw() {
+	let raw;
+	try {
+		raw = await readFile(GLOBAL_FILE, "utf-8");
+	} catch (err) {
+		if (err.code === "ENOENT") return [];
+		throw err;
+	}
+	const merged = /* @__PURE__ */ new Map();
+	for (const line of raw.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const doc = JSON.parse(trimmed);
+			if (typeof doc.pid !== "number") continue;
+			const prev = merged.get(doc.pid);
+			merged.set(doc.pid, prev ? {
+				...prev,
+				...doc
+			} : doc);
+		} catch {}
+	}
+	return Array.from(merged.values());
+}
+/**
+* Read all records, last-line-per-pid wins (events get merged).
+* Optionally filter to live processes only.
+*/
+async function readGlobalPids(opts = {}) {
+	const records = await readGlobalPidsRaw();
+	if (!opts.liveOnly) return records;
+	return records.filter((r) => r.status !== "exited" && isProcessAlive(r.pid));
+}
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+export { readGlobalPids as n, updateGlobalPidStatus as r, appendGlobalPid as t };
+//# sourceMappingURL=globalPidIndex-DNEh8a_O.js.map

package/dist/index.js

@@ -1,5 +1,6 @@
-import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-CsdLrLod.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-C8vuG5y-.js";
 import "./logger-B9h0djqx.js";
-import "./pidStore-CPrgJSJi.js";
+import "./pidStore-CHLHMBEM.js";
+import "./globalPidIndex-DNEh8a_O.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

package/dist/{package-DpfHTSW2.js → package-Bn0B_jWZ.js}

@@ -1,7 +1,7 @@
 //#region package.json
 var name = "agent-yes";
-var version = "1.73.1";
+var version = "1.73.2";
 
 //#endregion
 export { version as n, name as t };
-//# sourceMappingURL=package-DpfHTSW2.js.map
+//# sourceMappingURL=package-Bn0B_jWZ.js.map

package/dist/{pidStore-CPrgJSJi.js → pidStore-CHLHMBEM.js}

@@ -1,4 +1,5 @@
 import { n as logger } from "./logger-B9h0djqx.js";
+import { r as updateGlobalPidStatus, t as appendGlobalPid } from "./globalPidIndex-DNEh8a_O.js";
 import { closeSync, existsSync, fsyncSync, openSync } from "fs";
 import { appendFile, mkdir, readFile, rename, writeFile } from "fs/promises";
 import path from "path";
@@ -202,14 +203,17 @@ var PidStore = class PidStore {
 	}
 	async registerProcess({ pid, cli, args, prompt, cwd }) {
 		const now = Date.now();
+		const argsJson = JSON.stringify(args);
+		const logFile = path.resolve(this.getLogDir(), `${pid}.log`);
+		const fifoFile = this.getFifoPath(pid);
 		const record = {
 			pid,
 			cli,
-			args: JSON.stringify(args),
+			args: argsJson,
 			prompt,
 			cwd,
-			logFile: path.resolve(this.getLogDir(), `${pid}.log`),
-			fifoFile: this.getFifoPath(pid),
+			logFile,
+			fifoFile,
 			status: "active",
 			exitReason: "",
 			startedAt: now
@@ -224,6 +228,18 @@ var PidStore = class PidStore {
 			throw new Error(`Failed to register process ${pid}`);
 		}
 		logger.debug(`[pidStore] Registered process ${pid}`);
+		appendGlobalPid({
+			pid,
+			cli,
+			prompt: prompt ?? null,
+			cwd,
+			log_file: logFile,
+			fifo_file: fifoFile,
+			status: "active",
+			exit_code: null,
+			exit_reason: null,
+			started_at: now
+		}).catch(() => null);
 		return result;
 	}
 	async updateStatus(pid, status, extra) {
@@ -234,6 +250,11 @@ var PidStore = class PidStore {
 		if (extra?.exitCode !== void 0) patch.exitCode = extra.exitCode;
 		await this.store.updateById(existing._id, patch);
 		logger.debug(`[pidStore] Updated process ${pid} status=${status}`);
+		updateGlobalPidStatus(pid, {
+			status,
+			exit_code: extra?.exitCode ?? null,
+			exit_reason: extra?.exitReason ?? null
+		}).catch(() => null);
 	}
 	getAllRecords() {
 		return this.store.getAll();
@@ -316,4 +337,4 @@ pid-db/
 
 //#endregion
 export { PidStore as t };
-//# sourceMappingURL=pidStore-CPrgJSJi.js.map
+//# sourceMappingURL=pidStore-CHLHMBEM.js.map

package/dist/pidStore-DR1yPY3t.js

@@ -0,0 +1,5 @@
+import "./logger-B9h0djqx.js";
+import { t as PidStore } from "./pidStore-CHLHMBEM.js";
+import "./globalPidIndex-DNEh8a_O.js";
+
+export { PidStore };

package/dist/subcommands-CR1i1sjy.js

@@ -0,0 +1,387 @@
+import "./logger-B9h0djqx.js";
+import { n as readGlobalPids } from "./globalPidIndex-DNEh8a_O.js";
+import { readFile, stat } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+
+//#region ts/subcommands.ts
+/**
+* `cy ls / read / cat / tail / head / send` subcommand implementations.
+*
+* Mirrors the principles of koho's `terminal-ws-lib.ts` (session list, render
+* via @xterm/headless, keyword-keyed input) — but file-based instead of via
+* a daemon. Reads ~/.agent-yes/pids.jsonl (cross-runtime global index, written
+* by both the TS PidStore and the Rust pid_store::PidStore) and the per-pid
+* raw log files.
+*
+* Returns null when argv[2] is not a known subcommand so cli.ts falls through
+* to the normal agent-spawning flow.
+*/
+/**
+* Read the per-cwd TS PidStore JSONL and convert to the global record shape,
+* so pre-existing TS agents that were spawned before the global-index mirror
+* shipped still show up in `cy ls`. Merging is done in `mergeRecords`.
+*/
+async function readLocalTsPids(cwd) {
+	const jsonlPath = path.join(cwd, ".agent-yes", "pid-records.jsonl");
+	let raw;
+	try {
+		raw = await readFile(jsonlPath, "utf-8");
+	} catch {
+		return [];
+	}
+	const docs = /* @__PURE__ */ new Map();
+	for (const line of raw.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const doc = JSON.parse(trimmed);
+			if (!doc._id) continue;
+			if (doc.$$deleted) {
+				docs.delete(doc._id);
+				continue;
+			}
+			const prev = docs.get(doc._id);
+			docs.set(doc._id, prev ? {
+				...prev,
+				...doc
+			} : doc);
+		} catch {}
+	}
+	return Array.from(docs.values()).map((d) => ({
+		pid: d.pid,
+		cli: d.cli,
+		prompt: d.prompt ?? null,
+		cwd: d.cwd,
+		log_file: d.logFile ?? null,
+		fifo_file: d.fifoFile ?? null,
+		status: d.status ?? "active",
+		exit_code: d.exitCode ?? null,
+		exit_reason: d.exitReason ?? null,
+		started_at: d.startedAt ?? 0
+	}));
+}
+/** Merge by pid; later entries (typically from the global file) win. */
+function mergeRecords(...buckets) {
+	const out = /* @__PURE__ */ new Map();
+	for (const bucket of buckets) for (const r of bucket) {
+		const prev = out.get(r.pid);
+		out.set(r.pid, prev ? {
+			...prev,
+			...r
+		} : r);
+	}
+	return Array.from(out.values());
+}
+const SUBCOMMANDS = new Set([
+	"ls",
+	"list",
+	"ps",
+	"read",
+	"cat",
+	"tail",
+	"head",
+	"send"
+]);
+function isSubcommand(name) {
+	return !!name && SUBCOMMANDS.has(name);
+}
+/**
+* Top-level entry. Returns the desired process exit code, or null if argv
+* is not a subcommand invocation.
+*/
+async function runSubcommand(argv) {
+	const sub = argv[2];
+	if (!isSubcommand(sub)) return null;
+	const rest = argv.slice(3);
+	try {
+		switch (sub) {
+			case "ls":
+			case "list":
+			case "ps": return await cmdLs(rest);
+			case "read":
+			case "cat": return await cmdRead(rest, { mode: "cat" });
+			case "tail": return await cmdRead(rest, { mode: "tail" });
+			case "head": return await cmdRead(rest, { mode: "head" });
+			case "send": return await cmdSend(rest);
+			default: return null;
+		}
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		process.stderr.write(`cy ${sub}: ${msg}\n`);
+		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",
+					"json",
+					"latest"
+				].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,
+		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();
+	if (/^\d+$/.test(keyword) && record.pid === Number(keyword)) return true;
+	if (record.cwd.toLowerCase().includes(kw)) return true;
+	if (record.cli.toLowerCase() === kw) return true;
+	if (record.prompt && record.prompt.toLowerCase().includes(kw)) return true;
+	return false;
+}
+async function listRecords(keyword, opts) {
+	let records = mergeRecords(await readLocalTsPids(process.cwd()), opts.cwdScope ? await readLocalTsPids(opts.cwdScope) : [], await readGlobalPids());
+	if (!opts.all) records = records.filter((r) => r.status !== "exited" && isPidAlive(r.pid));
+	if (opts.cwdScope) {
+		const scope = opts.cwdScope;
+		records = records.filter((r) => r.cwd === scope || r.cwd.startsWith(scope + path.sep));
+	}
+	if (keyword) records = records.filter((r) => matchKeyword(r, keyword));
+	records.sort((a, b) => b.started_at - a.started_at);
+	return records;
+}
+function isPidAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function resolveOne(keyword, opts) {
+	if (!keyword) throw new Error("keyword required (pid, cwd substring, cli name, or prompt substring)");
+	const matches = await listRecords(keyword, opts);
+	if (matches.length === 0) throw new Error(`no running agent matched "${keyword}"`);
+	if (matches.length === 1) return matches[0];
+	if (opts.latest) return matches[0];
+	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 cmdLs(rest) {
+	const { flags, positional } = parseArgs(rest);
+	const opts = commonOpts(flags);
+	const keyword = positional[0];
+	const records = await listRecords(keyword, opts);
+	if (opts.json) {
+		process.stdout.write(JSON.stringify(records, null, 2) + "\n");
+		return 0;
+	}
+	if (records.length === 0) {
+		process.stderr.write(keyword ? `no running agents matched "${keyword}"\n` : "no running agents\n");
+		return 0;
+	}
+	const rows = records.map((r) => ({
+		pid: String(r.pid),
+		cli: r.cli,
+		status: r.status,
+		age: humanizeAge(Date.now() - r.started_at),
+		cwd: shortenPath(r.cwd),
+		prompt: truncate(r.prompt ?? "", 60)
+	}));
+	const widths = {
+		pid: Math.max(3, ...rows.map((r) => r.pid.length)),
+		cli: Math.max(3, ...rows.map((r) => r.cli.length)),
+		status: Math.max(6, ...rows.map((r) => r.status.length)),
+		age: Math.max(3, ...rows.map((r) => r.age.length)),
+		cwd: Math.max(3, ...rows.map((r) => r.cwd.length))
+	};
+	const header = [
+		"PID".padEnd(widths.pid),
+		"CLI".padEnd(widths.cli),
+		"STATUS".padEnd(widths.status),
+		"AGE".padEnd(widths.age),
+		"CWD".padEnd(widths.cwd),
+		"PROMPT"
+	].join("  ") + "\n";
+	process.stdout.write(header);
+	for (const r of rows) process.stdout.write([
+		r.pid.padEnd(widths.pid),
+		r.cli.padEnd(widths.cli),
+		r.status.padEnd(widths.status),
+		r.age.padEnd(widths.age),
+		r.cwd.padEnd(widths.cwd),
+		r.prompt
+	].join("  ") + "\n");
+	return 0;
+}
+function humanizeAge(ms) {
+	if (ms < 1e3) return "0s";
+	const s = Math.floor(ms / 1e3);
+	if (s < 60) return `${s}s`;
+	const m = Math.floor(s / 60);
+	if (m < 60) return `${m}m`;
+	const h = Math.floor(m / 60);
+	if (h < 24) return `${h}h`;
+	return `${Math.floor(h / 24)}d`;
+}
+function shortenPath(p) {
+	const home = homedir();
+	return p.startsWith(home) ? "~" + p.slice(home.length) : p;
+}
+function truncate(s, n) {
+	if (s.length <= n) return s;
+	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 nFlag = typeof flags.n === "string" ? Number(flags.n) : void 0;
+	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;
+	if (!logPath) throw new Error(`pid ${record.pid}: no log_file recorded`);
+	let stats;
+	try {
+		stats = await stat(logPath);
+	} catch {
+		throw new Error(`pid ${record.pid}: log file not found at ${logPath}`);
+	}
+	if (!stats.isFile()) throw new Error(`pid ${record.pid}: log path is not a file: ${logPath}`);
+	const rendered = await renderRawLog(await readFile(logPath), {
+		mode,
+		n
+	});
+	process.stdout.write(rendered);
+	if (!rendered.endsWith("\n")) process.stdout.write("\n");
+	return 0;
+}
+/**
+* Feed the raw PTY bytes through @xterm/headless and emit plain text.
+* Same approach as koho's renderTerminalBuffer + agent-yes's XtermProxy.
+*/
+async function renderRawLog(buf, { mode, n }) {
+	const cols = 200;
+	const rows = 50;
+	const scrollback = Math.max(5e4, n + rows + 100);
+	try {
+		const { Terminal } = await import("@xterm/headless");
+		const term = new Terminal({
+			cols,
+			rows,
+			scrollback,
+			allowProposedApi: true
+		});
+		await new Promise((resolve) => term.write(buf, resolve));
+		const active = term.buffer.active;
+		const lines = [];
+		for (let i = 0; i < active.length; i++) {
+			const line = active.getLine(i);
+			lines.push(line ? line.translateToString(false).trimEnd() : "");
+		}
+		while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+		if (mode === "cat") return lines.join("\n");
+		if (mode === "tail") return lines.slice(Math.max(0, lines.length - n)).join("\n");
+		return lines.slice(0, n).join("\n");
+	} catch {
+		let text = new TextDecoder().decode(buf);
+		text = text.replace(/\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g, "").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+		const lines = text.split("\n");
+		if (mode === "cat") return lines.join("\n");
+		if (mode === "tail") return lines.slice(Math.max(0, lines.length - n)).join("\n");
+		return lines.slice(0, n).join("\n");
+	}
+}
+async function cmdSend(rest) {
+	const { flags, positional } = parseArgs(rest);
+	const opts = commonOpts(flags);
+	const keyword = positional[0];
+	const message = positional.slice(1).join(" ");
+	if (!keyword) throw new Error("usage: cy send <keyword> <msg> [--code=enter|esc|ctrl-c|ctrl-y|tab|none]");
+	const trailing = controlCodeFromName(typeof flags.code === "string" ? flags.code.toLowerCase() : "enter");
+	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)`);
+	const payload = (message ?? "") + trailing;
+	await writeToIpc(fifoPath, payload);
+	process.stdout.write(`sent to pid ${record.pid} (${record.cli}): ${truncate(payload, 80)}\n`);
+	return 0;
+}
+function controlCodeFromName(name) {
+	switch (name) {
+		case "enter":
+		case "cr":
+		case "return": return "\r";
+		case "esc":
+		case "escape": return "\x1B";
+		case "ctrl-c":
+		case "ctrlc": return "";
+		case "ctrl-y":
+		case "ctrly": return "";
+		case "ctrl-d":
+		case "ctrld": return "";
+		case "tab": return "	";
+		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}`);
+	}
+}
+async function writeToIpc(ipcPath, payload) {
+	if (process.platform === "win32") {
+		const { connect } = await import("net");
+		await new Promise((resolve, reject) => {
+			const client = connect(ipcPath);
+			const timer = setTimeout(() => {
+				client.destroy();
+				reject(/* @__PURE__ */ new Error("named pipe connect timeout"));
+			}, 5e3);
+			client.on("connect", () => {
+				clearTimeout(timer);
+				client.write(payload);
+				client.end();
+				resolve();
+			});
+			client.on("error", (err) => {
+				clearTimeout(timer);
+				reject(err);
+			});
+		});
+	} else {
+		const { openSync, writeFileSync, closeSync } = await import("fs");
+		const fd = openSync(ipcPath, "w");
+		try {
+			writeFileSync(fd, payload);
+		} finally {
+			closeSync(fd);
+		}
+	}
+}
+
+//#endregion
+export { isSubcommand, runSubcommand };
+//# sourceMappingURL=subcommands-CR1i1sjy.js.map

package/dist/{tray-Bzb1owBN.js → tray-D5deJPjk.js}

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

package/dist/{ts-CsdLrLod.js → ts-C8vuG5y-.js}

@@ -1,7 +1,7 @@
 import { n as logger, t as addTransport } from "./logger-B9h0djqx.js";
-import { n as version } from "./package-DpfHTSW2.js";
+import { n as version } from "./package-Bn0B_jWZ.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-DQWJSptq.js";
-import { t as PidStore } from "./pidStore-CPrgJSJi.js";
+import { t as PidStore } from "./pidStore-CHLHMBEM.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
 import { closeSync, constants, createReadStream, existsSync, mkdirSync, openSync } from "fs";
@@ -1032,7 +1032,7 @@ async function notifyWebhook(status, details, cwd = process.cwd()) {
 
 //#endregion
 //#region ts/index.ts
-const config = await import("./agent-yes.config-CyP5iRZf.js").then((mod) => mod.default || mod);
+const config = await import("./agent-yes.config-1LMoK18R.js").then((mod) => mod.default || mod);
 const CLIS_CONFIG = config.clis;
 /**
 * Main function to run agent-cli with automatic yes/no responses
@@ -1679,4 +1679,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-CsdLrLod.js.map
+//# sourceMappingURL=ts-C8vuG5y-.js.map

package/package.json

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