claude-yes 1.72.3 → 1.72.4

package/dist/{SUPPORTED_CLIS-C-KnmE0Y.js → SUPPORTED_CLIS-Bqw9gxey.js}

@@ -815,7 +815,7 @@ function tryCatch(catchFn, fn) {
 //#endregion
 //#region package.json
 var name = "agent-yes";
-var version = "1.72.3";
+var version = "1.72.4";
 
 //#endregion
 //#region ts/pty-fix.ts
@@ -1895,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-C-KnmE0Y.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-Bqw9gxey.js.map

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
-import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-C-KnmE0Y.js";
+import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Bqw9gxey.js";
 import { t as logger } from "./logger-CX77vJDA.js";
 import { argv } from "process";
-import { spawn } from "child_process";
+import { execFileSync, spawn } from "child_process";
 import ms from "ms";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
@@ -225,44 +225,72 @@ async function writeUpdateCache(data) {
 	await writeFile(CACHE_FILE, JSON.stringify(data));
 }
 function detectPackageManager() {
-	if (process.env.BUN_INSTALL || process.env.npm_execpath?.includes("bun")) return "bun";
+	if (process.env.BUN_INSTALL || process.execPath?.includes("bun") || process.env.npm_execpath?.includes("bun")) return "bun";
 	return "npm";
 }
 /**
-* Check for updates and auto-install if a newer version is available.
+* Check for updates, auto-install if newer version is available, and re-exec
+* so the current invocation always runs the latest code.
+*
 * Uses a 1-hour TTL cache to avoid hitting the registry on every run.
 * All errors are swallowed — network issues must never break the tool.
 * Set AGENT_YES_NO_UPDATE=1 to opt out.
+*
+* The AGENT_YES_UPDATED env var prevents infinite re-exec loops:
+* after updating we re-exec with AGENT_YES_UPDATED=<version> so the
+* new process skips the update check.
 */
 async function checkAndAutoUpdate() {
 	if (process.env.AGENT_YES_NO_UPDATE) return;
+	if (process.env.AGENT_YES_UPDATED === version) return;
 	try {
+		let latestVersion;
 		const cache = await readUpdateCache();
-		if (cache && Date.now() - cache.checkedAt < TTL_MS) {
-			if (compareVersions(version, cache.latestVersion) < 0) await runInstall(cache.latestVersion);
-			return;
+		if (cache && Date.now() - cache.checkedAt < TTL_MS) latestVersion = cache.latestVersion;
+		else {
+			const fetched = await fetchLatestVersion();
+			if (!fetched) return;
+			latestVersion = fetched;
+			await writeUpdateCache({
+				checkedAt: Date.now(),
+				latestVersion
+			});
+		}
+		if (compareVersions(version, latestVersion) < 0) {
+			if (await runInstall(latestVersion)) reExec(latestVersion);
 		}
-		const latestVersion = await fetchLatestVersion();
-		if (!latestVersion) return;
-		await writeUpdateCache({
-			checkedAt: Date.now(),
-			latestVersion
-		});
-		if (compareVersions(version, latestVersion) < 0) await runInstall(latestVersion);
 	} catch {}
 }
 async function runInstall(latestVersion) {
-	const installArgs = detectPackageManager() === "bun" ? `bun add -g agent-yes@${latestVersion}` : `npm install -g agent-yes@${latestVersion}`;
+	const installCmd = detectPackageManager() === "bun" ? `bun add -g agent-yes@${latestVersion}` : `npm install -g agent-yes@${latestVersion}`;
 	process.stderr.write(`\x1b[33m[agent-yes] Updating ${version} → ${latestVersion}…\x1b[0m\n`);
 	try {
-		await execaCommand(installArgs, { stdio: "inherit" });
-		await writeUpdateCache({
-			checkedAt: 0,
-			latestVersion
-		});
+		await execaCommand(installCmd, { stdio: "inherit" });
 		process.stderr.write(`\x1b[32m[agent-yes] Updated to ${latestVersion}\x1b[0m\n`);
+		return true;
 	} catch {
-		process.stderr.write(`\x1b[31m[agent-yes] Auto-update failed. Run: ${installArgs}\x1b[0m\n`);
+		process.stderr.write(`\x1b[31m[agent-yes] Auto-update failed. Run: ${installCmd}\x1b[0m\n`);
+		return false;
+	}
+}
+/**
+* Re-exec the current process so the newly installed version runs.
+* Sets AGENT_YES_UPDATED=<version> to prevent an infinite loop.
+*/
+function reExec(version) {
+	const [bin, ...args] = process.argv;
+	process.stderr.write(`\x1b[36m[agent-yes] Restarting with v${version}…\x1b[0m\n`);
+	try {
+		execFileSync(bin, args, {
+			stdio: "inherit",
+			env: {
+				...process.env,
+				AGENT_YES_UPDATED: version
+			}
+		});
+		process.exit(0);
+	} catch (err) {
+		process.exit(err.status ?? 1);
 	}
 }
 /**
@@ -478,15 +506,15 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 
 //#endregion
 //#region ts/cli.ts
-const updateCheckPromise = checkAndAutoUpdate();
+await checkAndAutoUpdate();
 const config = parseCliArgs(process.argv);
 if (config.tray) {
-	const { startTray } = await import("./tray-BQkynk6r.js");
+	const { startTray } = await import("./tray-CPpdxTV-.js");
 	await startTray();
 	await new Promise(() => {});
 }
 {
-	const { ensureTray } = await import("./tray-BQkynk6r.js");
+	const { ensureTray } = await import("./tray-CPpdxTV-.js");
 	ensureTray();
 }
 if (config.useRust) {
@@ -581,7 +609,6 @@ const { exitCode } = await cliYes({
 	...config,
 	autoYes: config.autoYes
 });
-await updateCheckPromise;
 console.log("exiting process");
 process.exit(exitCode ?? 1);
 

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-C-KnmE0Y.js";
+import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-Bqw9gxey.js";
 import "./logger-CX77vJDA.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

package/dist/{tray-BQkynk6r.js → tray-CPpdxTV-.js}

@@ -6,7 +6,6 @@ import { existsSync } from "fs";
 
 //#region ts/tray.ts
 const POLL_INTERVAL = 2e3;
-const IDLE_EXIT_POLLS = 15;
 const getTrayDir = () => path.join(process.env.CLAUDE_YES_HOME || homedir(), ".claude-yes");
 const getTrayPidFile = () => path.join(getTrayDir(), "tray.pid");
 const ICON_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAjklEQVQ4T2NkoBAwUqifgWoGMDIyNjAyMv5nYGBYQMgVjMgCQM0LGBkZHYDYAY8BDUBxByB2wGcAyAUOQOwAxPYMDAyOeCzAbwBIMyMjowNQsz0ely8ACjng8wJeA0CaGRgY7IHYAZ8hQHEHfF7AawBYMwODPZABRHsBpwEgzUDN9kDsgM8lQHEHfC4gJhwAAM3hMBGq3cNNAAAAAElFTkSuQmCC";
@@ -153,17 +152,9 @@ async function startTray() {
 		if (action.item.title === "Quit Tray") cleanup();
 	});
 	let lastCount = count;
-	let idlePolls = count === 0 ? 1 : 0;
 	intervalId = setInterval(async () => {
 		try {
 			const { count: newCount, tasks: newTasks } = await getRunningAgentCount();
-			if (newCount === 0) {
-				idlePolls++;
-				if (idlePolls >= IDLE_EXIT_POLLS) {
-					cleanup();
-					return;
-				}
-			} else idlePolls = 0;
 			if (newCount !== lastCount) {
 				lastCount = newCount;
 				systray.sendAction({
@@ -184,4 +175,4 @@ async function startTray() {
 
 //#endregion
 export { ensureTray, startTray };
-//# sourceMappingURL=tray-BQkynk6r.js.map
+//# sourceMappingURL=tray-CPpdxTV-.js.map

package/package.json

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

package/ts/cli.ts

@@ -9,8 +9,9 @@ import { checkAndAutoUpdate, displayVersion } from "./versionChecker.ts";
 import { getRustBinary } from "./rustBinary.ts";
 import { buildRustArgs } from "./buildRustArgs.ts";
 
-// Start update check in background immediately (runs in parallel with the agent session)
-const updateCheckPromise = checkAndAutoUpdate();
+// Check for updates before starting — installs & re-execs if a newer version exists.
+// Fast path: cached result (no network), so this adds near-zero latency most of the time.
+await checkAndAutoUpdate();
 
 // Parse CLI arguments
 const config = parseCliArgs(process.argv);
@@ -152,8 +153,5 @@ if (config.verbose) {
 const { default: cliYes } = await import("./index.ts");
 const { exitCode } = await cliYes({ ...config, autoYes: config.autoYes });
 
-// Apply update if one was found during the session
-await updateCheckPromise;
-
 console.log("exiting process");
 process.exit(exitCode ?? 1);

package/ts/tray.spec.ts

@@ -215,62 +215,6 @@ describe("tray", () => {
       Object.defineProperty(process, "platform", { value: originalPlatform });
     });
 
-    it("should auto-exit after ~30s with 0 agents", async () => {
-      const originalPlatform = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      vi.useFakeTimers();
-      const mockExit = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
-
-      const { startTray } = await import("./tray.ts");
-      await startTray();
-
-      // Keep returning 0 agents for 15 polls (IDLE_EXIT_POLLS)
-      mockGetRunningAgentCount.mockResolvedValue({ count: 0, tasks: [] });
-
-      // Advance 15 * 2s = 30s
-      await vi.advanceTimersByTimeAsync(15 * 2100);
-
-      expect(mockSysTray.instance.kill).toHaveBeenCalledWith(false);
-      await vi.waitFor(() => expect(mockExit).toHaveBeenCalledWith(0));
-
-      mockExit.mockRestore();
-      vi.useRealTimers();
-      Object.defineProperty(process, "platform", { value: originalPlatform });
-    });
-
-    it("should reset idle counter when agents appear", async () => {
-      const originalPlatform = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      vi.useFakeTimers();
-      const mockExit = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
-
-      const { startTray } = await import("./tray.ts");
-      await startTray();
-
-      // 10 polls at 0 agents
-      mockGetRunningAgentCount.mockResolvedValue({ count: 0, tasks: [] });
-      await vi.advanceTimersByTimeAsync(10 * 2100);
-
-      // Then an agent appears — resets idle counter
-      mockGetRunningAgentCount.mockResolvedValue({
-        count: 1,
-        tasks: [
-          { pid: 1, cwd: "/a", task: "t", status: "running" as const, startedAt: 0, lockedAt: 0 },
-        ],
-      });
-      await vi.advanceTimersByTimeAsync(2100);
-
-      // Then 10 more polls at 0 — should NOT exit yet (need 15 consecutive)
-      mockGetRunningAgentCount.mockResolvedValue({ count: 0, tasks: [] });
-      await vi.advanceTimersByTimeAsync(10 * 2100);
-
-      expect(mockExit).not.toHaveBeenCalled();
-
-      mockExit.mockRestore();
-      vi.useRealTimers();
-      Object.defineProperty(process, "platform", { value: originalPlatform });
-    });
-
     it("should work on Windows", async () => {
       const originalPlatform = process.platform;
       Object.defineProperty(process, "platform", { value: "win32" });

package/ts/tray.ts

@@ -5,7 +5,6 @@ import path from "path";
 import { getRunningAgentCount, type Task } from "./runningLock.ts";
 
 const POLL_INTERVAL = 2000;
-const IDLE_EXIT_POLLS = 15; // Exit after 15 polls (~30s) with 0 agents
 
 const getTrayDir = () => path.join(process.env.CLAUDE_YES_HOME || homedir(), ".claude-yes");
 const getTrayPidFile = () => path.join(getTrayDir(), "tray.pid");
@@ -177,21 +176,10 @@ export async function startTray(): Promise<void> {
 
   // Poll and update, auto-exit after ~30s idle (0 agents)
   let lastCount = count;
-  let idlePolls = count === 0 ? 1 : 0;
   intervalId = setInterval(async () => {
     try {
       const { count: newCount, tasks: newTasks } = await getRunningAgentCount();
 
-      if (newCount === 0) {
-        idlePolls++;
-        if (idlePolls >= IDLE_EXIT_POLLS) {
-          cleanup();
-          return;
-        }
-      } else {
-        idlePolls = 0;
-      }
-
       if (newCount !== lastCount) {
         lastCount = newCount;
 

package/ts/versionChecker.spec.ts

@@ -12,6 +12,14 @@ vi.mock("fs/promises", () => ({
   readFile: vi.fn(),
   writeFile: vi.fn().mockResolvedValue(undefined),
 }));
+vi.mock("child_process", () => ({
+  execFileSync: vi.fn(() => {
+    // Simulate successful re-exec by throwing an exit-like error
+    const err = new Error("re-exec") as any;
+    err.status = 0;
+    throw err;
+  }),
+}));
 
 describe("versionChecker", () => {
   describe("compareVersions", () => {
@@ -81,7 +89,10 @@ describe("versionChecker", () => {
       vi.clearAllMocks();
       vi.stubGlobal("fetch", vi.fn());
       vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+      // Use a mock for process.exit to prevent actual exit in tests
+      vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
       delete process.env.AGENT_YES_NO_UPDATE;
+      delete process.env.AGENT_YES_UPDATED;
       delete process.env.BUN_INSTALL;
     });
 
@@ -95,6 +106,13 @@ describe("versionChecker", () => {
       expect(fetch).not.toHaveBeenCalled();
     });
 
+    it("should skip when AGENT_YES_UPDATED matches current version", async () => {
+      const pkg = await import("../package.json");
+      process.env.AGENT_YES_UPDATED = pkg.default.version;
+      await checkAndAutoUpdate();
+      expect(fetch).not.toHaveBeenCalled();
+    });
+
     it("should use cached result within TTL and not install when up-to-date", async () => {
       const { readFile } = await import("fs/promises");
       vi.mocked(readFile).mockResolvedValueOnce(
@@ -105,19 +123,23 @@ describe("versionChecker", () => {
       expect(process.stderr.write).not.toHaveBeenCalled();
     });
 
-    it("should install from cache when cached version is newer and within TTL", async () => {
+    it("should install and re-exec from cache when cached version is newer and within TTL", async () => {
       const { readFile } = await import("fs/promises");
       const { execaCommand } = await import("execa");
+      const { execFileSync } = await import("child_process");
       vi.mocked(readFile).mockResolvedValueOnce(
         JSON.stringify({ checkedAt: Date.now(), latestVersion: "999.0.0" }) as any,
       );
       await checkAndAutoUpdate();
       expect(execaCommand).toHaveBeenCalled();
+      expect(execFileSync).toHaveBeenCalled();
+      expect(process.exit).toHaveBeenCalled();
     });
 
-    it("should fetch and write cache when stale, install if behind", async () => {
+    it("should fetch and write cache when stale, install and re-exec if behind", async () => {
       const { readFile, writeFile } = await import("fs/promises");
       const { execaCommand } = await import("execa");
+      const { execFileSync } = await import("child_process");
       vi.mocked(readFile).mockRejectedValueOnce(new Error("no cache"));
       vi.mocked(fetch).mockResolvedValue({
         ok: true,
@@ -126,6 +148,7 @@ describe("versionChecker", () => {
       await checkAndAutoUpdate();
       expect(writeFile).toHaveBeenCalled();
       expect(execaCommand).toHaveBeenCalled();
+      expect(execFileSync).toHaveBeenCalled();
     });
 
     it("should fetch and write cache but not install if up-to-date", async () => {

package/ts/versionChecker.ts

@@ -1,3 +1,4 @@
+import { execFileSync } from "child_process";
 import { execaCommand } from "execa";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
@@ -25,59 +26,92 @@ async function writeUpdateCache(data: UpdateCache): Promise<void> {
 }
 
 function detectPackageManager(): string {
-  if (process.env.BUN_INSTALL || process.env.npm_execpath?.includes("bun")) return "bun";
+  if (
+    process.env.BUN_INSTALL ||
+    process.execPath?.includes("bun") ||
+    process.env.npm_execpath?.includes("bun")
+  )
+    return "bun";
   return "npm";
 }
 
 /**
- * Check for updates and auto-install if a newer version is available.
+ * Check for updates, auto-install if newer version is available, and re-exec
+ * so the current invocation always runs the latest code.
+ *
  * Uses a 1-hour TTL cache to avoid hitting the registry on every run.
  * All errors are swallowed — network issues must never break the tool.
  * Set AGENT_YES_NO_UPDATE=1 to opt out.
+ *
+ * The AGENT_YES_UPDATED env var prevents infinite re-exec loops:
+ * after updating we re-exec with AGENT_YES_UPDATED=<version> so the
+ * new process skips the update check.
  */
 export async function checkAndAutoUpdate(): Promise<void> {
   if (process.env.AGENT_YES_NO_UPDATE) return;
 
+  // Prevent infinite re-exec: if we just updated to this version, skip
+  if (process.env.AGENT_YES_UPDATED === pkg.version) return;
+
   try {
+    let latestVersion: string | undefined;
+
     // Check cache TTL
     const cache = await readUpdateCache();
     if (cache && Date.now() - cache.checkedAt < TTL_MS) {
-      // Use cached result
-      if (compareVersions(pkg.version, cache.latestVersion) < 0) {
-        await runInstall(cache.latestVersion);
-      }
-      return;
+      latestVersion = cache.latestVersion;
+    } else {
+      // Fetch latest from registry
+      const fetched = await fetchLatestVersion();
+      if (!fetched) return;
+      latestVersion = fetched;
+      await writeUpdateCache({ checkedAt: Date.now(), latestVersion });
     }
 
-    // Fetch latest from registry
-    const latestVersion = await fetchLatestVersion();
-    if (!latestVersion) return;
-
-    await writeUpdateCache({ checkedAt: Date.now(), latestVersion });
-
     if (compareVersions(pkg.version, latestVersion) < 0) {
-      await runInstall(latestVersion);
+      const installed = await runInstall(latestVersion);
+      if (installed) {
+        reExec(latestVersion);
+      }
     }
   } catch {
     // Silently ignore all errors
   }
 }
 
-async function runInstall(latestVersion: string): Promise<void> {
+async function runInstall(latestVersion: string): Promise<boolean> {
   const pm = detectPackageManager();
-  const installArgs =
+  const installCmd =
     pm === "bun"
       ? `bun add -g agent-yes@${latestVersion}`
       : `npm install -g agent-yes@${latestVersion}`;
 
   process.stderr.write(`\x1b[33m[agent-yes] Updating ${pkg.version} → ${latestVersion}…\x1b[0m\n`);
   try {
-    await execaCommand(installArgs, { stdio: "inherit" });
-    // Clear cache so next run re-checks
-    await writeUpdateCache({ checkedAt: 0, latestVersion });
+    await execaCommand(installCmd, { stdio: "inherit" });
     process.stderr.write(`\x1b[32m[agent-yes] Updated to ${latestVersion}\x1b[0m\n`);
+    return true;
   } catch {
-    process.stderr.write(`\x1b[31m[agent-yes] Auto-update failed. Run: ${installArgs}\x1b[0m\n`);
+    process.stderr.write(`\x1b[31m[agent-yes] Auto-update failed. Run: ${installCmd}\x1b[0m\n`);
+    return false;
+  }
+}
+
+/**
+ * Re-exec the current process so the newly installed version runs.
+ * Sets AGENT_YES_UPDATED=<version> to prevent an infinite loop.
+ */
+function reExec(version: string): never {
+  const [bin, ...args] = process.argv;
+  process.stderr.write(`\x1b[36m[agent-yes] Restarting with v${version}…\x1b[0m\n`);
+  try {
+    execFileSync(bin, args, {
+      stdio: "inherit",
+      env: { ...process.env, AGENT_YES_UPDATED: version },
+    });
+    process.exit(0);
+  } catch (err: any) {
+    process.exit(err.status ?? 1);
   }
 }