agent-yes 1.70.1 → 1.72.0

package/dist/{SUPPORTED_CLIS-Bq5hoKRN.js → SUPPORTED_CLIS-jR_I2op4.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.72.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-jR_I2op4.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-jR_I2op4.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-Dyiihcrq.js");
+	await startTray();
+	await new Promise(() => {});
+}
 if (config.useRust) {
 	let rustBinary;
 	try {
@@ -562,6 +572,10 @@ if (config.verbose) {
 	console.log(config);
 	console.log(argv);
 }
+{
+	const { ensureTray } = await import("./tray-Dyiihcrq.js");
+	ensureTray();
+}
 const { default: cliYes } = await import("./index.js");
 const { exitCode } = await cliYes({
 	...config,

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-jR_I2op4.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