agent-yes 1.62.2 → 1.64.0

package/README.md

@@ -1,6 +1,6 @@
 # Agent-Yes! for Claude/Codex/Gemini/Cursor/Copilot/Qwen/Auggie
 
-A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses. Originally designed for Claude CLI, now supports multiple AI coding assistants.
+A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses. Originally designed for Claude CLI, now supports multiple AI coding assistants. Rewritten in Rust for improved performance and reliability.
 
 ⚠️ **Important Security Warning**: Only run this on trusted repositories. This tool automatically responds to prompts and can execute commands without user confirmation. Be aware of potential prompt injection attacks where malicious code or instructions could be embedded in files or user inputs to manipulate the automated responses.
 

package/dist/{SUPPORTED_CLIS-CxaWfAAA.js → SUPPORTED_CLIS-DXou-_yV.js}

@@ -2,15 +2,16 @@ import { t as logger } from "./logger-CX77vJDA.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
 import { execaCommandSync, parseCommandString } from "execa";
-import { fromWritable } from "from-node-stream";
-import { appendFile, mkdir, readFile, readdir, rename, writeFile } from "fs/promises";
+import { fromReadable, fromWritable } from "from-node-stream";
+import { appendFile, mkdir, readFile, readdir, rename, unlink, writeFile } from "fs/promises";
 import path, { dirname, join } from "path";
 import DIE from "phpdie";
 import sflow from "sflow";
 import { TerminalRenderStream } from "terminal-render";
 import { homedir } from "os";
 import winston from "winston";
-import { closeSync, existsSync, fsyncSync, mkdirSync, openSync } from "fs";
+import { closeSync, constants, createReadStream, existsSync, fsyncSync, mkdirSync, openSync } from "fs";
+import { createServer } from "net";
 import { lock } from "proper-lockfile";
 import { execSync as execSync$1 } from "node:child_process";
 import { fileURLToPath } from "url";
@@ -422,6 +423,163 @@ function shouldUseLock(_cwd) {
 	return true;
 }
 
