agent-yes 1.75.2 → 1.76.0

package/dist/{SUPPORTED_CLIS-C2w9JqbM.js → SUPPORTED_CLIS-DAufh-XY.js}

@@ -1,5 +1,6 @@
-import { t as CLIS_CONFIG } from "./ts-Cuys5-PF.js";
+import { t as CLIS_CONFIG } from "./ts-MmVGVMOz.js";
 import "./logger-B9h0djqx.js";
+import "./versionChecker-CAoC4Jzx.js";
 import "./pidStore-C1JXxoPi.js";
 import "./globalPidIndex-Cr-g75QF.js";
 
@@ -8,4 +9,4 @@ const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS };
-//# sourceMappingURL=SUPPORTED_CLIS-C2w9JqbM.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-DAufh-XY.js.map

package/dist/agent-yes.js

@@ -1,2 +1,10 @@
 #!/usr/bin/env bun
-await import('./cli.js')
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+if (existsSync(join(root, ".git"))) {
+  await import("../ts/cli.ts");
+} else {
+  await import("./cli.js");
+}

package/dist/amp-yes.js

@@ -1,2 +1,10 @@
 #!/usr/bin/env bun
-await import('./cli.js')
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+if (existsSync(join(root, ".git"))) {
+  await import("../ts/cli.ts");
+} else {
+  await import("./cli.js");
+}

package/dist/auggie-yes.js

@@ -1,2 +1,10 @@
 #!/usr/bin/env bun
-await import('./cli.js')
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+if (existsSync(join(root, ".git"))) {
+  await import("../ts/cli.ts");
+} else {
+  await import("./cli.js");
+}

package/dist/claude-yes.js

@@ -1,2 +1,10 @@
 #!/usr/bin/env bun
-await import('./cli.js')
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+if (existsSync(join(root, ".git"))) {
+  await import("../ts/cli.ts");
+} else {
+  await import("./cli.js");
+}

package/dist/cli.js

@@ -1,14 +1,13 @@
 #!/usr/bin/env bun
 import { n as logger } from "./logger-B9h0djqx.js";
-import { n as version, t as name } from "./package-8zpT1iww.js";
+import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-CAoC4Jzx.js";
 import { argv } from "process";
 import { execFileSync, spawn } from "child_process";
 import ms from "ms";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { existsSync, lstatSync, mkdirSync, readlinkSync, unlinkSync } from "fs";
-import { chmod, copyFile, mkdir, readFile, writeFile } from "fs/promises";
-import { homedir } from "os";
+import { existsSync, mkdirSync, unlinkSync } from "fs";
+import { chmod, copyFile } from "fs/promises";
 import path from "path";
 
 //#region ts/parseCliArgs.ts
@@ -237,176 +236,6 @@ function parseCliArgs(argv, supportedClis) {
 	};
 }
 
