agent-yes 1.45.2 → 1.46.1

package/dist/{SUPPORTED_CLIS-hj4ASwQy.js → SUPPORTED_CLIS-BwukLRmP.js}

@@ -1,7 +1,7 @@
 import { a as __esmMin, c as __toESM, i as __commonJSMin, n as require_winston, o as __exportAll, s as __require, t as logger } from "./logger-DH1Rx9HI.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
-import { existsSync } from "fs";
+import { existsSync, mkdirSync } from "fs";
 import path, { dirname, join } from "path";
 import { constants } from "node:os";
 import path$1 from "node:path";
@@ -10735,4 +10735,4 @@ const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { AgentContext as a, config as i, CLIS_CONFIG as n, PidStore as o, agentYes as r, removeControlCharacters as s, SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-hj4ASwQy.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-BwukLRmP.js.map

package/dist/cli.js

@@ -1,16 +1,17 @@
 #!/usr/bin/env bun
 import { c as __toESM, i as __commonJSMin, r as require_ms, t as logger } from "./logger-DH1Rx9HI.js";
 import "./agent-yes.config-CrlZMQo-.js";
-import { o as PidStore, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-hj4ASwQy.js";
+import { o as PidStore, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BwukLRmP.js";
 import { createRequire } from "node:module";
 import { argv } from "process";
 import { spawn } from "child_process";
-import { existsSync, readFileSync, readdirSync, statSync, writeFile } from "fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFile } from "fs";
 import path, { basename, dirname, extname, join, normalize, relative, resolve } from "path";
 import { format, inspect } from "util";
 import { notStrictEqual, strictEqual } from "assert";
 import { fileURLToPath } from "url";
 import { readFileSync as readFileSync$1, readdirSync as readdirSync$1 } from "node:fs";
+import { chmod, copyFile, rename } from "fs/promises";
 
 //#region node_modules/cliui/build/lib/index.js
 var import_ms = /* @__PURE__ */ __toESM(require_ms(), 1);
@@ -4696,26 +4697,165 @@ async function displayVersion() {
 }
 
 //#endregion
-//#region ts/cli.ts
-const config = parseCliArgs(process.argv);
-if (config.useRust) {
-	const rustBinaryName = config.cli ? `${config.cli}-yes` : "agent-yes";
-	const rustBinaryPaths = [
+//#region ts/rustBinary.ts
+/**
+* Rust binary helper - finds or downloads the appropriate prebuilt binary
+*/
+const PLATFORM_MAP = {
+	"linux-x64": "agent-yes-linux-x64-musl",
+	"linux-arm64": "agent-yes-linux-arm64-musl",
+	"darwin-x64": "agent-yes-darwin-x64",
+	"darwin-arm64": "agent-yes-darwin-arm64",
+	"win32-x64": "agent-yes-win32-x64"
+};
+/**
+* Get the binary name for the current platform
+*/
+function getBinaryName() {
+	const platform = process.platform;
+	const arch = process.arch;
+	const binaryName = PLATFORM_MAP[`${platform}-${arch}`];
+	if (!binaryName) throw new Error(`Unsupported platform: ${platform}-${arch}. Supported: ${Object.keys(PLATFORM_MAP).join(", ")}`);
+	return binaryName + (platform === "win32" ? ".exe" : "");
+}
+/**
+* Get the directory where binaries are stored
+*/
+function getBinDir() {
+	const packageBinDir = path.resolve(import.meta.dir, "../bin");
+	if (existsSync(packageBinDir)) return packageBinDir;
+	const cacheDir = process.env.AGENT_YES_CACHE_DIR || path.join(process.env.XDG_CACHE_HOME || path.join(process.env.HOME || "/tmp", ".cache"), "agent-yes");
+	return path.join(cacheDir, "bin");
+}
+/**
+* Find the Rust binary, checking multiple locations
+*/
+function findRustBinary(verbose = false) {
+	const binaryName = getBinaryName();
+	binaryName.replace(/\.exe$/, "");
+	const searchPaths = [
+		path.join(getBinDir(), binaryName),
 		path.resolve(import.meta.dir, "../rs/target/release/agent-yes"),
 		path.resolve(import.meta.dir, "../rs/target/debug/agent-yes"),
-		rustBinaryName,
-		"agent-yes"
+		path.join(getBinDir(), binaryName)
 	];
+	if (verbose) {
+		console.log(`[rust] Looking for binary: ${binaryName}`);
+		console.log(`[rust] Search paths:`);
+	}
+	for (const p of searchPaths) {
+		if (verbose) console.log(`[rust]   - ${p}: ${existsSync(p) ? "FOUND" : "not found"}`);
+		if (existsSync(p)) return p;
+	}
+}
+/**
+* Get GitHub release download URL for the binary
+*/
+function getDownloadUrl(version = "latest") {
+	const binaryName = getBinaryName().replace(/\.exe$/, "");
+	const ext = process.platform === "win32" ? ".zip" : ".tar.gz";
+	if (version === "latest") return `https://github.com/snomiao/agent-yes/releases/latest/download/${binaryName}${ext}`;
+	return `https://github.com/snomiao/agent-yes/releases/download/v${version}/${binaryName}${ext}`;
+}
+/**
+* Download and extract the binary
+*/
+async function downloadBinary(verbose = false) {
+	const binDir = getBinDir();
+	const binaryName = getBinaryName();
+	const binaryPath = path.join(binDir, binaryName);
+	mkdirSync(binDir, { recursive: true });
+	const url = getDownloadUrl();
+	if (verbose) console.log(`[rust] Downloading binary from: ${url}`);
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Failed to download binary: ${response.status} ${response.statusText}`);
+	if (process.platform === "win32") {
+		const tempZipPath = path.join(binDir, "temp.zip");
+		await Bun.write(tempZipPath, await response.arrayBuffer());
+		await Bun.spawn([
+			"powershell",
+			"-Command",
+			`Expand-Archive -Path '${tempZipPath}' -DestinationPath '${binDir}' -Force`
+		], {
+			cwd: binDir,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		}).exited;
+		try {
+			unlinkSync(tempZipPath);
+		} catch {}
+	} else {
+		const tarPath = path.join(binDir, "temp.tar.gz");
+		await Bun.write(tarPath, await response.arrayBuffer());
+		await Bun.spawn([
+			"tar",
+			"-xzf",
+			tarPath,
+			"-C",
+			binDir
+		], {
+			cwd: binDir,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		}).exited;
+		const possibleNames = [
+			"agent-yes",
+			binaryName.replace(/-musl$/, "").replace(/-gnu$/, ""),
+			binaryName
+		];
+		for (const name of possibleNames) {
+			const extractedPath = path.join(binDir, name);
+			if (existsSync(extractedPath) && extractedPath !== binaryPath) {
+				try {
+					await copyFile(extractedPath, binaryPath);
+					unlinkSync(extractedPath);
+				} catch {}
+				break;
+			}
+		}
+		try {
+			unlinkSync(tarPath);
+		} catch {}
+		await chmod(binaryPath, 493);
+	}
+	if (verbose) console.log(`[rust] Binary downloaded to: ${binaryPath}`);
+	return binaryPath;
+}
+/**
+* Get or download the Rust binary
+*/
+async function getRustBinary(options = {}) {
+	const { verbose = false, forceDownload = false } = options;
+	if (!forceDownload) {
+		const existing = findRustBinary(verbose);
+		if (existing) {
+			if (verbose) console.log(`[rust] Using existing binary: ${existing}`);
+			return existing;
+		}
+	}
+	if (verbose) console.log(`[rust] Binary not found, downloading...`);
+	try {
+		return await downloadBinary(verbose);
+	} catch (err) {
+		throw new Error(`Failed to get Rust binary: ${err instanceof Error ? err.message : err}\nYou can build manually with: cd rs && cargo build --release`);
+	}
+}
+
+//#endregion
+//#region ts/cli.ts
+const config = parseCliArgs(process.argv);
+if (config.useRust) {
 	let rustBinary;
-	for (const p of rustBinaryPaths) if (p.includes("/") && existsSync(p)) {
-		rustBinary = p;
-		break;
-	} else if (!p.includes("/")) {
-		rustBinary = p;
-		break;
-	}
-	if (!rustBinary) {
-		console.error("Rust binary not found. Please build with: cd rs && cargo build --release");
+	try {
+		rustBinary = await getRustBinary({ verbose: config.verbose });
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
 		process.exit(1);
 	}
 	const rustArgs = process.argv.slice(2).filter((arg) => arg !== "--rust" && !arg.startsWith("--rust="));
@@ -4729,7 +4869,7 @@ if (config.useRust) {
 		cwd: process.cwd()
 	});
 	child.on("error", (err) => {
-		if (err.code === "ENOENT") console.error(`Rust binary '${rustBinary}' not found in PATH. Please build with: cd rs && cargo build --release`);
+		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);
 	});

package/dist/index.js

@@ -1,4 +1,4 @@
 import "./logger-DH1Rx9HI.js";
-import { a as AgentContext, i as config, n as CLIS_CONFIG, r as agentYes, s as removeControlCharacters } from "./SUPPORTED_CLIS-hj4ASwQy.js";
+import { a as AgentContext, i as config, n as CLIS_CONFIG, r as agentYes, s as removeControlCharacters } from "./SUPPORTED_CLIS-BwukLRmP.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.45.2",
+  "version": "1.46.1",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",
@@ -49,7 +49,8 @@
     "scripts",
     "ts/*.ts",
     "!dist/**/*.map",
-    "dist/**/*.js"
+    "dist/**/*.js",
+    "bin"
   ],
   "type": "module",
   "module": "ts/index.ts",

package/scripts/download-rust-binary.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+/**
+ * Script to download the prebuilt Rust binary for the current platform
+ *
+ * Usage:
+ *   bun scripts/download-rust-binary.ts
+ *   npx agent-yes download-binary
+ */
+
+import { downloadBinary, findRustBinary, getBinaryName, getDownloadUrl } from "../ts/rustBinary.ts";
+
+async function main() {
+  const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
+  const force = process.argv.includes("--force") || process.argv.includes("-f");
+
+  console.log(`Platform: ${process.platform}-${process.arch}`);
+  console.log(`Binary name: ${getBinaryName()}`);
+  console.log(`Download URL: ${getDownloadUrl()}`);
+  console.log();
+
+  // Check if binary already exists
+  if (!force) {
+    const existing = findRustBinary(verbose);
+    if (existing) {
+      console.log(`Binary already exists at: ${existing}`);
+      console.log("Use --force to re-download");
+      return;
+    }
+  }
+
+  console.log("Downloading binary...");
+  try {
+    const binaryPath = await downloadBinary(verbose);
+    console.log(`\nSuccess! Binary downloaded to: ${binaryPath}`);
+    console.log("\nYou can now use: npx agent-yes --rust");
+  } catch (err) {
+    console.error(`\nFailed to download binary: ${err instanceof Error ? err.message : err}`);
+    console.error("\nYou can build manually with:");
+    console.error("  cd rs && cargo build --release");
+    process.exit(1);
+  }
+}
+
+main();

package/ts/cli.ts

@@ -8,36 +8,20 @@ import { parseCliArgs } from "./parseCliArgs.ts";
 import { logger } from "./logger.ts";
 import { PidStore } from "./pidStore.ts";
 import { displayVersion } from "./versionChecker.ts";
+import { getRustBinary } from "./rustBinary.ts";
 
 // Parse CLI arguments
 const config = parseCliArgs(process.argv);
 
 // Handle --rust: spawn the Rust binary instead
 if (config.useRust) {
-  const rustBinaryName = config.cli ? `${config.cli}-yes` : "agent-yes";
-  const rustBinaryPaths = [
-    // Check relative to this script (in the repo)
-    path.resolve(import.meta.dir, "../rs/target/release/agent-yes"),
-    path.resolve(import.meta.dir, "../rs/target/debug/agent-yes"),
-    // Check in PATH
-    rustBinaryName,
-    "agent-yes",
-  ];
-
-  let rustBinary: string | undefined;
-  for (const p of rustBinaryPaths) {
-    if (p.includes("/") && existsSync(p)) {
-      rustBinary = p;
-      break;
-    } else if (!p.includes("/")) {
-      // For PATH lookup, just use it directly
-      rustBinary = p;
-      break;
-    }
-  }
+  let rustBinary: string;
 
-  if (!rustBinary) {
-    console.error("Rust binary not found. Please build with: cd rs && cargo build --release");
+  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);
   }
 
@@ -58,7 +42,7 @@ if (config.useRust) {
 
   child.on("error", (err) => {
     if ((err as NodeJS.ErrnoException).code === "ENOENT") {
-      console.error(`Rust binary '${rustBinary}' not found in PATH. Please build with: cd rs && cargo build --release`);
+      console.error(`Rust binary '${rustBinary}' not found. Try: npx agent-yes --rust --verbose`);
     } else {
       console.error(`Failed to spawn Rust binary: ${err.message}`);
     }

package/ts/rustBinary.ts

@@ -0,0 +1,224 @@
+/**
+ * Rust binary helper - finds or downloads the appropriate prebuilt binary
+ */
+
+import { existsSync, mkdirSync, unlinkSync, renameSync, copyFileSync } from "fs";
+import { chmod, unlink, rename, copyFile } from "fs/promises";
+import path from "path";
+
+// Platform/arch to binary name mapping
+const PLATFORM_MAP: Record<string, string> = {
+  "linux-x64": "agent-yes-linux-x64-musl", // Use musl for better compatibility
+  "linux-arm64": "agent-yes-linux-arm64-musl",
+  "darwin-x64": "agent-yes-darwin-x64",
+  "darwin-arm64": "agent-yes-darwin-arm64",
+  "win32-x64": "agent-yes-win32-x64",
+};
+
+/**
+ * Get the binary name for the current platform
+ */
+export function getBinaryName(): string {
+  const platform = process.platform;
+  const arch = process.arch;
+  const key = `${platform}-${arch}`;
+
+  const binaryName = PLATFORM_MAP[key];
+  if (!binaryName) {
+    throw new Error(
+      `Unsupported platform: ${platform}-${arch}. ` +
+        `Supported: ${Object.keys(PLATFORM_MAP).join(", ")}`
+    );
+  }
+
+  return binaryName + (platform === "win32" ? ".exe" : "");
+}
+
+/**
+ * Get the directory where binaries are stored
+ */
+export function getBinDir(): string {
+  // First check for binaries in the npm package
+  const packageBinDir = path.resolve(import.meta.dir, "../bin");
+  if (existsSync(packageBinDir)) {
+    return packageBinDir;
+  }
+
+  // Fall back to user's cache directory
+  const cacheDir =
+    process.env.AGENT_YES_CACHE_DIR ||
+    path.join(
+      process.env.XDG_CACHE_HOME || path.join(process.env.HOME || "/tmp", ".cache"),
+      "agent-yes"
+    );
+
+  return path.join(cacheDir, "bin");
+}
+
+/**
+ * Find the Rust binary, checking multiple locations
+ */
+export function findRustBinary(verbose = false): string | undefined {
+  const binaryName = getBinaryName();
+  const baseName = binaryName.replace(/\.exe$/, "");
+
+  const searchPaths = [
+    // 1. Check in npm package bin directory
+    path.join(getBinDir(), binaryName),
+
+    // 2. Check relative to this script (in the repo during development)
+    path.resolve(import.meta.dir, "../rs/target/release/agent-yes"),
+    path.resolve(import.meta.dir, "../rs/target/debug/agent-yes"),
+
+    // 3. Check in user's cache directory
+    path.join(getBinDir(), binaryName),
+  ];
+
+  if (verbose) {
+    console.log(`[rust] Looking for binary: ${binaryName}`);
+    console.log(`[rust] Search paths:`);
+  }
+
+  for (const p of searchPaths) {
+    if (verbose) {
+      console.log(`[rust]   - ${p}: ${existsSync(p) ? "FOUND" : "not found"}`);
+    }
+    if (existsSync(p)) {
+      return p;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Get GitHub release download URL for the binary
+ */
+export function getDownloadUrl(version = "latest"): string {
+  const binaryName = getBinaryName().replace(/\.exe$/, "");
+  const isWindows = process.platform === "win32";
+  const ext = isWindows ? ".zip" : ".tar.gz";
+
+  if (version === "latest") {
+    return `https://github.com/snomiao/agent-yes/releases/latest/download/${binaryName}${ext}`;
+  }
+
+  return `https://github.com/snomiao/agent-yes/releases/download/v${version}/${binaryName}${ext}`;
+}
+
+/**
+ * Download and extract the binary
+ */
+export async function downloadBinary(verbose = false): Promise<string> {
+  const binDir = getBinDir();
+  const binaryName = getBinaryName();
+  const binaryPath = path.join(binDir, binaryName);
+
+  // Create bin directory if needed
+  mkdirSync(binDir, { recursive: true });
+
+  const url = getDownloadUrl();
+  if (verbose) {
+    console.log(`[rust] Downloading binary from: ${url}`);
+  }
+
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download binary: ${response.status} ${response.statusText}`);
+  }
+
+  const isWindows = process.platform === "win32";
+
+  if (isWindows) {
+    // For Windows, download and extract zip
+    const tempZipPath = path.join(binDir, "temp.zip");
+    await Bun.write(tempZipPath, await response.arrayBuffer());
+
+    // Use PowerShell to extract zip
+    const proc = Bun.spawn(
+      ["powershell", "-Command", `Expand-Archive -Path '${tempZipPath}' -DestinationPath '${binDir}' -Force`],
+      { cwd: binDir, stdio: ["ignore", "pipe", "pipe"] }
+    );
+    await proc.exited;
+
+    // Clean up
+    try {
+      unlinkSync(tempZipPath);
+    } catch {}
+  } else {
+    // For Unix, download and extract tar.gz
+    const tarPath = path.join(binDir, "temp.tar.gz");
+    await Bun.write(tarPath, await response.arrayBuffer());
+
+    // Extract using tar command
+    const proc = Bun.spawn(["tar", "-xzf", tarPath, "-C", binDir], {
+      cwd: binDir,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    await proc.exited;
+
+    // The extracted file might have a different name, find and rename it
+    const extractedName = binaryName.replace(/-musl$/, "").replace(/-gnu$/, "");
+    const possibleNames = ["agent-yes", extractedName, binaryName];
+
+    for (const name of possibleNames) {
+      const extractedPath = path.join(binDir, name);
+      if (existsSync(extractedPath) && extractedPath !== binaryPath) {
+        try {
+          await copyFile(extractedPath, binaryPath);
+          unlinkSync(extractedPath);
+        } catch {}
+        break;
+      }
+    }
+
+    // Clean up tar file
+    try {
+      unlinkSync(tarPath);
+    } catch {}
+
+    // Make executable
+    await chmod(binaryPath, 0o755);
+  }
+
+  if (verbose) {
+    console.log(`[rust] Binary downloaded to: ${binaryPath}`);
+  }
+
+  return binaryPath;
+}
+
+/**
+ * Get or download the Rust binary
+ */
+export async function getRustBinary(options: {
+  verbose?: boolean;
+  forceDownload?: boolean;
+} = {}): Promise<string> {
+  const { verbose = false, forceDownload = false } = options;
+
+  // First try to find existing binary
+  if (!forceDownload) {
+    const existing = findRustBinary(verbose);
+    if (existing) {
+      if (verbose) {
+        console.log(`[rust] Using existing binary: ${existing}`);
+      }
+      return existing;
+    }
+  }
+
+  // Download if not found
+  if (verbose) {
+    console.log(`[rust] Binary not found, downloading...`);
+  }
+
+  try {
+    return await downloadBinary(verbose);
+  } catch (err) {
+    throw new Error(
+      `Failed to get Rust binary: ${err instanceof Error ? err.message : err}\n` +
+        `You can build manually with: cd rs && cargo build --release`
+    );
+  }
+}