+//#endregion
+//#region ts/beta/fifo.ts
+/**
+* Creates an IPC stream (FIFO on Linux, Named Pipes on Windows) for additional stdin input
+* @param cli - The CLI name for logging purposes
+* @param customPath - Optional custom path for the IPC file; if provided, uses this instead of generating a path
+* @returns An object with stream and cleanup function, or null if failed
+*/
+async function createFifoStream(cli, customPath) {
+	if (process.platform === "win32") return await createWindowsNamedPipe(cli, customPath);
+	else if (process.platform === "linux") return await createLinuxFifo(cli, customPath);
+	else {
+		logger.warn(`[${cli}-yes] IPC not supported on platform: ${process.platform}`);
+		return null;
+	}
+}
+/**
+* Creates a Windows named pipe for IPC
+*/
+async function createWindowsNamedPipe(cli, customPath) {
+	try {
+		let pipePath;
+		if (customPath) pipePath = customPath;
+		else pipePath = `\\\\.\\pipe\\agent-yes-${(/* @__PURE__ */ new Date()).toISOString().replace(/\D/g, "").slice(0, 17)}${Math.random().toString(36).substring(2, 5)}`;
+		logger.info(`[${cli}-yes] Creating Windows named pipe at ${pipePath}`);
+		const server = createServer();
+		let connection = null;
+		let isClosing = false;
+		const stream = new ReadableStream({
+			start(controller) {
+				server.on("connection", (socket) => {
+					connection = socket;
+					logger.info(`[${cli}-yes] Client connected to named pipe`);
+					socket.on("data", (chunk) => {
+						const data = chunk.toString();
+						logger.debug(`[${cli}-yes] Received data via named pipe: ${data}`);
+						controller.enqueue(data);
+					});
+					socket.on("end", () => {
+						logger.debug(`[${cli}-yes] Client disconnected from named pipe`);
+						connection = null;
+					});
+					socket.on("error", (error) => {
+						logger.warn(`[${cli}-yes] Named pipe socket error:`, error);
+						if (!isClosing) controller.error(error);
+					});
+				});
+				server.on("error", (error) => {
+					logger.warn(`[${cli}-yes] Named pipe server error:`, error);
+					if (!isClosing) controller.error(error);
+				});
+				server.listen(pipePath, () => {
+					logger.info(`[${cli}-yes] Named pipe server listening at ${pipePath}`);
+				});
+			},
+			cancel() {
+				isClosing = true;
+				if (connection) connection.end();
+				server.close();
+			}
+		});
+		const cleanup = async () => {
+			isClosing = true;
+			if (connection) connection.end();
+			server.close();
+			logger.info(`[${cli}-yes] Cleaned up Windows named pipe at ${pipePath}`);
+		};
+		process.on("exit", () => cleanup().catch(() => null));
+		process.on("SIGINT", () => cleanup().catch(() => null));
+		process.on("SIGTERM", () => cleanup().catch(() => null));
+		return {
+			stream,
+			[Symbol.asyncDispose]: cleanup
+		};
+	} catch (error) {
+		logger.warn(`[${cli}-yes] Failed to create Windows named pipe:`, error);
+		return null;
+	}
+}
+/**
+* Creates a Linux FIFO for IPC (original implementation)
+*/
+async function createLinuxFifo(cli, customPath) {
+	let fifoPath = null;
+	let fifoStream = null;
+	logger.debug(`[${cli}-yes] Creating Linux FIFO with customPath: ${customPath}`);
+	try {
+		if (customPath) fifoPath = customPath;
+		else fifoPath = `/tmp/agent-yes-${(/* @__PURE__ */ new Date()).toISOString().replace(/\D/g, "").slice(0, 17)}${Math.random().toString(36).substring(2, 5)}.stdin`;
+		try {
+			mkdirSync(dirname(fifoPath), { recursive: true });
+		} catch (dirError) {
+			logger.warn(`[${cli}-yes] Failed to create FIFO directory: ${dirError}`);
+			return null;
+		}
+		const escapedPath = fifoPath.replace(/'/g, "'\"'\"'");
+		const mkfifoResult = execaCommandSync(`mkfifo '${escapedPath}'`, { reject: false });
+		if (mkfifoResult.exitCode !== 0) {
+			logger.warn(`[${cli}-yes] mkfifo command failed with exit code ${mkfifoResult.exitCode}`);
+			logger.warn(`[${cli}-yes] Command: mkfifo '${escapedPath}'`);
+			if (mkfifoResult.stderr) logger.warn(`[${cli}-yes] mkfifo stderr: ${mkfifoResult.stderr}`);
+			if (mkfifoResult.stdout) logger.warn(`[${cli}-yes] mkfifo stdout: ${mkfifoResult.stdout}`);
+			return null;
+		}
+		logger.info(`[${cli}-yes] Created FIFO at ${fifoPath}`);
+		try {
+			fifoStream = createReadStream("", {
+				fd: openSync(fifoPath, constants.O_RDONLY | constants.O_NONBLOCK),
+				autoClose: true
+			});
+			const dummyWriteFd = openSync(fifoPath, constants.O_WRONLY | constants.O_NONBLOCK);
+			logger.info(`[${cli}-yes] FIFO opened for reading`);
+			const cleanupFifo = async () => {
+				try {
+					closeSync(dummyWriteFd);
+				} catch {}
+				if (fifoStream) try {
+					fifoStream.close();
+					logger.debug(`[${cli}-yes] Closed FIFO stream`);
+				} catch (error) {
+					logger.debug(`[${cli}-yes] Error closing FIFO stream:`, { error });
+				}
+				if (fifoPath) try {
+					await unlink(fifoPath).catch(() => null);
+					logger.info(`[${cli}-yes] Cleaned up FIFO at ${fifoPath}`);
+				} catch {}
+			};
+			process.on("exit", () => {
+				if (fifoPath) unlink(fifoPath).catch(() => null);
+			});
+			process.on("SIGINT", async () => {
+				await cleanupFifo();
+			});
+			process.on("SIGTERM", async () => {
+				await cleanupFifo();
+			});
+			return {
+				stream: sflow(fromReadable(fifoStream)).map((buffer) => buffer.toString()),
+				[Symbol.asyncDispose]: cleanupFifo
+			};
+		} catch (error) {
+			logger.warn(`[${cli}-yes] Failed to open FIFO at ${fifoPath}:`, { error });
+			if (error instanceof Error) {
+				logger.warn(`[${cli}-yes] Error details: ${error.message}`);
+				if (error.stack) logger.debug(`[${cli}-yes] Stack trace: ${error.stack}`);
+			}
+			if (fifoPath) unlink(fifoPath).catch(() => null);
+			return null;
+		}
+	} catch (error) {
+		logger.warn(`[${cli}-yes] Failed to create FIFO:`, { error });
+		if (error instanceof Error) logger.warn(`[${cli}-yes] Error details: ${error.message}`);
+		if (fifoPath) unlink(fifoPath).catch(() => null);
+		return null;
+	}
+}
+
 //#endregion
 //#region ts/JsonlStore.ts
 /**
@@ -792,19 +950,13 @@ var ReadyManager = class {
 async function sendEnter(context, waitms = 1e3) {
 	const st = Date.now();
 	await context.idleWaiter.wait(waitms);
-	const et = Date.now();
-	logger.debug(`sendingEnter| idleWaiter.wait(${String(waitms)}) took ${String(et - st)}ms`);
+	logger.debug(`sendEnter| idleWait took ${String(Date.now() - st)}ms`);
 	context.nextStdout.unready();
 	context.shell.write("\r");
-	logger.debug(`enterSent| idleWaiter.wait(${String(waitms)}) took ${String(et - st)}ms`);
-	await Promise.race([context.nextStdout.wait(), new Promise((resolve) => setTimeout(() => {
-		if (!context.nextStdout.isReady) context.shell.write("\r");
-		resolve();
-	}, 1e3))]);
-	await Promise.race([context.nextStdout.wait(), new Promise((resolve) => setTimeout(() => {
+	for (const ms of [1e3, 3e3]) await Promise.race([context.nextStdout.wait(), new Promise((resolve) => setTimeout(() => {
 		if (!context.nextStdout.isReady) context.shell.write("\r");
 		resolve();
-	}, 3e3))]);
+	}, ms))]);
 }
 /**
 * Send a message to the shell
@@ -907,7 +1059,7 @@ function tryCatch(catchFn, fn) {
 //#endregion
 //#region package.json
 var name = "agent-yes";
-var version = "1.62.2";
+var version = "1.64.0";
 
 //#endregion
 //#region ts/pty-fix.ts
@@ -1363,7 +1515,7 @@ const CLIS_CONFIG = config.clis;
 * });
 * ```
 */
