agent-yes 1.67.0 → 1.68.1

package/dist/{SUPPORTED_CLIS-CmSMCHW2.js → SUPPORTED_CLIS-Dxapc1qa.js}

@@ -1059,7 +1059,7 @@ function tryCatch(catchFn, fn) {
 //#endregion
 //#region package.json
 var name = "agent-yes";
-var version = "1.67.0";
+var version = "1.68.1";
 
 //#endregion
 //#region ts/pty-fix.ts
@@ -2139,4 +2139,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-CmSMCHW2.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-Dxapc1qa.js.map

package/dist/cli.js

@@ -1,13 +1,15 @@
 #!/usr/bin/env bun
-import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-CmSMCHW2.js";
+import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Dxapc1qa.js";
 import { t as logger } from "./logger-CX77vJDA.js";
 import { argv } from "process";
 import { spawn } from "child_process";
 import ms from "ms";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { chmod, copyFile } from "fs/promises";
+import { execaCommand } from "execa";
+import { chmod, copyFile, mkdir, readFile, writeFile } from "fs/promises";
 import path from "path";
+import { homedir } from "os";
 import { existsSync, mkdirSync, unlinkSync } from "fs";
 
 //#region ts/parseCliArgs.ts
@@ -202,6 +204,62 @@ function parseCliArgs(argv) {
 
 //#endregion
 //#region ts/versionChecker.ts
+const CACHE_DIR = path.join(homedir(), ".cache", "agent-yes");
+const CACHE_FILE = path.join(CACHE_DIR, "update-check.json");
+const TTL_MS = 3600 * 1e3;
+async function readUpdateCache() {
+	try {
+		const raw = await readFile(CACHE_FILE, "utf8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+async function writeUpdateCache(data) {
+	await mkdir(CACHE_DIR, { recursive: true });
+	await writeFile(CACHE_FILE, JSON.stringify(data));
+}
+function detectPackageManager() {
+	if (process.env.BUN_INSTALL || process.env.npm_execpath?.includes("bun")) return "bun";
+	return "npm";
+}
+/**
+* Check for updates and auto-install if a newer version is available.
+* 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.
+*/
+async function checkAndAutoUpdate() {
+	if (process.env.AGENT_YES_NO_UPDATE) return;
+	try {
+		const cache = await readUpdateCache();
+		if (cache && Date.now() - cache.checkedAt < TTL_MS) {
+			if (compareVersions(version, cache.latestVersion) < 0) await runInstall(cache.latestVersion);
+			return;
+		}
+		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}`;
+	process.stderr.write(`\x1b[33m[agent-yes] Updating ${version} → ${latestVersion}…\x1b[0m\n`);
+	try {
+		await execaCommand(installArgs, { stdio: "inherit" });
+		await writeUpdateCache({
+			checkedAt: 0,
+			latestVersion
+		});
+		process.stderr.write(`\x1b[32m[agent-yes] Updated to ${latestVersion}\x1b[0m\n`);
+	} catch {
+		process.stderr.write(`\x1b[31m[agent-yes] Auto-update failed. Run: ${installArgs}\x1b[0m\n`);
+	}
+}
 /**
 * Fetch the latest version of the package from npm registry
 */
@@ -415,37 +473,42 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 
 //#endregion
 //#region ts/cli.ts
+const updateCheckPromise = checkAndAutoUpdate();
 const config = parseCliArgs(process.argv);
 if (config.useRust) {
 	let rustBinary;
 	try {
 		rustBinary = await getRustBinary({ verbose: config.verbose });
 	} catch (err) {
-		console.error(err instanceof Error ? err.message : String(err));
-		process.exit(1);
+		if (config.verbose) {
+			console.error(`[rust] ${err instanceof Error ? err.message : String(err)}`);
+			console.error("[rust] Falling back to TypeScript implementation.");
+		}
 	}
-	const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
-	if (config.verbose) {
-		console.log(`[rust] Using binary: ${rustBinary}`);
-		console.log(`[rust] Args: ${rustArgs.join(" ")}`);
+	if (rustBinary) {
+		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
+		if (config.verbose) {
+			console.log(`[rust] Using binary: ${rustBinary}`);
+			console.log(`[rust] Args: ${rustArgs.join(" ")}`);
+		}
+		const child = spawn(rustBinary, rustArgs, {
+			stdio: "inherit",
+			env: process.env,
+			cwd: process.cwd()
+		});
+		child.on("error", (err) => {
+			if (err.code === "ENOENT") console.error(`Rust binary '${rustBinary}' not found. Try: npx agent-yes --rust --verbose`);
+			else console.error(`Failed to spawn Rust binary: ${err.message}`);
+			process.exit(1);
+		});
+		child.on("exit", (code, signal) => {
+			if (signal) process.exit(128 + (signal === "SIGINT" ? 2 : signal === "SIGTERM" ? 15 : 1));
+			process.exit(code ?? 1);
+		});
+		process.on("SIGINT", () => child.kill("SIGINT"));
+		process.on("SIGTERM", () => child.kill("SIGTERM"));
+		await new Promise(() => {});
 	}
-	const child = spawn(rustBinary, rustArgs, {
-		stdio: "inherit",
-		env: process.env,
-		cwd: process.cwd()
-	});
-	child.on("error", (err) => {
-		if (err.code === "ENOENT") console.error(`Rust binary '${rustBinary}' not found. Try: npx agent-yes --rust --verbose`);
-		else console.error(`Failed to spawn Rust binary: ${err.message}`);
-		process.exit(1);
-	});
-	child.on("exit", (code, signal) => {
-		if (signal) process.exit(128 + (signal === "SIGINT" ? 2 : signal === "SIGTERM" ? 15 : 1));
-		process.exit(code ?? 1);
-	});
-	process.on("SIGINT", () => child.kill("SIGINT"));
-	process.on("SIGTERM", () => child.kill("SIGTERM"));
-	await new Promise(() => {});
 }
 if (config.showVersion) {
 	await displayVersion();
@@ -504,6 +567,7 @@ 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-CmSMCHW2.js";
+import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-Dxapc1qa.js";
 import "./logger-CX77vJDA.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.67.0",
+  "version": "1.68.1",
   "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

@@ -5,62 +5,65 @@ import { parseCliArgs } from "./parseCliArgs.ts";
 import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
 import { logger } from "./logger.ts";
 import { PidStore } from "./pidStore.ts";
-import { displayVersion } from "./versionChecker.ts";
+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();
+
 // Parse CLI arguments
 const config = parseCliArgs(process.argv);
 
-// Handle --rust: spawn the Rust binary instead
+// Handle --rust: spawn the Rust binary instead, fall back to TypeScript if unavailable
 if (config.useRust) {
-  let rustBinary: string;
+  let rustBinary: string | undefined;
 
   try {
-    // Get or download the Rust binary for the current platform
     rustBinary = await getRustBinary({ verbose: config.verbose });
   } catch (err) {
-    console.error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-  }
-
-  // Build args for Rust binary
-  const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
-
-  if (config.verbose) {
-    console.log(`[rust] Using binary: ${rustBinary}`);
-    console.log(`[rust] Args: ${rustArgs.join(" ")}`);
+    // Rust binary unavailable (not yet released for this version, or network issue) — fall back to TypeScript
+    if (config.verbose) {
+      console.error(`[rust] ${err instanceof Error ? err.message : String(err)}`);
+      console.error("[rust] Falling back to TypeScript implementation.");
+    }
   }
 
-  // Spawn the Rust process with stdio inheritance
-  const child = spawn(rustBinary, rustArgs, {
-    stdio: "inherit",
-    env: process.env,
-    cwd: process.cwd(),
-  });
-
-  child.on("error", (err) => {
-    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
-      console.error(`Rust binary '${rustBinary}' not found. Try: npx agent-yes --rust --verbose`);
-    } else {
-      console.error(`Failed to spawn Rust binary: ${err.message}`);
-    }
-    process.exit(1);
-  });
+  if (rustBinary) {
+    const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 
-  child.on("exit", (code, signal) => {
-    if (signal) {
-      process.exit(128 + (signal === "SIGINT" ? 2 : signal === "SIGTERM" ? 15 : 1));
+    if (config.verbose) {
+      console.log(`[rust] Using binary: ${rustBinary}`);
+      console.log(`[rust] Args: ${rustArgs.join(" ")}`);
     }
-    process.exit(code ?? 1);
-  });
-
-  // Forward signals to child
-  process.on("SIGINT", () => child.kill("SIGINT"));
-  process.on("SIGTERM", () => child.kill("SIGTERM"));
 
-  // Keep the process alive while child is running
-  await new Promise(() => {}); // Never resolves, exits via child.on("exit")
+    const child = spawn(rustBinary, rustArgs, {
+      stdio: "inherit",
+      env: process.env,
+      cwd: process.cwd(),
+    });
+
+    child.on("error", (err) => {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+        console.error(`Rust binary '${rustBinary}' not found. Try: npx agent-yes --rust --verbose`);
+      } else {
+        console.error(`Failed to spawn Rust binary: ${err.message}`);
+      }
+      process.exit(1);
+    });
+
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        process.exit(128 + (signal === "SIGINT" ? 2 : signal === "SIGTERM" ? 15 : 1));
+      }
+      process.exit(code ?? 1);
+    });
+
+    process.on("SIGINT", () => child.kill("SIGINT"));
+    process.on("SIGTERM", () => child.kill("SIGTERM"));
+
+    await new Promise(() => {}); // Never resolves, exits via child.on("exit")
+  }
 }
 
 // Handle --version: display version and exit
@@ -134,5 +137,9 @@ 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/versionChecker.spec.ts

@@ -1,5 +1,17 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-import { compareVersions, fetchLatestVersion, displayVersion } from "./versionChecker";
+import {
+  checkAndAutoUpdate,
+  compareVersions,
+  fetchLatestVersion,
+  displayVersion,
+} from "./versionChecker";
+
+vi.mock("execa", () => ({ execaCommand: vi.fn().mockResolvedValue({}) }));
+vi.mock("fs/promises", () => ({
+  mkdir: vi.fn().mockResolvedValue(undefined),
+  readFile: vi.fn(),
+  writeFile: vi.fn().mockResolvedValue(undefined),
+}));
 
 describe("versionChecker", () => {
   describe("compareVersions", () => {
@@ -64,6 +76,107 @@ describe("versionChecker", () => {
     });
   });
 
+  describe("checkAndAutoUpdate", () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+      vi.stubGlobal("fetch", vi.fn());
+      vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+      delete process.env.AGENT_YES_NO_UPDATE;
+      delete process.env.BUN_INSTALL;
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it("should skip when AGENT_YES_NO_UPDATE is set", async () => {
+      process.env.AGENT_YES_NO_UPDATE = "1";
+      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(
+        JSON.stringify({ checkedAt: Date.now(), latestVersion: "0.0.1" }) as any,
+      );
+      await checkAndAutoUpdate();
+      expect(fetch).not.toHaveBeenCalled();
+      expect(process.stderr.write).not.toHaveBeenCalled();
+    });
+
+    it("should install from cache when cached version is newer and within TTL", async () => {
+      const { readFile } = await import("fs/promises");
+      const { execaCommand } = await import("execa");
+      vi.mocked(readFile).mockResolvedValueOnce(
+        JSON.stringify({ checkedAt: Date.now(), latestVersion: "999.0.0" }) as any,
+      );
+      await checkAndAutoUpdate();
+      expect(execaCommand).toHaveBeenCalled();
+    });
+
+    it("should fetch and write cache when stale, install if behind", async () => {
+      const { readFile, writeFile } = await import("fs/promises");
+      const { execaCommand } = await import("execa");
+      vi.mocked(readFile).mockRejectedValueOnce(new Error("no cache"));
+      vi.mocked(fetch).mockResolvedValue({
+        ok: true,
+        json: async () => ({ version: "999.0.0" }),
+      } as Response);
+      await checkAndAutoUpdate();
+      expect(writeFile).toHaveBeenCalled();
+      expect(execaCommand).toHaveBeenCalled();
+    });
+
+    it("should fetch and write cache but not install if up-to-date", async () => {
+      const { readFile, writeFile } = await import("fs/promises");
+      const { execaCommand } = await import("execa");
+      vi.mocked(readFile).mockRejectedValueOnce(new Error("no cache"));
+      vi.mocked(fetch).mockResolvedValue({
+        ok: true,
+        json: async () => ({ version: "0.0.1" }),
+      } as Response);
+      await checkAndAutoUpdate();
+      expect(writeFile).toHaveBeenCalled();
+      expect(execaCommand).not.toHaveBeenCalled();
+    });
+
+    it("should silently handle fetch failure", async () => {
+      const { readFile } = await import("fs/promises");
+      vi.mocked(readFile).mockRejectedValueOnce(new Error("no cache"));
+      vi.mocked(fetch).mockRejectedValue(new Error("network error"));
+      await expect(checkAndAutoUpdate()).resolves.toBeUndefined();
+    });
+
+    it("should use bun when BUN_INSTALL is set", async () => {
+      process.env.BUN_INSTALL = "/home/user/.bun";
+      const { readFile } = await import("fs/promises");
+      const { execaCommand } = await import("execa");
+      vi.mocked(readFile).mockRejectedValueOnce(new Error("no cache"));
+      vi.mocked(fetch).mockResolvedValue({
+        ok: true,
+        json: async () => ({ version: "999.0.0" }),
+      } as Response);
+      await checkAndAutoUpdate();
+      expect(vi.mocked(execaCommand).mock.calls[0]?.[0]).toContain("bun");
+    });
+
+    it("should print error and not throw when install fails", async () => {
+      const { readFile } = await import("fs/promises");
+      const { execaCommand } = await import("execa");
+      vi.mocked(readFile).mockRejectedValueOnce(new Error("no cache"));
+      vi.mocked(fetch).mockResolvedValue({
+        ok: true,
+        json: async () => ({ version: "999.0.0" }),
+      } as Response);
+      vi.mocked(execaCommand).mockRejectedValueOnce(new Error("install failed"));
+      await expect(checkAndAutoUpdate()).resolves.toBeUndefined();
+      expect(process.stderr.write).toHaveBeenCalledWith(
+        expect.stringContaining("Auto-update failed"),
+      );
+    });
+  });
+
   describe("displayVersion", () => {
     beforeEach(() => {
       vi.stubGlobal("fetch", vi.fn());

package/ts/versionChecker.ts

@@ -1,5 +1,86 @@
+import { execaCommand } from "execa";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
 import pkg from "../package.json" with { type: "json" };
 
+const CACHE_DIR = path.join(homedir(), ".cache", "agent-yes");
+const CACHE_FILE = path.join(CACHE_DIR, "update-check.json");
+const TTL_MS = 60 * 60 * 1000; // 1 hour
+
+type UpdateCache = { checkedAt: number; latestVersion: string };
+
+async function readUpdateCache(): Promise<UpdateCache | null> {
+  try {
+    const raw = await readFile(CACHE_FILE, "utf8");
+    return JSON.parse(raw) as UpdateCache;
+  } catch {
+    return null;
+  }
+}
+
+async function writeUpdateCache(data: UpdateCache): Promise<void> {
+  await mkdir(CACHE_DIR, { recursive: true });
+  await writeFile(CACHE_FILE, JSON.stringify(data));
+}
+
+function detectPackageManager(): string {
+  if (process.env.BUN_INSTALL || process.env.npm_execpath?.includes("bun")) return "bun";
+  return "npm";
+}
+
+/**
+ * Check for updates and auto-install if a newer version is available.
+ * 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.
+ */
+export async function checkAndAutoUpdate(): Promise<void> {
+  if (process.env.AGENT_YES_NO_UPDATE) return;
+
+  try {
+    // 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;
+    }
+
+    // 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);
+    }
+  } catch {
+    // Silently ignore all errors
+  }
+}
+
+async function runInstall(latestVersion: string): Promise<void> {
+  const pm = detectPackageManager();
+  const installArgs =
+    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 });
+    process.stderr.write(`\x1b[32m[agent-yes] Updated to ${latestVersion}\x1b[0m\n`);
+  } catch {
+    process.stderr.write(`\x1b[31m[agent-yes] Auto-update failed. Run: ${installArgs}\x1b[0m\n`);
+  }
+}
+
 /**
  * Fetch the latest version of the package from npm registry
  */