agent-yes 1.70.1 → 1.71.0

package/dist/{SUPPORTED_CLIS-Bq5hoKRN.js → SUPPORTED_CLIS-DtYo1wxO.js}

@@ -1,4 +1,5 @@
 import { t as logger } from "./logger-CX77vJDA.js";
+import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-BBI_URhR.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
 import { execaCommandSync, parseCommandString } from "execa";
@@ -178,251 +179,6 @@ function removeControlCharacters(str) {
 	return str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
 }
 
-//#endregion
-//#region ts/runningLock.ts
-const getLockDir = () => path.join(process.env.CLAUDE_YES_HOME || homedir(), ".claude-yes");
-const getLockFile = () => path.join(getLockDir(), "running.lock.json");
-const MAX_RETRIES = 5;
-const RETRY_DELAYS = [
-	50,
-	100,
-	200,
-	400,
-	800
-];
-const POLL_INTERVAL = 2e3;
-/**
-* Check if a process is running
-*/
-function isProcessRunning(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Get git repository root for a directory
-*/
-function getGitRoot(cwd) {
-	try {
-		return execSync("git rev-parse --show-toplevel", {
-			cwd,
-			encoding: "utf8",
-			stdio: [
-				"pipe",
-				"pipe",
-				"ignore"
-			]
-		}).trim();
-	} catch {
-		return null;
-	}
-}
-/**
-* Check if directory is in a git repository
-*/
-function isGitRepo(cwd) {
-	try {
-		return getGitRoot(cwd) !== null;
-	} catch {
-		return false;
-	}
-}
-/**
-* Resolve path to real path (handling symlinks)
-*/
-function resolveRealPath(p) {
-	try {
-		return path.resolve(p);
-	} catch {
-		return p;
-	}
-}
-/**
-* Sleep for a given number of milliseconds
-*/
-function sleep$1(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
-* Read lock file with retry logic and stale lock cleanup
-*/
-async function readLockFile() {
-	try {
-		const lockDir = getLockDir();
-		const lockFilePath = getLockFile();
-		await mkdir(lockDir, { recursive: true });
-		if (!existsSync(lockFilePath)) return { tasks: [] };
-		const content = await readFile(lockFilePath, "utf8");
-		const lockFile = JSON.parse(content);
-		lockFile.tasks = lockFile.tasks.filter((task) => {
-			if (isProcessRunning(task.pid)) return true;
-			return false;
-		});
-		return lockFile;
-	} catch {
-		return { tasks: [] };
-	}
-}
-/**
-* Write lock file atomically with retry logic
-*/
-async function writeLockFile(lockFile, retryCount = 0) {
-	try {
-		const lockDir = getLockDir();
-		const lockFilePath = getLockFile();
-		await mkdir(lockDir, { recursive: true });
-		const tempFile = `${lockFilePath}.tmp.${process.pid}`;
-		await writeFile(tempFile, JSON.stringify(lockFile, null, 2), "utf8");
-		await rename(tempFile, lockFilePath);
-	} catch (error) {
-		if (retryCount < MAX_RETRIES) {
-			await sleep$1(RETRY_DELAYS[retryCount] || 800);
-			return writeLockFile(lockFile, retryCount + 1);
-		}
-		throw error;
-	}
-}
-/**
-* Check if lock exists for the current working directory
-*/
-async function checkLock(cwd, _prompt) {
-	const resolvedCwd = resolveRealPath(cwd);
-	const gitRoot = isGitRepo(resolvedCwd) ? getGitRoot(resolvedCwd) : null;
-	const lockKey = gitRoot || resolvedCwd;
-	const blockingTasks = (await readLockFile()).tasks.filter((task) => {
-		if (!isProcessRunning(task.pid)) return false;
-		if (task.status !== "running") return false;
-		if (gitRoot && task.gitRoot) return task.gitRoot === gitRoot;
-		else return task.cwd === lockKey;
-	});
-	return {
-		isLocked: blockingTasks.length > 0,
-		blockingTasks,
-		lockKey
-	};
-}
-/**
-* Add a task to the lock file
-*/
-async function addTask(task) {
-	const lockFile = await readLockFile();
-	lockFile.tasks = lockFile.tasks.filter((t) => t.pid !== task.pid);
-	lockFile.tasks.push(task);
-	await writeLockFile(lockFile);
-}
-/**
-* Update task status
-*/
-async function updateTaskStatus(pid, status) {
-	const lockFile = await readLockFile();
-	const task = lockFile.tasks.find((t) => t.pid === pid);
-	if (task) {
-		task.status = status;
-		await writeLockFile(lockFile);
-	}
-}
-/**
-* Remove a task from the lock file
-*/
-async function removeTask(pid) {
-	const lockFile = await readLockFile();
-	lockFile.tasks = lockFile.tasks.filter((t) => t.pid !== pid);
-	await writeLockFile(lockFile);
-}
-/**
-* Wait for lock to be released
-*/
-async function waitForUnlock(blockingTasks, currentTask) {
-	const blockingTask = blockingTasks[0];
-	if (!blockingTask) return;
-	console.log(`⏳ Queueing for unlock of: ${blockingTask.task}`);
-	console.log(`   Press 'b' to bypass queue, 'k' to kill previous instance`);
-	await addTask({
-		...currentTask,
-		status: "queued"
-	});
-	const stdin = process.stdin;
-	const wasRaw = stdin.isRaw;
-	stdin.setRawMode?.(true);
-	stdin.resume();
-	let bypassed = false;
-	let killed = false;
-	const keyHandler = (key) => {
-		const char = key.toString();
-		if (char === "b" || char === "B") {
-			console.log("\n⚡ Bypassing queue...");
-			bypassed = true;
-		} else if (char === "k" || char === "K") {
-			console.log("\n🔪 Killing previous instance...");
-			killed = true;
-		}
-	};
-	stdin.on("data", keyHandler);
-	let dots = 0;
-	while (true) {
-		if (bypassed) {
-			await updateTaskStatus(currentTask.pid, "running");
-			console.log("✓ Queue bypassed, starting task...");
-			break;
-		}
-		if (killed && blockingTask) {
-			try {
-				process.kill(blockingTask.pid, "SIGTERM");
-				console.log(`✓ Killed process ${blockingTask.pid}`);
-				await sleep$1(1e3);
-			} catch (err) {
-				console.log(`⚠️  Could not kill process ${blockingTask.pid}: ${err}`);
-			}
-			killed = false;
-		}
-		await sleep$1(POLL_INTERVAL);
-		if (!(await checkLock(currentTask.cwd, currentTask.task)).isLocked) {
-			await updateTaskStatus(currentTask.pid, "running");
-			console.log(`\n✓ Lock released, starting task...`);
-			break;
-		}
-		dots = (dots + 1) % 4;
-		process.stdout.write(`\r⏳ Queueing${".".repeat(dots)}${" ".repeat(3 - dots)}`);
-	}
-	stdin.off("data", keyHandler);
-	stdin.setRawMode?.(wasRaw);
-	if (!wasRaw) stdin.pause();
-}
-/**
-* Acquire lock or wait if locked
-*/
-async function acquireLock(cwd, prompt = "no prompt provided") {
-	const resolvedCwd = resolveRealPath(cwd);
-	const task = {
-		cwd: resolvedCwd,
-		gitRoot: (isGitRepo(resolvedCwd) ? getGitRoot(resolvedCwd) : null) || void 0,
-		task: prompt.substring(0, 100),
-		pid: process.pid,
-		status: "running",
-		startedAt: Date.now(),
-		lockedAt: Date.now()
-	};
-	const lockCheck = await checkLock(resolvedCwd, prompt);
-	if (lockCheck.isLocked) await waitForUnlock(lockCheck.blockingTasks, task);
-	else await addTask(task);
-}
-/**
-* Release lock for current process
-*/
-async function releaseLock(pid = process.pid) {
-	await removeTask(pid);
-}
-/**
-* Check if we should use locking for this directory
-* Only use locking if we're in a git repository
-*/
-function shouldUseLock(_cwd) {
-	return true;
-}
-
 //#endregion
 //#region ts/beta/fifo.ts
 /**
@@ -1059,7 +815,7 @@ function tryCatch(catchFn, fn) {
 //#endregion
 //#region package.json
 var name = "agent-yes";
-var version = "1.70.1";
+var version = "1.71.0";
 
 //#endregion
 //#region ts/pty-fix.ts
@@ -1486,7 +1242,7 @@ async function notifyWebhook(status, details, cwd = process.cwd()) {
 
 //#endregion
 //#region ts/index.ts
-const config = await import("./agent-yes.config-DcxG25Gv.js").then((mod) => mod.default || mod);
+const config = await import("./agent-yes.config-CtQprJrA.js").then((mod) => mod.default || mod);
 const CLIS_CONFIG = config.clis;
 /**
 * Main function to run agent-cli with automatic yes/no responses
@@ -2139,4 +1895,4 @@ const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { AgentContext as a, PidStore as c, config as i, removeControlCharacters as l, CLIS_CONFIG as n, name as o, agentYes as r, version as s, SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-Bq5hoKRN.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-DtYo1wxO.js.map

package/dist/{agent-yes.config-DcxG25Gv.js → agent-yes.config-CtQprJrA.js}

@@ -332,4 +332,4 @@ function getDefaultConfig() {
 
 //#endregion
 export { agent_yes_config_default as default };
-//# sourceMappingURL=agent-yes.config-DcxG25Gv.js.map
+//# sourceMappingURL=agent-yes.config-CtQprJrA.js.map

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Bq5hoKRN.js";
+import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DtYo1wxO.js";
 import { t as logger } from "./logger-CX77vJDA.js";
 import { argv } from "process";
 import { spawn } from "child_process";
@@ -91,6 +91,10 @@ function parseCliArgs(argv) {
 		description: "Pass --dangerously-skip-permissions to the CLI (claude shortcut)",
 		default: false,
 		alias: "y"
+	}).option("tray", {
+		type: "boolean",
+		description: "Show a system tray icon with running agent count (macOS/Windows only)",
+		default: false
 	}).option("rust", {
 		type: "boolean",
 		description: "Use the Rust implementation (enabled by default, use --no-rust for TypeScript)",
@@ -193,6 +197,7 @@ function parseCliArgs(argv) {
 		showVersion: parsedArgv.version,
 		autoYes: parsedArgv.auto !== "no",
 		idleAction: parsedArgv.idleAction,
+		tray: parsedArgv.tray,
 		useRust: parsedArgv.rust,
 		swarm: parsedArgv.swarm ?? (parsedArgv.experimentalSwarm ? parsedArgv.swarmTopic : void 0),
 		experimentalSwarm: parsedArgv.experimentalSwarm,
@@ -475,6 +480,11 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 //#region ts/cli.ts
 const updateCheckPromise = checkAndAutoUpdate();
 const config = parseCliArgs(process.argv);
+if (config.tray) {
+	const { startTray } = await import("./tray-BzSS0v-i.js");
+	await startTray();
+	await new Promise(() => {});
+}
 if (config.useRust) {
 	let rustBinary;
 	try {

package/dist/index.js

@@ -1,4 +1,4 @@
-import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-Bq5hoKRN.js";
+import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-DtYo1wxO.js";
 import "./logger-CX77vJDA.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

package/dist/runningLock-BBI_URhR.js

@@ -0,0 +1,263 @@
+import { execSync } from "child_process";
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import path from "path";
+import { homedir } from "os";
+import { existsSync } from "fs";
+
+//#region ts/runningLock.ts
+const getLockDir = () => path.join(process.env.CLAUDE_YES_HOME || homedir(), ".claude-yes");
+const getLockFile = () => path.join(getLockDir(), "running.lock.json");
+const MAX_RETRIES = 5;
+const RETRY_DELAYS = [
+	50,
+	100,
+	200,
+	400,
+	800
+];
+const POLL_INTERVAL = 2e3;
+/**
+* Check if a process is running
+*/
+function isProcessRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Get git repository root for a directory
+*/
+function getGitRoot(cwd) {
+	try {
+		return execSync("git rev-parse --show-toplevel", {
+			cwd,
+			encoding: "utf8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+/**
+* Check if directory is in a git repository
+*/
+function isGitRepo(cwd) {
+	try {
+		return getGitRoot(cwd) !== null;
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve path to real path (handling symlinks)
+*/
+function resolveRealPath(p) {
+	try {
+		return path.resolve(p);
+	} catch {
+		return p;
+	}
+}
+/**
+* Sleep for a given number of milliseconds
+*/
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Read lock file with retry logic and stale lock cleanup
+*/
+async function readLockFile() {
+	try {
+		const lockDir = getLockDir();
+		const lockFilePath = getLockFile();
+		await mkdir(lockDir, { recursive: true });
+		if (!existsSync(lockFilePath)) return { tasks: [] };
+		const content = await readFile(lockFilePath, "utf8");
+		const lockFile = JSON.parse(content);
+		lockFile.tasks = lockFile.tasks.filter((task) => {
+			if (isProcessRunning(task.pid)) return true;
+			return false;
+		});
+		return lockFile;
+	} catch {
+		return { tasks: [] };
+	}
+}
+/**
+* Write lock file atomically with retry logic
+*/
+async function writeLockFile(lockFile, retryCount = 0) {
+	try {
+		const lockDir = getLockDir();
+		const lockFilePath = getLockFile();
+		await mkdir(lockDir, { recursive: true });
+		const tempFile = `${lockFilePath}.tmp.${process.pid}`;
+		await writeFile(tempFile, JSON.stringify(lockFile, null, 2), "utf8");
+		await rename(tempFile, lockFilePath);
+	} catch (error) {
+		if (retryCount < MAX_RETRIES) {
+			await sleep(RETRY_DELAYS[retryCount] || 800);
+			return writeLockFile(lockFile, retryCount + 1);
+		}
+		throw error;
+	}
+}
+/**
+* Check if lock exists for the current working directory
+*/
+async function checkLock(cwd, _prompt) {
+	const resolvedCwd = resolveRealPath(cwd);
+	const gitRoot = isGitRepo(resolvedCwd) ? getGitRoot(resolvedCwd) : null;
+	const lockKey = gitRoot || resolvedCwd;
+	const blockingTasks = (await readLockFile()).tasks.filter((task) => {
+		if (!isProcessRunning(task.pid)) return false;
+		if (task.status !== "running") return false;
+		if (gitRoot && task.gitRoot) return task.gitRoot === gitRoot;
+		else return task.cwd === lockKey;
+	});
+	return {
+		isLocked: blockingTasks.length > 0,
+		blockingTasks,
+		lockKey
+	};
+}
+/**
+* Add a task to the lock file
+*/
+async function addTask(task) {
+	const lockFile = await readLockFile();
+	lockFile.tasks = lockFile.tasks.filter((t) => t.pid !== task.pid);
+	lockFile.tasks.push(task);
+	await writeLockFile(lockFile);
+}
+/**
+* Update task status
+*/
+async function updateTaskStatus(pid, status) {
+	const lockFile = await readLockFile();
+	const task = lockFile.tasks.find((t) => t.pid === pid);
+	if (task) {
+		task.status = status;
+		await writeLockFile(lockFile);
+	}
+}
+/**
+* Remove a task from the lock file
+*/
+async function removeTask(pid) {
+	const lockFile = await readLockFile();
+	lockFile.tasks = lockFile.tasks.filter((t) => t.pid !== pid);
+	await writeLockFile(lockFile);
+}
+/**
+* Wait for lock to be released
+*/
+async function waitForUnlock(blockingTasks, currentTask) {
+	const blockingTask = blockingTasks[0];
+	if (!blockingTask) return;
+	console.log(`⏳ Queueing for unlock of: ${blockingTask.task}`);
+	console.log(`   Press 'b' to bypass queue, 'k' to kill previous instance`);
+	await addTask({
+		...currentTask,
+		status: "queued"
+	});
+	const stdin = process.stdin;
+	const wasRaw = stdin.isRaw;
+	stdin.setRawMode?.(true);
+	stdin.resume();
+	let bypassed = false;
+	let killed = false;
+	const keyHandler = (key) => {
+		const char = key.toString();
+		if (char === "b" || char === "B") {
+			console.log("\n⚡ Bypassing queue...");
+			bypassed = true;
+		} else if (char === "k" || char === "K") {
+			console.log("\n🔪 Killing previous instance...");
+			killed = true;
+		}
+	};
+	stdin.on("data", keyHandler);
+	let dots = 0;
+	while (true) {
+		if (bypassed) {
+			await updateTaskStatus(currentTask.pid, "running");
+			console.log("✓ Queue bypassed, starting task...");
+			break;
+		}
+		if (killed && blockingTask) {
+			try {
+				process.kill(blockingTask.pid, "SIGTERM");
+				console.log(`✓ Killed process ${blockingTask.pid}`);
+				await sleep(1e3);
+			} catch (err) {
+				console.log(`⚠️  Could not kill process ${blockingTask.pid}: ${err}`);
+			}
+			killed = false;
+		}
+		await sleep(POLL_INTERVAL);
+		if (!(await checkLock(currentTask.cwd, currentTask.task)).isLocked) {
+			await updateTaskStatus(currentTask.pid, "running");
+			console.log(`\n✓ Lock released, starting task...`);
+			break;
+		}
+		dots = (dots + 1) % 4;
+		process.stdout.write(`\r⏳ Queueing${".".repeat(dots)}${" ".repeat(3 - dots)}`);
+	}
+	stdin.off("data", keyHandler);
+	stdin.setRawMode?.(wasRaw);
+	if (!wasRaw) stdin.pause();
+}
+/**
+* Get the count of currently running agents
+*/
+async function getRunningAgentCount() {
+	const running = (await readLockFile()).tasks.filter((t) => t.status === "running");
+	return {
+		count: running.length,
+		tasks: running
+	};
+}
+/**
+* Acquire lock or wait if locked
+*/
+async function acquireLock(cwd, prompt = "no prompt provided") {
+	const resolvedCwd = resolveRealPath(cwd);
+	const task = {
+		cwd: resolvedCwd,
+		gitRoot: (isGitRepo(resolvedCwd) ? getGitRoot(resolvedCwd) : null) || void 0,
+		task: prompt.substring(0, 100),
+		pid: process.pid,
+		status: "running",
+		startedAt: Date.now(),
+		lockedAt: Date.now()
+	};
+	const lockCheck = await checkLock(resolvedCwd, prompt);
+	if (lockCheck.isLocked) await waitForUnlock(lockCheck.blockingTasks, task);
+	else await addTask(task);
+}
+/**
+* Release lock for current process
+*/
+async function releaseLock(pid = process.pid) {
+	await removeTask(pid);
+}
+/**
+* Check if we should use locking for this directory
+* Only use locking if we're in a git repository
+*/
+function shouldUseLock(_cwd) {
+	return true;
+}
+
+//#endregion
+export { shouldUseLock as i, getRunningAgentCount as n, releaseLock as r, acquireLock as t };
+//# sourceMappingURL=runningLock-BBI_URhR.js.map

package/dist/tray-BzSS0v-i.js

@@ -0,0 +1,109 @@
+import { n as getRunningAgentCount } from "./runningLock-BBI_URhR.js";
+
+//#region ts/tray.ts
+const POLL_INTERVAL = 2e3;
+const ICON_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAjklEQVQ4T2NkoBAwUqifgWoGMDIyNjAyMv5nYGBYQMgVjMgCQM0LGBkZHYDYAY8BDUBxByB2wGcAyAUOQOwAxPYMDAyOeCzAbwBIMyMjowNQsz0ely8ACjng8wJeA0CaGRgY7IHYAZ8hQHEHfF7AawBYMwODPZABRHsBpwEgzUDN9kDsgM8lQHEHfC4gJhwAAM3hMBGq3cNNAAAAAElFTkSuQmCC";
+function buildMenuItems(tasks) {
+	const items = [];
+	if (tasks.length === 0) items.push({
+		title: "No running agents",
+		tooltip: "",
+		enabled: false
+	});
+	else {
+		items.push({
+			title: `Running agents: ${tasks.length}`,
+			tooltip: "",
+			enabled: false
+		});
+		items.push({
+			title: "---",
+			tooltip: "",
+			enabled: false
+		});
+		for (const task of tasks) {
+			const dir = task.cwd.replace(/^.*[/\\]/, "");
+			const desc = task.task ? ` - ${task.task.slice(0, 40)}` : "";
+			items.push({
+				title: `[${task.pid}] ${dir}${desc}`,
+				tooltip: task.cwd,
+				enabled: false
+			});
+		}
+	}
+	items.push({
+		title: "---",
+		tooltip: "",
+		enabled: false
+	});
+	items.push({
+		title: "Quit Tray",
+		tooltip: "Exit tray icon",
+		enabled: true
+	});
+	return items;
+}
+async function startTray() {
+	if (process.platform !== "darwin" && process.platform !== "win32") {
+		console.error("Tray icon is only supported on macOS and Windows.");
+		return;
+	}
+	let SysTray;
+	try {
+		SysTray = (await import("systray2")).default;
+	} catch {
+		console.error("systray2 is not installed. Install it with: npm install systray2");
+		return;
+	}
+	const { count, tasks } = await getRunningAgentCount();
+	const systray = new SysTray({
+		menu: {
+			icon: ICON_BASE64,
+			title: `AY: ${count}`,
+			tooltip: `agent-yes: ${count} running`,
+			items: buildMenuItems(tasks)
+		},
+		debug: false,
+		copyDir: false
+	});
+	await systray.ready();
+	console.log(`Tray started. Watching ${count} running agent(s).`);
+	systray.onClick((action) => {
+		if (action.item.title === "Quit Tray") {
+			systray.kill(false);
+			process.exit(0);
+		}
+	});
+	let lastCount = count;
+	const interval = setInterval(async () => {
+		try {
+			const { count: newCount, tasks: newTasks } = await getRunningAgentCount();
+			if (newCount !== lastCount) {
+				lastCount = newCount;
+				systray.sendAction({
+					type: "update-menu",
+					menu: {
+						icon: ICON_BASE64,
+						title: `AY: ${newCount}`,
+						tooltip: `agent-yes: ${newCount} running`,
+						items: buildMenuItems(newTasks)
+					}
+				});
+			}
+		} catch {}
+	}, POLL_INTERVAL);
+	process.on("SIGINT", () => {
+		clearInterval(interval);
+		systray.kill(false);
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		clearInterval(interval);
+		systray.kill(false);
+		process.exit(0);
+	});
+}
+
+//#endregion
+export { startTray };
+//# sourceMappingURL=tray-BzSS0v-i.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.70.1",
+  "version": "1.71.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",
@@ -130,6 +130,9 @@
       "optional": true
     }
   },
+  "optionalDependencies": {
+    "systray2": "^2.1.4"
+  },
   "engines": {
     "node": ">=22.0.0"
   },

package/ts/cli.ts

@@ -15,6 +15,13 @@ const updateCheckPromise = checkAndAutoUpdate();
 // Parse CLI arguments
 const config = parseCliArgs(process.argv);
 
+// Handle --tray: show system tray icon and block
+if (config.tray) {
+  const { startTray } = await import("./tray.ts");
+  await startTray();
+  await new Promise(() => {}); // Block forever, exit via tray quit or signal
+}
+
 // Handle --rust: spawn the Rust binary instead, fall back to TypeScript if unavailable
 if (config.useRust) {
   let rustBinary: string | undefined;

package/ts/parseCliArgs.ts

@@ -126,6 +126,11 @@ export function parseCliArgs(argv: string[]) {
       default: false,
       alias: "y",
     })
+    .option("tray", {
+      type: "boolean",
+      description: "Show a system tray icon with running agent count (macOS/Windows only)",
+      default: false,
+    })
     .option("rust", {
       type: "boolean",
       description: "Use the Rust implementation (enabled by default, use --no-rust for TypeScript)",
@@ -275,6 +280,7 @@ export function parseCliArgs(argv: string[]) {
     showVersion: parsedArgv.version,
     autoYes: parsedArgv.auto !== "no", // auto-yes enabled by default, disabled with --auto=no
     idleAction: parsedArgv.idleAction as string | undefined,
+    tray: parsedArgv.tray,
     useRust: parsedArgv.rust,
     // New unified --swarm flag (takes precedence over deprecated flags)
     swarm: parsedArgv.swarm ?? (parsedArgv.experimentalSwarm ? parsedArgv.swarmTopic : undefined),

package/ts/runningLock.ts

@@ -286,6 +286,20 @@ async function waitForUnlock(blockingTasks: Task[], currentTask: Task): Promise<
   if (!wasRaw) stdin.pause();
 }
 
+/**
+ * Read the current lock file (exported for tray and other consumers)
+ */
+export { readLockFile };
+
+/**
+ * Get the count of currently running agents
+ */
+export async function getRunningAgentCount(): Promise<{ count: number; tasks: Task[] }> {
+  const lockFile = await readLockFile();
+  const running = lockFile.tasks.filter((t) => t.status === "running");
+  return { count: running.length, tasks: running };
+}
+
 /**
  * Clean stale locks from the lock file
  */

package/ts/tray.spec.ts

@@ -0,0 +1,233 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Mock systray2 before imports
+const mockSysTray = vi.hoisted(() => {
+  const instance = {
+    ready: vi.fn().mockResolvedValue(undefined),
+    onClick: vi.fn(),
+    sendAction: vi.fn(),
+    kill: vi.fn(),
+  };
+  const MockClass = vi.fn().mockImplementation(function (this: any, opts: any) {
+    Object.assign(this, instance);
+    (MockClass as any).__lastOpts = opts;
+    return this;
+  }) as any;
+  MockClass.__lastOpts = null;
+  return {
+    instance,
+    MockClass,
+  };
+});
+
+vi.mock("systray2", () => ({
+  default: mockSysTray.MockClass,
+}));
+
+// Mock runningLock
+const mockGetRunningAgentCount = vi.hoisted(() =>
+  vi.fn().mockResolvedValue({ count: 0, tasks: [] }),
+);
+
+vi.mock("./runningLock.ts", () => ({
+  getRunningAgentCount: mockGetRunningAgentCount,
+}));
+
+describe("tray", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetRunningAgentCount.mockResolvedValue({ count: 0, tasks: [] });
+  });
+
+  describe("startTray", () => {
+    it("should create a systray instance on macOS", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      expect(mockSysTray.MockClass).toHaveBeenCalledWith(
+        expect.objectContaining({
+          menu: expect.objectContaining({
+            title: "AY: 0",
+            tooltip: "agent-yes: 0 running",
+          }),
+        }),
+      );
+      expect(mockSysTray.instance.ready).toHaveBeenCalled();
+      expect(mockSysTray.instance.onClick).toHaveBeenCalled();
+
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should show running agent count and task details", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+
+      mockGetRunningAgentCount.mockResolvedValue({
+        count: 2,
+        tasks: [
+          {
+            pid: 1234,
+            cwd: "/home/user/project-a",
+            task: "fix bugs",
+            status: "running",
+            startedAt: Date.now(),
+            lockedAt: Date.now(),
+          },
+          {
+            pid: 5678,
+            cwd: "/home/user/project-b",
+            task: "add tests",
+            status: "running",
+            startedAt: Date.now(),
+            lockedAt: Date.now(),
+          },
+        ],
+      });
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      const menuArg = mockSysTray.MockClass.mock.calls[0][0];
+      expect(menuArg.menu.title).toBe("AY: 2");
+      expect(menuArg.menu.tooltip).toBe("agent-yes: 2 running");
+
+      // Should have: header, separator, 2 agent items, separator, quit
+      const items = menuArg.menu.items;
+      expect(items[0].title).toBe("Running agents: 2");
+      expect(items[2].title).toContain("[1234]");
+      expect(items[2].title).toContain("project-a");
+      expect(items[3].title).toContain("[5678]");
+      expect(items[3].title).toContain("project-b");
+
+      // Last item should be "Quit Tray"
+      expect(items[items.length - 1].title).toBe("Quit Tray");
+
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should handle quit menu click", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+
+      const mockExit = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      // Get the onClick callback
+      const onClickCb = mockSysTray.instance.onClick.mock.calls[0][0];
+
+      // Simulate "Quit Tray" click
+      onClickCb({ item: { title: "Quit Tray" } });
+
+      expect(mockSysTray.instance.kill).toHaveBeenCalledWith(false);
+      expect(mockExit).toHaveBeenCalledWith(0);
+
+      mockExit.mockRestore();
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should update tray when agent count changes", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+
+      vi.useFakeTimers();
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      // Now simulate agent count change on next poll
+      mockGetRunningAgentCount.mockResolvedValue({
+        count: 3,
+        tasks: [
+          {
+            pid: 111,
+            cwd: "/a",
+            task: "t1",
+            status: "running" as const,
+            startedAt: 0,
+            lockedAt: 0,
+          },
+          {
+            pid: 222,
+            cwd: "/b",
+            task: "t2",
+            status: "running" as const,
+            startedAt: 0,
+            lockedAt: 0,
+          },
+          {
+            pid: 333,
+            cwd: "/c",
+            task: "t3",
+            status: "running" as const,
+            startedAt: 0,
+            lockedAt: 0,
+          },
+        ],
+      });
+
+      // Advance timer past poll interval
+      await vi.advanceTimersByTimeAsync(2100);
+
+      expect(mockSysTray.instance.sendAction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "update-menu",
+          menu: expect.objectContaining({
+            title: "AY: 3",
+          }),
+        }),
+      );
+
+      vi.useRealTimers();
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should not update tray when agent count stays the same", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+
+      vi.useFakeTimers();
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      // Same count on next poll
+      mockGetRunningAgentCount.mockResolvedValue({ count: 0, tasks: [] });
+
+      await vi.advanceTimersByTimeAsync(2100);
+
+      expect(mockSysTray.instance.sendAction).not.toHaveBeenCalled();
+
+      vi.useRealTimers();
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should work on Windows", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "win32" });
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      expect(mockSysTray.MockClass).toHaveBeenCalled();
+
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+
+    it("should skip on Linux", async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", { value: "linux" });
+
+      const { startTray } = await import("./tray.ts");
+      await startTray();
+
+      expect(mockSysTray.MockClass).not.toHaveBeenCalled();
+
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+  });
+});

package/ts/tray.ts

@@ -0,0 +1,118 @@
+import { getRunningAgentCount, type Task } from "./runningLock.ts";
+
+const POLL_INTERVAL = 2000;
+
+// Minimal 16x16 white circle PNG as base64 (used as tray icon)
+const ICON_BASE64 =
+  "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAA" +
+  "jklEQVQ4T2NkoBAwUqifgWoGMDIyNjAyMv5nYGBYQMgVjMgC" +
+  "QM0LGBkZHYDYAY8BDUBxByB2wGcAyAUOQOwAxPYMDAyOeCzA" +
+  "bwBIMyMjowNQsz0ely8ACjng8wJeA0CaGRgY7IHYAZ8hQHEH" +
+  "fF7AawBYMwODPZABRHsBpwEgzUDN9kDsgM8lQHEHfC4gJhwA" +
+  "AM3hMBGq3cNNAAAAAElFTkSuQmCC";
+
+function buildMenuItems(tasks: Task[]) {
+  const items = [];
+
+  if (tasks.length === 0) {
+    items.push({ title: "No running agents", tooltip: "", enabled: false });
+  } else {
+    items.push({
+      title: `Running agents: ${tasks.length}`,
+      tooltip: "",
+      enabled: false,
+    });
+    items.push({ title: "---", tooltip: "", enabled: false });
+    for (const task of tasks) {
+      const dir = task.cwd.replace(/^.*[/\\]/, "");
+      const desc = task.task ? ` - ${task.task.slice(0, 40)}` : "";
+      items.push({
+        title: `[${task.pid}] ${dir}${desc}`,
+        tooltip: task.cwd,
+        enabled: false,
+      });
+    }
+  }
+
+  items.push({ title: "---", tooltip: "", enabled: false });
+  items.push({ title: "Quit Tray", tooltip: "Exit tray icon", enabled: true });
+
+  return items;
+}
+
+export async function startTray(): Promise<void> {
+  // Only macOS and Windows have proper tray support
+  if (process.platform !== "darwin" && process.platform !== "win32") {
+    console.error("Tray icon is only supported on macOS and Windows.");
+    return;
+  }
+
+  let SysTray: typeof import("systray2").default;
+  try {
+    SysTray = (await import("systray2")).default;
+  } catch {
+    console.error("systray2 is not installed. Install it with: npm install systray2");
+    return;
+  }
+
+  const { count, tasks } = await getRunningAgentCount();
+
+  const systray = new SysTray({
+    menu: {
+      icon: ICON_BASE64,
+      title: `AY: ${count}`,
+      tooltip: `agent-yes: ${count} running`,
+      items: buildMenuItems(tasks),
+    },
+    debug: false,
+    copyDir: false,
+  });
+
+  await systray.ready();
+  console.log(`Tray started. Watching ${count} running agent(s).`);
+
+  // Handle quit
+  systray.onClick((action) => {
+    if (action.item.title === "Quit Tray") {
+      systray.kill(false);
+      process.exit(0);
+    }
+  });
+
+  // Poll and update
+  let lastCount = count;
+  const interval = setInterval(async () => {
+    try {
+      const { count: newCount, tasks: newTasks } = await getRunningAgentCount();
+
+      if (newCount !== lastCount) {
+        lastCount = newCount;
+
+        // Update title and tooltip
+        systray.sendAction({
+          type: "update-menu",
+          menu: {
+            icon: ICON_BASE64,
+            title: `AY: ${newCount}`,
+            tooltip: `agent-yes: ${newCount} running`,
+            items: buildMenuItems(newTasks),
+          },
+        });
+      }
+    } catch {
+      // Ignore polling errors
+    }
+  }, POLL_INTERVAL);
+
+  // Cleanup on exit
+  process.on("SIGINT", () => {
+    clearInterval(interval);
+    systray.kill(false);
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    clearInterval(interval);
+    systray.kill(false);
+    process.exit(0);
+  });
+}