-//#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.execPath?.includes("bun") || process.env.npm_execpath?.includes("bun")) return "bun";
-	return "npm";
-}
-/**
-* 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) return;
-	if (import.meta.url.startsWith("file://") && !import.meta.url.includes("node_modules")) {
-		const scriptDir = path.dirname(new URL(import.meta.url).pathname);
-		const repoRoot = path.resolve(scriptDir, "..");
-		if (existsSync(path.join(repoRoot, ".git"))) return;
-	}
-	try {
-		let latestVersion;
-		const cache = await readUpdateCache();
-		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);
-		}
-	} catch {}
-}
-async function runInstall(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 {
-		const { execaCommand } = await import("execa");
-		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: ${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);
-	}
-}
-/**
-* Fetch the latest version of the package from npm registry
-*/
-async function fetchLatestVersion() {
-	try {
-		const response = await fetch(`https://registry.npmjs.org/${name}/latest`, { signal: AbortSignal.timeout(3e3) });
-		if (!response.ok) return null;
-		return (await response.json()).version;
-	} catch {
-		return null;
-	}
-}
-/**
-* Compare two semantic versions
-* Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
-*/
-function compareVersions(v1, v2) {
-	const parts1 = v1.split(".").map(Number);
-	const parts2 = v2.split(".").map(Number);
-	for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
-		const part1 = parts1[i] || 0;
-		const part2 = parts2[i] || 0;
-		if (part1 > part2) return 1;
-		if (part1 < part2) return -1;
-	}
-	return 0;
-}
-/**
-* Detect how agent-yes was installed.
-* Returns a short label: "git", "bun link", "bun", "npm", "npx", or "unknown"
-*/
-function detectInstallMethod() {
-	try {
-		const scriptDir = path.dirname(new URL(import.meta.url).pathname);
-		if (!scriptDir.includes("node_modules")) {
-			const repoRoot = path.resolve(scriptDir, "..");
-			if (existsSync(path.join(repoRoot, ".git"))) return "git";
-			return "source";
-		}
-		const nodeModulesEntry = scriptDir.replace(/\/dist$/, "");
-		try {
-			if (lstatSync(nodeModulesEntry).isSymbolicLink()) {
-				const target = readlinkSync(nodeModulesEntry);
-				const resolvedTarget = path.resolve(path.dirname(nodeModulesEntry), target);
-				if (existsSync(path.join(resolvedTarget, ".git"))) return "bun link (git)";
-				return "bun link";
-			}
-		} catch {}
-		if (scriptDir.includes(".bun/")) return "bun";
-		if (scriptDir.includes(".npm/")) return "npx";
-		if (process.env.npm_execpath?.includes("bun")) return "bun";
-		if (process.env.npm_config_user_agent?.startsWith("bun")) return "bun";
-		if (process.env.npm_config_user_agent?.startsWith("npm")) return "npm";
-		return "npm";
-	} catch {
-		return "unknown";
-	}
-}
-/**
-* Format version string with install method
-*/
-function versionString() {
-	return `agent-yes v${version} (${detectInstallMethod()})`;
-}
-/**
-* Display version information with async latest version check
-*/
-async function displayVersion() {
-	console.log(versionString());
-	const latestVersion = await fetchLatestVersion();
-	if (latestVersion) {
-		const comparison = compareVersions(version, latestVersion);
-		if (comparison < 0) console.log(`\x1b[33m${latestVersion} (update available)\x1b[0m`);
-		else if (comparison > 0) console.log(`${latestVersion} (latest published)`);
-		else console.log(`${latestVersion} (latest)`);
-	} else console.log("(unable to check for updates)");
-}
-
 //#endregion
 //#region ts/rustBinary.ts
 /**
@@ -552,7 +381,7 @@ function getRustBinaryVersion(binaryPath) {
 				"ignore"
 			]
 		}).match(/(\d+\.\d+\.\d+)/);
-		return match ? match[1] : null;
+		return match ? match[1] ?? null : null;
 	} catch {
 		return null;
 	}
@@ -564,20 +393,31 @@ function getRustBinaryVersion(binaryPath) {
 function autoRebuildIfOutdated(binaryPath, verbose) {
 	if (!binaryPath.includes("/target/release") && !binaryPath.includes("/target/debug")) return true;
 	const binaryVersion = getRustBinaryVersion(binaryPath);
-	if (verbose) console.log(`[rust] Binary version: ${binaryVersion}, package version: ${version}`);
-	if (binaryVersion === version) return true;
+	const pkgVersion = getInstalledPackage().version;
+	if (verbose) console.log(`[rust] Binary version: ${binaryVersion}, package version: ${pkgVersion}`);
+	if (binaryVersion === pkgVersion) return true;
 	const rsDir = binaryPath.replace(/\/target\/(release|debug)\/agent-yes.*$/, "");
 	if (!existsSync(path.join(rsDir, "Cargo.toml"))) {
 		if (verbose) console.log(`[rust] Cannot find Cargo.toml at ${rsDir}, skipping rebuild`);
 		return true;
 	}
-	process.stderr.write(`\x1b[33m[rust] Binary outdated (${binaryVersion ?? "unknown"} → ${version}), rebuilding…\x1b[0m\n`);
+	process.stderr.write(`\x1b[33m[rust] Binary outdated (${binaryVersion ?? "unknown"} → ${pkgVersion}), rebuilding…\x1b[0m\n`);
 	try {
 		execFileSync("cargo", ["build", ...binaryPath.includes("/target/release") ? ["--release"] : []], {
 			cwd: rsDir,
 			stdio: "inherit",
 			timeout: 3e5
 		});
+		try {
+			execFileSync("cargo", [
+				"install",
+				"--path",
+				rsDir
+			], {
+				stdio: "inherit",
+				timeout: 6e4
+			});
+		} catch {}
 		process.stderr.write(`\x1b[32m[rust] Rebuild complete\x1b[0m\n`);
 		return true;
 	} catch {
@@ -645,12 +485,12 @@ await checkAndAutoUpdate();
 logger.info(versionString());
 const config = parseCliArgs(process.argv);
 if (config.tray) {
-	const { startTray } = await import("./tray-D5deJPjk.js");
+	const { startTray } = await import("./tray-CH_G7aXM.js");
 	await startTray();
 	await new Promise(() => {});
 }
 {
-	const { ensureTray } = await import("./tray-D5deJPjk.js");
+	const { ensureTray } = await import("./tray-CH_G7aXM.js");
 	ensureTray();
 }
 if (config.useRust) {
@@ -664,7 +504,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-C2w9JqbM.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-DAufh-XY.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);

package/dist/codex-yes.js

@@ -1,2 +1,10 @@
 #!/usr/bin/env bun
-await import('./cli.js')
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+if (existsSync(join(root, ".git"))) {
+  await import("../ts/cli.ts");
+} else {
+  await import("./cli.js");
+}

package/dist/copilot-yes.js

@@ -1,2 +1,10 @@
 #!/usr/bin/env bun
-await import('./cli.js')
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+if (existsSync(join(root, ".git"))) {
+  await import("../ts/cli.ts");
+} else {
+  await import("./cli.js");
+}

package/dist/cursor-yes.js

@@ -1,2 +1,10 @@
 #!/usr/bin/env bun
-await import('./cli.js')
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+if (existsSync(join(root, ".git"))) {
+  await import("../ts/cli.ts");
+} else {
+  await import("./cli.js");
+}

package/dist/cy.js

@@ -1,2 +1,10 @@
 #!/usr/bin/env bun
-await import('./cli.js')
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+if (existsSync(join(root, ".git"))) {
+  await import("../ts/cli.ts");
+} else {
+  await import("./cli.js");
+}

package/dist/gemini-yes.js

@@ -1,2 +1,10 @@
 #!/usr/bin/env bun
-await import('./cli.js')
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+if (existsSync(join(root, ".git"))) {
+  await import("../ts/cli.ts");
+} else {
+  await import("./cli.js");
+}

package/dist/grok-yes.js

@@ -1,2 +1,10 @@
 #!/usr/bin/env bun
-await import('./cli.js')
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+if (existsSync(join(root, ".git"))) {
+  await import("../ts/cli.ts");
+} else {
+  await import("./cli.js");
+}

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-Cuys5-PF.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-MmVGVMOz.js";
 import "./logger-B9h0djqx.js";
+import "./versionChecker-CAoC4Jzx.js";
 import "./pidStore-C1JXxoPi.js";
 import "./globalPidIndex-Cr-g75QF.js";
 

package/dist/opencode-yes.js

@@ -1,2 +1,10 @@
 #!/usr/bin/env bun
-await import('./cli.js')
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+if (existsSync(join(root, ".git"))) {
+  await import("../ts/cli.ts");
+} else {
+  await import("./cli.js");
+}

package/dist/qwen-yes.js

@@ -1,2 +1,10 @@
 #!/usr/bin/env bun
-await import('./cli.js')
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+if (existsSync(join(root, ".git"))) {
+  await import("../ts/cli.ts");
+} else {
+  await import("./cli.js");
+}

package/dist/{runningLock-DQWJSptq.js → runningLock-C22d9SRJ.js}

@@ -28,6 +28,21 @@ function isProcessRunning(pid) {
 	}
 }
 /**
+* Build an env that scrubs inherited GIT_* repo-locating vars so the spawned
+* `git` resolves the repo from `cwd` only. Without this, running inside a git
+* hook (where GIT_DIR / GIT_INDEX_FILE / GIT_WORK_TREE / GIT_COMMON_DIR are
+* exported) makes `git rev-parse --show-toplevel` use the hook's repo context
+* instead of the requested directory.
+*/
+function gitCleanEnv() {
+	const env = { ...process.env };
+	delete env.GIT_DIR;
+	delete env.GIT_WORK_TREE;
+	delete env.GIT_INDEX_FILE;
+	delete env.GIT_COMMON_DIR;
+	return env;
+}
+/**
 * Get git repository root for a directory
 */
 function getGitRoot(cwd) {
@@ -39,7 +54,8 @@ function getGitRoot(cwd) {
 				"pipe",
 				"pipe",
 				"ignore"
-			]
+			],
+			env: gitCleanEnv()
 		}).trim();
 	} catch {
 		return null;
@@ -260,4 +276,4 @@ function shouldUseLock(_cwd) {
 
 //#endregion
 export { shouldUseLock as i, getRunningAgentCount as n, releaseLock as r, acquireLock as t };
-//# sourceMappingURL=runningLock-DQWJSptq.js.map
+//# sourceMappingURL=runningLock-C22d9SRJ.js.map

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

@@ -1,4 +1,4 @@
-import { n as getRunningAgentCount } from "./runningLock-DQWJSptq.js";
+import { n as getRunningAgentCount } from "./runningLock-C22d9SRJ.js";
 import { existsSync } from "fs";
 import { mkdir, readFile, unlink, writeFile } from "fs/promises";
 import { homedir } from "os";
@@ -175,4 +175,4 @@ async function startTray() {
 
 //#endregion
 export { ensureTray, startTray };
-//# sourceMappingURL=tray-D5deJPjk.js.map
+//# sourceMappingURL=tray-CH_G7aXM.js.map

package/dist/{ts-Cuys5-PF.js → ts-MmVGVMOz.js}

@@ -1,6 +1,6 @@
 import { n as logger, t as addTransport } from "./logger-B9h0djqx.js";
-import { n as version } from "./package-8zpT1iww.js";
-import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-DQWJSptq.js";
+import { r as getInstalledPackage } from "./versionChecker-CAoC4Jzx.js";
+import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-C22d9SRJ.js";
 import { t as PidStore } from "./pidStore-C1JXxoPi.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
@@ -8,6 +8,7 @@ import { closeSync, constants, createReadStream, existsSync, mkdirSync, openSync
 import { mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path, { dirname, join } from "path";
+import { fileURLToPath } from "url";
 import { execaCommandSync, parseCommandString } from "execa";
 import { fromReadable, fromWritable } from "from-node-stream";
 import DIE from "phpdie";
@@ -15,7 +16,6 @@ import sflow from "sflow";
 import xterm from "@xterm/headless";
 import { createServer } from "net";
 import { execSync as execSync$1 } from "node:child_process";
-import { fileURLToPath } from "url";
 import os from "node:os";
 import { readFile as readFile$1 } from "node:fs/promises";
 import path$1 from "node:path";
@@ -775,7 +775,7 @@ function spawnAgent(options) {
 		let [bin, ...args] = [...parseCommandString(cliConf?.binary || cli), ...cliArgs];
 		logger.debug(`Spawning ${bin} with args: ${JSON.stringify(args)}`);
 		const spawned = pty.spawn(bin, args, ptyOptions);
-		logger.info(`[${cli}-yes] Spawned ${bin} with PID ${spawned.pid} (agent-yes v${version})`);
+		logger.info(`[${cli}-yes] Spawned ${bin} with PID ${spawned.pid} (agent-yes v${getInstalledPackage().version})`);
 		return spawned;
 	};
 	return tryCatch((error, attempts, spawn, ...args) => {
@@ -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-Cuys5-PF.js.map
+//# sourceMappingURL=ts-MmVGVMOz.js.map

package/dist/versionChecker-CAoC4Jzx.js

@@ -0,0 +1,224 @@
+import { execFileSync } from "child_process";
+import { existsSync, lstatSync, readFileSync, readlinkSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+
+//#region package.json
+var name = "agent-yes";
+var version = "1.76.0";
+
+//#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;
+const CANONICAL_PKG_NAME = "agent-yes";
+let cachedInstalledPkg = null;
+/**
+* Read the live `package.json` from disk for the running module.
+*
+* The bundled `package.json` import is inlined at build time; if `dist/` is
+* published without a fresh build (issue #39), the inlined `version` lies
+* and the auto-update loop fires forever. Reading the on-disk manifest each
+* run keeps the version honest even when the bundle is stale.
+*/
+function getInstalledPackage() {
+	if (cachedInstalledPkg) return cachedInstalledPkg;
+	let dir = null;
+	try {
+		dir = path.dirname(fileURLToPath(import.meta.url));
+	} catch {}
+	if (dir) for (let i = 0; i < 6; i++) {
+		const candidate = path.join(dir, "package.json");
+		try {
+			if (existsSync(candidate)) {
+				const json = JSON.parse(readFileSync(candidate, "utf8"));
+				if (json.name === name && typeof json.version === "string") {
+					cachedInstalledPkg = {
+						name: json.name,
+						version: json.version
+					};
+					return cachedInstalledPkg;
+				}
+			}
+		} catch {}
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	cachedInstalledPkg = {
+		name,
+		version
+	};
+	return cachedInstalledPkg;
+}
+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.execPath?.includes("bun") || process.env.npm_execpath?.includes("bun")) return "bun";
+	return "npm";
+}
+/**
+* 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) return;
+	if (import.meta.url.startsWith("file://") && !import.meta.url.includes("node_modules")) {
+		const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+		const repoRoot = path.resolve(scriptDir, "..");
+		if (existsSync(path.join(repoRoot, ".git"))) return;
+	}
+	try {
+		let latestVersion;
+		const cache = await readUpdateCache();
+		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(getInstalledPackage().version, latestVersion) < 0) {
+			if (await runInstall(latestVersion)) reExec(latestVersion);
+		}
+	} catch {}
+}
+async function runInstall(latestVersion) {
+	const installCmd = detectPackageManager() === "bun" ? `bun add -g ${CANONICAL_PKG_NAME}@${latestVersion}` : `npm install -g ${CANONICAL_PKG_NAME}@${latestVersion}`;
+	process.stderr.write(`\x1b[33m[agent-yes] Updating ${getInstalledPackage().version} → ${latestVersion}…\x1b[0m\n`);
+	try {
+		const { execaCommand } = await import("execa");
+		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: ${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);
+	}
+}
+/**
+* Fetch the latest version of the package from npm registry
+*/
+async function fetchLatestVersion() {
+	try {
+		const response = await fetch(`https://registry.npmjs.org/${CANONICAL_PKG_NAME}/latest`, { signal: AbortSignal.timeout(3e3) });
+		if (!response.ok) return null;
+		return (await response.json()).version;
+	} catch {
+		return null;
+	}
+}
+/**
+* Compare two semantic versions
+* Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+*/
+function compareVersions(v1, v2) {
+	const parts1 = v1.split(".").map(Number);
+	const parts2 = v2.split(".").map(Number);
+	for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+		const part1 = parts1[i] || 0;
+		const part2 = parts2[i] || 0;
+		if (part1 > part2) return 1;
+		if (part1 < part2) return -1;
+	}
+	return 0;
+}
+/**
+* Detect how agent-yes was installed.
+* Returns a short label: "git", "bun link", "bun", "npm", "npx", or "unknown"
+*/
+function detectInstallMethod() {
+	try {
+		const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+		if (!scriptDir.includes("node_modules")) {
+			const repoRoot = path.resolve(scriptDir, "..");
+			if (existsSync(path.join(repoRoot, ".git"))) return "git";
+			return "source";
+		}
+		const nodeModulesEntry = scriptDir.replace(/\/dist$/, "");
+		try {
+			if (lstatSync(nodeModulesEntry).isSymbolicLink()) {
+				const target = readlinkSync(nodeModulesEntry);
+				const resolvedTarget = path.resolve(path.dirname(nodeModulesEntry), target);
+				if (existsSync(path.join(resolvedTarget, ".git"))) return "bun link (git)";
+				return "bun link";
+			}
+		} catch {}
+		if (scriptDir.includes(".bun/")) return "bun";
+		if (scriptDir.includes(".npm/")) return "npx";
+		if (process.env.npm_execpath?.includes("bun")) return "bun";
+		if (process.env.npm_config_user_agent?.startsWith("bun")) return "bun";
+		if (process.env.npm_config_user_agent?.startsWith("npm")) return "npm";
+		return "npm";
+	} catch {
+		return "unknown";
+	}
+}
+/**
+* Format version string with install method
+*/
+function versionString() {
+	return `agent-yes v${getInstalledPackage().version} (${detectInstallMethod()})`;
+}
+/**
+* Display version information with async latest version check
+*/
+async function displayVersion() {
+	console.log(versionString());
+	const latestVersion = await fetchLatestVersion();
+	if (latestVersion) {
+		const comparison = compareVersions(getInstalledPackage().version, latestVersion);
+		if (comparison < 0) console.log(`\x1b[33m${latestVersion} (update available)\x1b[0m`);
+		else if (comparison > 0) console.log(`${latestVersion} (latest published)`);
+		else console.log(`${latestVersion} (latest)`);
+	} else console.log("(unable to check for updates)");
+}
+
+//#endregion
+export { versionString as i, displayVersion as n, getInstalledPackage as r, checkAndAutoUpdate as t };
+//# sourceMappingURL=versionChecker-CAoC4Jzx.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.75.2",
+  "version": "1.76.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",
@@ -77,7 +77,7 @@
     "fmt": "oxlint --fix --fix-suggestions && oxfmt",
     "verify-deps": "node ./scripts/verify-deps.js",
     "_prepack": "bun run build",
-    "prepublishOnly": "npm run verify-deps",
+    "prepublishOnly": "bun run build && npm run verify-deps",
     "prepare": "husky",
     "release": "standard-version && npm publish",
     "release:beta": "standard-version && npm publish --tag beta",

package/ts/postbuild.ts

@@ -15,18 +15,26 @@ const suffixes = ["-yes"];
 // Short aliases: maps alias name → target CLI name (alias resolves in parseCliArgs.ts)
 const shortAliases: Record<string, string> = { cy: "claude" };
 
+// When .git exists (git clone), run TypeScript directly via bun — no build needed.
+// When absent (npm install), fall back to compiled dist/cli.js.
+const wrapperContent = `\
+#!/usr/bin/env bun
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+if (existsSync(join(root, ".git"))) {
+  await import("../ts/cli.ts");
+} else {
+  await import("./cli.js");
+}`;
+
 await sflow(cliNames.flatMap((cli) => suffixes.map((suffix) => ({ cli, suffix }))))
   .map(async ({ cli, suffix }) => {
     const cliName = `${cli}${suffix}`;
 
     const wrapperPath = `./dist/${cliName}.js`;
-    await writeFile(
-      wrapperPath,
-      `
-#!/usr/bin/env bun
-await import('./cli.js')
-`.trim(),
-    );
+    await writeFile(wrapperPath, wrapperContent);
     await chmod(wrapperPath, 0o755);
 
     // Only register -yes variants in package.json bin
@@ -41,13 +49,7 @@ await import('./cli.js')
 // Generate short alias wrapper files
 for (const [alias] of Object.entries(shortAliases)) {
   const wrapperPath = `./dist/${alias}.js`;
-  await writeFile(
-    wrapperPath,
-    `
-#!/usr/bin/env bun
-await import('./cli.js')
-`.trim(),
-  );
+  await writeFile(wrapperPath, wrapperContent);
   await chmod(wrapperPath, 0o755);
   if (!(pkg.bin as Record<string, string>)?.[alias]) {
     await Bun.$`npm pkg set ${"bin." + alias}=${wrapperPath}`;

package/ts/runningLock.ts

@@ -43,6 +43,22 @@ function isProcessRunning(pid: number): boolean {
   }
 }
 
+/**
+ * Build an env that scrubs inherited GIT_* repo-locating vars so the spawned
+ * `git` resolves the repo from `cwd` only. Without this, running inside a git
+ * hook (where GIT_DIR / GIT_INDEX_FILE / GIT_WORK_TREE / GIT_COMMON_DIR are
+ * exported) makes `git rev-parse --show-toplevel` use the hook's repo context
+ * instead of the requested directory.
+ */
+function gitCleanEnv(): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = { ...process.env };
+  delete env.GIT_DIR;
+  delete env.GIT_WORK_TREE;
+  delete env.GIT_INDEX_FILE;
+  delete env.GIT_COMMON_DIR;
+  return env;
+}
+
 /**
  * Get git repository root for a directory
  */
@@ -52,6 +68,7 @@ function getGitRoot(cwd: string): string | null {
       cwd,
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"],
+      env: gitCleanEnv(),
     });
     return result.trim();
   } catch {

package/ts/rustBinary.ts

@@ -6,7 +6,7 @@ import { execFileSync } from "child_process";
 import { existsSync, mkdirSync, unlinkSync } from "fs";
 import { chmod, copyFile } from "fs/promises";
 import path from "path";
-import pkg from "../package.json" with { type: "json" };
+import { getInstalledPackage } from "./versionChecker.ts";
 
 // Platform/arch to binary name mapping
 const PLATFORM_MAP: Record<string, string> = {
@@ -206,7 +206,7 @@ function getRustBinaryVersion(binaryPath: string): string | null {
     });
     // Output is like "agent-yes 1.72.3" or "agent-yes v1.72.3"
     const match = output.match(/(\d+\.\d+\.\d+)/);
-    return match ? match[1] : null;
+    return match ? (match[1] ?? null) : null;
   } catch {
     return null;
   }
@@ -223,11 +223,12 @@ function autoRebuildIfOutdated(binaryPath: string, verbose: boolean): boolean {
   }
 
   const binaryVersion = getRustBinaryVersion(binaryPath);
+  const pkgVersion = getInstalledPackage().version;
   if (verbose) {
-    console.log(`[rust] Binary version: ${binaryVersion}, package version: ${pkg.version}`);
+    console.log(`[rust] Binary version: ${binaryVersion}, package version: ${pkgVersion}`);
   }
 
-  if (binaryVersion === pkg.version) {
+  if (binaryVersion === pkgVersion) {
     return true; // up to date
   }
 
@@ -239,7 +240,7 @@ function autoRebuildIfOutdated(binaryPath: string, verbose: boolean): boolean {
   }
 
   process.stderr.write(
-    `\x1b[33m[rust] Binary outdated (${binaryVersion ?? "unknown"} → ${pkg.version}), rebuilding…\x1b[0m\n`,
+    `\x1b[33m[rust] Binary outdated (${binaryVersion ?? "unknown"} → ${pkgVersion}), rebuilding…\x1b[0m\n`,
   );
 
   try {
@@ -250,6 +251,15 @@ function autoRebuildIfOutdated(binaryPath: string, verbose: boolean): boolean {
       stdio: "inherit",
       timeout: 300_000, // 5 min max
     });
+    // Also update ~/.cargo/bin so the system-wide binary stays current
+    try {
+      execFileSync("cargo", ["install", "--path", rsDir], {
+        stdio: "inherit",
+        timeout: 60_000,
+      });
+    } catch {
+      // non-fatal: the target/ binary is already updated
+    }
     process.stderr.write(`\x1b[32m[rust] Rebuild complete\x1b[0m\n`);
     return true;
   } catch {

package/ts/versionChecker.spec.ts

@@ -1,12 +1,14 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
 import {
+  _setInstalledPackageForTesting,
   checkAndAutoUpdate,
   compareVersions,
   fetchLatestVersion,
   displayVersion,
   detectInstallMethod,
+  getInstalledPackage,
   versionString,
-} from "./versionChecker";
+} from "./versionChecker.ts";
 
 vi.mock("execa", () => ({ execaCommand: vi.fn().mockResolvedValue({}) }));
 vi.mock("fs/promises", () => ({
@@ -18,8 +20,12 @@ vi.mock("fs", async (importOriginal) => {
   const actual = await importOriginal<typeof import("fs")>();
   return {
     ...actual,
-    // Return false for .git checks so the dev-checkout guard doesn't skip auto-update in tests
+    // Return false for .git / package.json lookups so neither the dev-checkout
+    // guard nor getInstalledPackage's disk read fires during the auto-update tests.
     existsSync: vi.fn(() => false),
+    readFileSync: vi.fn(() => {
+      throw new Error("readFileSync not stubbed");
+    }),
     lstatSync: actual.lstatSync,
     readlinkSync: actual.readlinkSync,
   };
@@ -99,6 +105,7 @@ describe("versionChecker", () => {
   describe("checkAndAutoUpdate", () => {
     beforeEach(() => {
       vi.clearAllMocks();
+      _setInstalledPackageForTesting(null);
       vi.stubGlobal("fetch", vi.fn());
       vi.spyOn(process.stderr, "write").mockImplementation(() => true);
       // Use a mock for process.exit to prevent actual exit in tests
@@ -300,4 +307,77 @@ describe("versionChecker", () => {
       expect(str).toMatch(/agent-yes v\d+\.\d+\.\d+ \(.+\)/);
     });
   });
+
+  // Regression test for https://github.com/snomiao/agent-yes/issues/39:
+  // a stale bundled version string must not pin the auto-update comparison
+  // when a fresh package.json is on disk next to the running module.
+  describe("getInstalledPackage (issue #39)", () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+      _setInstalledPackageForTesting(null);
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+      _setInstalledPackageForTesting(null);
+    });
+
+    it("prefers the on-disk package.json over the bundled (potentially stale) import", async () => {
+      const fs = await import("fs");
+      vi.mocked(fs.existsSync).mockReturnValueOnce(true);
+      vi.mocked(fs.readFileSync).mockReturnValueOnce(
+        JSON.stringify({ name: "agent-yes", version: "999.0.0" }) as any,
+      );
+
+      const resolved = getInstalledPackage();
+      expect(resolved.version).toBe("999.0.0");
+      expect(resolved.name).toBe("agent-yes");
+    });
+
+    it("continues walking parents when a candidate package.json is unreadable", async () => {
+      // Per-candidate try/catch: an unreadable/unparsable manifest at one
+      // level must not abort the upward walk and silently fall back to the
+      // bundled (stale) manifest. The walk must keep going until it finds
+      // a matching package.json or exhausts parents.
+      const fs = await import("fs");
+      let call = 0;
+      vi.mocked(fs.existsSync).mockImplementation(() => true);
+      vi.mocked(fs.readFileSync).mockImplementation(() => {
+        call += 1;
+        if (call === 1) throw new Error("EACCES");
+        if (call === 2) return "{not json" as any;
+        return JSON.stringify({ name: "agent-yes", version: "999.0.0" }) as any;
+      });
+
+      const resolved = getInstalledPackage();
+      expect(resolved.version).toBe("999.0.0");
+      expect(call).toBeGreaterThanOrEqual(3);
+    });
+
+    it("does not trigger an auto-update when on-disk version already matches the registry", async () => {
+      // Simulate the post-fix scenario: the bundled `pkg.version` (frozen at
+      // build time) is older than the registry, but the runtime resolver
+      // surfaces the correct on-disk version and the comparison short-circuits.
+      // Pre-fix behavior was install + reExec on every invocation → infinite loop.
+      _setInstalledPackageForTesting({ name: "agent-yes", version: "999.0.0" });
+
+      const { readFile } = await import("fs/promises");
+      const { execaCommand } = await import("execa");
+      vi.mocked(readFile).mockRejectedValueOnce(new Error("no cache"));
+      vi.stubGlobal(
+        "fetch",
+        vi.fn().mockResolvedValue({
+          ok: true,
+          json: async () => ({ version: "999.0.0" }),
+        } as Response),
+      );
+      vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+      vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+      delete process.env.AGENT_YES_NO_UPDATE;
+      delete process.env.AGENT_YES_UPDATED;
+
+      await checkAndAutoUpdate();
+      expect(execaCommand).not.toHaveBeenCalled();
+    });
+  });
 });

package/ts/versionChecker.ts

@@ -1,14 +1,80 @@
 import { execFileSync } from "child_process";
-import { existsSync, lstatSync, readlinkSync } from "fs";
+import { existsSync, lstatSync, readFileSync, readlinkSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
-import pkg from "../package.json" with { type: "json" };
+import { fileURLToPath } from "url";
+import bundledPkg 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
 
+// The release pipeline publishes both `agent-yes` and `claude-yes` from the
+// same source by flipping `package.json#name` and re-running `npm publish`
+// (which now triggers `bun run build`, rebuilding dist with whichever name is
+// set). The auto-updater's registry lookup, install command, and shared
+// cache file must all stay pinned to the canonical package — otherwise a
+// `claude-yes` install would query `claude-yes/latest` while `runInstall`
+// still hard-codes `agent-yes`.
+const CANONICAL_PKG_NAME = "agent-yes";
+
+let cachedInstalledPkg: { name: string; version: string } | null = null;
+
+/**
+ * Read the live `package.json` from disk for the running module.
+ *
+ * The bundled `package.json` import is inlined at build time; if `dist/` is
+ * published without a fresh build (issue #39), the inlined `version` lies
+ * and the auto-update loop fires forever. Reading the on-disk manifest each
+ * run keeps the version honest even when the bundle is stale.
+ */
+export function getInstalledPackage(): { name: string; version: string } {
+  if (cachedInstalledPkg) return cachedInstalledPkg;
+  let dir: string | null = null;
+  try {
+    dir = path.dirname(fileURLToPath(import.meta.url));
+  } catch {
+    // import.meta.url malformed; fall through to bundled
+  }
+  if (dir) {
+    for (let i = 0; i < 6; i++) {
+      const candidate = path.join(dir, "package.json");
+      // A per-candidate try/catch: a transient read error, partial write, or
+      // BOM on any single package.json must NOT abort the upward walk —
+      // otherwise we'd silently fall back to the stale bundled manifest that
+      // issue #39 was about. Keep walking until we either find a matching
+      // manifest or exhaust parents.
+      try {
+        if (existsSync(candidate)) {
+          const json = JSON.parse(readFileSync(candidate, "utf8")) as {
+            name?: string;
+            version?: string;
+          };
+          if (json.name === bundledPkg.name && typeof json.version === "string") {
+            cachedInstalledPkg = { name: json.name, version: json.version };
+            return cachedInstalledPkg;
+          }
+        }
+      } catch {
+        // unreadable / unparsable — continue walking
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  cachedInstalledPkg = { name: bundledPkg.name, version: bundledPkg.version };
+  return cachedInstalledPkg;
+}
+
+/** Test-only: clear or seed the memoized lookup. */
+export function _setInstalledPackageForTesting(
+  value: { name: string; version: string } | null,
+): void {
+  cachedInstalledPkg = value;
+}
+
 type UpdateCache = { checkedAt: number; latestVersion: string };
 
 async function readUpdateCache(): Promise<UpdateCache | null> {
@@ -75,7 +141,7 @@ export async function checkAndAutoUpdate(): Promise<void> {
       await writeUpdateCache({ checkedAt: Date.now(), latestVersion });
     }
 
-    if (compareVersions(pkg.version, latestVersion) < 0) {
+    if (compareVersions(getInstalledPackage().version, latestVersion) < 0) {
       const installed = await runInstall(latestVersion);
       if (installed) {
         reExec(latestVersion);
@@ -90,10 +156,12 @@ async function runInstall(latestVersion: string): Promise<boolean> {
   const pm = detectPackageManager();
   const installCmd =
     pm === "bun"
-      ? `bun add -g agent-yes@${latestVersion}`
-      : `npm install -g agent-yes@${latestVersion}`;
+      ? `bun add -g ${CANONICAL_PKG_NAME}@${latestVersion}`
+      : `npm install -g ${CANONICAL_PKG_NAME}@${latestVersion}`;
 
-  process.stderr.write(`\x1b[33m[agent-yes] Updating ${pkg.version} → ${latestVersion}…\x1b[0m\n`);
+  process.stderr.write(
+    `\x1b[33m[agent-yes] Updating ${getInstalledPackage().version} → ${latestVersion}…\x1b[0m\n`,
+  );
   try {
     const { execaCommand } = await import("execa");
     await execaCommand(installCmd, { stdio: "inherit" });
@@ -128,7 +196,7 @@ function reExec(version: string): never {
  */
 export async function fetchLatestVersion(): Promise<string | null> {
   try {
-    const response = await fetch(`https://registry.npmjs.org/${pkg.name}/latest`, {
+    const response = await fetch(`https://registry.npmjs.org/${CANONICAL_PKG_NAME}/latest`, {
       signal: AbortSignal.timeout(3000), // 3 second timeout
     });
 
@@ -215,7 +283,7 @@ export function detectInstallMethod(): string {
  * Format version string with install method
  */
 export function versionString(): string {
-  return `agent-yes v${pkg.version} (${detectInstallMethod()})`;
+  return `agent-yes v${getInstalledPackage().version} (${detectInstallMethod()})`;
 }
 
 /**
@@ -227,7 +295,7 @@ export async function displayVersion(): Promise<void> {
   const latestVersion = await fetchLatestVersion();
 
   if (latestVersion) {
-    const comparison = compareVersions(pkg.version, latestVersion);
+    const comparison = compareVersions(getInstalledPackage().version, latestVersion);
 
     if (comparison < 0) {
       console.log(`\x1b[33m${latestVersion} (update available)\x1b[0m`);

package/dist/package-8zpT1iww.js

@@ -1,7 +0,0 @@
-//#region package.json
-var name = "agent-yes";
-var version = "1.75.1";
-
-//#endregion
-export { version as n, name as t };
-//# sourceMappingURL=package-8zpT1iww.js.map