-async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, exitOnIdle, logFile, removeControlCharactersFromStdout = false, verbose = false, queue = false, install = false, resume = false, useSkills = false, useStdinAppend: _useStdinAppend = false, autoYes = true }) {
+async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, exitOnIdle, logFile, removeControlCharactersFromStdout = false, verbose = false, queue = false, install = false, resume = false, useSkills = false, useStdinAppend = false, autoYes = true }) {
 	if (!cli) throw new Error(`cli is required`);
 	const conf = CLIS_CONFIG[cli] || DIE(`Unsupported cli tool: ${cli}, current process.argv: ${process.argv.join(" ")}`);
 	const workingDir = cwd ?? process.cwd();
@@ -1484,6 +1636,12 @@ async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, ex
 		install,
 		ptyOptions
 	});
+	function onData(data) {
+		const currentPid = shell.pid;
+		outputWriter.write(data);
+		globalAgentRegistry.appendStdout(currentPid, data);
+	}
+	shell.onData(onData);
 	try {
 		await pidStore.registerProcess({
 			pid: shell.pid,
@@ -1531,12 +1689,6 @@ async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, ex
 		if (!ctx.stdinFirstReady.isReady) ctx.stdinFirstReady.ready();
 	});
 	const pendingExitCode = Promise.withResolvers();
-	function onData(data) {
-		const currentPid = shell.pid;
-		outputWriter.write(data);
-		globalAgentRegistry.appendStdout(currentPid, data);
-	}
-	shell.onData(onData);
 	shell.onExit(async function onExit({ exitCode }) {
 		const exitedPid = shell.pid;
 		globalAgentRegistry.unregister(exitedPid);
@@ -1842,7 +1994,14 @@ async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, ex
 			}
 			return out;
 		};
-	})()).onStart(async function promptOnStart() {
+	})()).by(async (s) => {
+		if (!useStdinAppend) return s;
+		const ipcResult = await createFifoStream(cli, pidStore.getFifoPath(shell.pid));
+		if (!ipcResult) return s;
+		pendingExitCode.promise.finally(async () => await ipcResult[Symbol.asyncDispose]());
+		process.stderr.write(`\n  Append prompts: ${cli}-yes --append-prompt '...'\n\n`);
+		return s.merge(ipcResult.stream);
+	}).confluenceByConcat().onStart(async function promptOnStart() {
 		logger.debug("Sending prompt message: " + JSON.stringify(prompt));
 		if (prompt) await sendMessage(ctx.messageContext, prompt);
 	}).by({
@@ -1953,4 +2112,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-CxaWfAAA.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-DXou-_yV.js.map

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-CxaWfAAA.js";
+import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DXou-_yV.js";
 import { t as logger } from "./logger-CX77vJDA.js";
 import { argv } from "process";
 import { spawn } from "child_process";
@@ -85,8 +85,8 @@ function parseCliArgs(argv) {
 		default: "yes"
 	}).option("rust", {
 		type: "boolean",
-		description: "Use the Rust implementation instead of TypeScript",
-		default: false
+		description: "Use the Rust implementation (enabled by default, use --no-rust for TypeScript)",
+		default: true
 	}).option("swarm", {
 		type: "string",
 		description: `Enable swarm mode for multi-agent P2P networking (requires --rust).
@@ -271,10 +271,11 @@ function getBinDir() {
 */
 function findRustBinary(verbose = false) {
 	const binaryName = getBinaryName();
+	const ext = process.platform === "win32" ? ".exe" : "";
 	const searchPaths = [
+		path.resolve(import.meta.dirname ?? import.meta.dir, `../rs/target/release/agent-yes${ext}`),
+		path.resolve(import.meta.dirname ?? import.meta.dir, `../rs/target/debug/agent-yes${ext}`),
 		path.join(getBinDir(), binaryName),
-		path.resolve(import.meta.dirname ?? import.meta.dir, "../rs/target/release/agent-yes"),
-		path.resolve(import.meta.dirname ?? import.meta.dir, "../rs/target/debug/agent-yes"),
 		path.join(getBinDir(), binaryName)
 	];
 	if (verbose) {

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-CxaWfAAA.js";
+import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-DXou-_yV.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.62.2",
+  "version": "1.64.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

package/ts/index.ts

@@ -14,7 +14,6 @@ import pty, { ptyPackage } from "./pty.ts";
 import { removeControlCharacters } from "./removeControlCharacters.ts";
 import { acquireLock, releaseLock, shouldUseLock } from "./runningLock.ts";
 import { logger } from "./logger.ts";
-// oxlint-disable-next-line no-unused-vars -- kept for FIFO re-enable (see TODO at index.ts:833)
 import { createFifoStream } from "./beta/fifo.ts";
 import { PidStore } from "./pidStore.ts";
 import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
@@ -118,7 +117,7 @@ export default async function agentYes({
   install = false,
   resume = false,
   useSkills = false,
-  useStdinAppend: _useStdinAppend = false,
+  useStdinAppend = false,
   autoYes = true,
 }: {
   cli: SUPPORTED_CLIS;
@@ -328,6 +327,15 @@ export default async function agentYes({
     ptyOptions,
   });
 
+  // Attach data handler IMMEDIATELY after spawn to avoid losing early PTY output.
+  // node-pty emits 'data' events eagerly — if no listener is attached, events are lost.
+  function onData(data: string) {
+    const currentPid = shell.pid;
+    outputWriter.write(data);
+    globalAgentRegistry.appendStdout(currentPid, data);
+  }
+  shell.onData(onData);
+
   // Register process in pidStore (non-blocking - failures should not prevent agent from running)
   try {
     await pidStore.registerProcess({ pid: shell.pid, cli, args: cliArgs, prompt, cwd: workingDir });
@@ -387,16 +395,6 @@ export default async function agentYes({
 
   const pendingExitCode = Promise.withResolvers<number | null>();
 
-  function onData(data: string) {
-    const currentPid = shell.pid; // Capture PID before any potential shell reassignment
-    // Write eagerly — TerminalRenderStream never exerts backpressure,
-    // so the PTY is always drained and the child process never blocks.
-    outputWriter.write(data);
-    // append to agent registry for MCP server
-    globalAgentRegistry.appendStdout(currentPid, data);
-  }
-
-  shell.onData(onData);
   shell.onExit(async function onExit({ exitCode }) {
     const exitedPid = shell.pid; // Capture PID immediately before any shell reassignment
     // Unregister from agent registry
@@ -833,18 +831,17 @@ export default async function agentYes({
       })(),
     )
 
-    // TODO(sno): Read from IPC stream if available (FIFO on Linux, Named Pipes on Windows)
-    // .by(async (s) => {
-    //   if (!useStdinAppend) return s;
-    //   const fifoPath = pidStore.getFifoPath(shell.pid);
-    //   if (!fifoPath) return s; // Skip if no valid path
-    //   const ipcResult = await createFifoStream(cli, fifoPath);
-    //   if (!ipcResult) return s;
-    //   pendingExitCode.promise.finally(async() => await ipcResult[Symbol.asyncDispose]());
-    //   process.stderr.write(`\n  Append prompts: ${cli}-yes --append-prompt '...'\n\n`);
-    //   return s.merge(ipcResult.stream);
-    // })
-    // .confluenceByConcat() // necessary when .by() above is async
+    // Read from IPC stream if available (FIFO on Linux, Named Pipes on Windows)
+    .by(async (s) => {
+      if (!useStdinAppend) return s;
+      const fifoPath = pidStore.getFifoPath(shell.pid);
+      const ipcResult = await createFifoStream(cli, fifoPath);
+      if (!ipcResult) return s;
+      pendingExitCode.promise.finally(async () => await ipcResult[Symbol.asyncDispose]());
+      process.stderr.write(`\n  Append prompts: ${cli}-yes --append-prompt '...'\n\n`);
+      return s.merge(ipcResult.stream);
+    })
+    .confluenceByConcat() // necessary because .by() above is async
 
     // .map((e) => e.replaceAll('\x1a', '')) // remove ctrl+z from user's input, to prevent bug (but this seems bug)
     // .forEach(e => appendFile('.cache/io.log', "input |" + JSON.stringify(e) + '\n')) // for debugging

package/ts/parseCliArgs.ts

@@ -121,8 +121,8 @@ export function parseCliArgs(argv: string[]) {
     })
     .option("rust", {
       type: "boolean",
-      description: "Use the Rust implementation instead of TypeScript",
-      default: false,
+      description: "Use the Rust implementation (enabled by default, use --no-rust for TypeScript)",
+      default: true,
     })
     .option("swarm", {
       type: "string",

package/ts/rustBinary.ts

@@ -61,13 +61,14 @@ export function getBinDir(): string {
 export function findRustBinary(verbose = false): string | undefined {
   const binaryName = getBinaryName();
 
+  const ext = process.platform === "win32" ? ".exe" : "";
   const searchPaths = [
-    // 1. Check in npm package bin directory
-    path.join(getBinDir(), binaryName),
+    // 1. Check relative to this script (in the repo during development)
+    path.resolve(import.meta.dirname ?? import.meta.dir, `../rs/target/release/agent-yes${ext}`),
+    path.resolve(import.meta.dirname ?? import.meta.dir, `../rs/target/debug/agent-yes${ext}`),
 
-    // 2. Check relative to this script (in the repo during development)
-    path.resolve(import.meta.dirname ?? import.meta.dir, "../rs/target/release/agent-yes"),
-    path.resolve(import.meta.dirname ?? import.meta.dir, "../rs/target/debug/agent-yes"),
+    // 2. Check in npm package bin directory
+    path.join(getBinDir(), binaryName),
 
     // 3. Check in user's cache directory
     path.join(getBinDir(), binaryName),