agent-yes 1.62.1 → 1.63.0

package/dist/{SUPPORTED_CLIS-BWhzaf_k.js → SUPPORTED_CLIS-BFlBIzu3.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
 /**
@@ -798,11 +956,11 @@ async function sendEnter(context, waitms = 1e3) {
 	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.ready) context.shell.write("\r");
+		if (!context.nextStdout.isReady) context.shell.write("\r");
 		resolve();
 	}, 1e3))]);
 	await Promise.race([context.nextStdout.wait(), new Promise((resolve) => setTimeout(() => {
-		if (!context.nextStdout.ready) context.shell.write("\r");
+		if (!context.nextStdout.isReady) context.shell.write("\r");
 		resolve();
 	}, 3e3))]);
 }
@@ -819,7 +977,10 @@ async function sendMessage(context, message, { waitForReady = true } = {}) {
 	context.shell.write(message);
 	context.idleWaiter.ping();
 	logger.debug(`waiting next stdout|${message}`);
-	await context.nextStdout.wait();
+	await Promise.race([context.nextStdout.wait(), new Promise((resolve) => setTimeout(() => {
+		logger.warn(`nextStdout.wait() timed out after 30s for message: ${message}`);
+		resolve();
+	}, 3e4))]);
 	logger.debug(`sending enter`);
 	await sendEnter(context, 1e3);
 	logger.debug(`sent enter`);
@@ -904,7 +1065,7 @@ function tryCatch(catchFn, fn) {
 //#endregion
 //#region package.json
 var name = "agent-yes";
-var version = "1.62.1";
+var version = "1.63.0";
 
 //#endregion
 //#region ts/pty-fix.ts
@@ -1360,7 +1521,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();
@@ -1777,7 +1938,7 @@ async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, ex
 		cancel(_reason) {
 			process.stdin.pause();
 		}
-	});
+	}, { highWaterMark: 16 });
 	let aborted = false;
 	await sflow(stdinStream).map((buffer) => {
 		const str = buffer.toString();
@@ -1839,7 +2000,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({
@@ -1950,4 +2118,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-BWhzaf_k.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-BFlBIzu3.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-BWhzaf_k.js";
+import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BFlBIzu3.js";
 import { t as logger } from "./logger-CX77vJDA.js";
 import { argv } from "process";
 import { spawn } from "child_process";

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-BWhzaf_k.js";
+import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-BFlBIzu3.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.1",
+  "version": "1.63.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;
@@ -687,52 +686,55 @@ export default async function agentYes({
   // CRITICAL FIX: fromReadable() from 'from-node-stream' doesn't work properly with stdin
   // because it doesn't handle Node.js stream modes correctly. We create a custom ReadableStream
   // that properly manages stdin's flowing mode and event listeners.
-  const stdinStream = new ReadableStream<Buffer>({
-    start(controller) {
-      // Set up stdin in flowing mode so 'data' events fire
-      process.stdin.resume();
-
-      let closed = false;
-
-      // Handle data events
-      const dataHandler = (chunk: Buffer) => {
-        try {
-          controller.enqueue(chunk);
-        } catch {
-          // Ignore enqueue errors (stream may be closed)
-        }
-      };
+  const stdinStream = new ReadableStream<Buffer>(
+    {
+      start(controller) {
+        // Set up stdin in flowing mode so 'data' events fire
+        process.stdin.resume();
+
+        let closed = false;
+
+        // Handle data events
+        const dataHandler = (chunk: Buffer) => {
+          try {
+            controller.enqueue(chunk);
+          } catch {
+            // Ignore enqueue errors (stream may be closed)
+          }
+        };
 
-      // Handle end/close - both events can fire, so track state
-      const endHandler = () => {
-        if (closed) return;
-        closed = true;
-        try {
-          controller.close();
-        } catch {
-          // Ignore close errors (already closed)
-        }
-      };
+        // Handle end/close - both events can fire, so track state
+        const endHandler = () => {
+          if (closed) return;
+          closed = true;
+          try {
+            controller.close();
+          } catch {
+            // Ignore close errors (already closed)
+          }
+        };
 
-      const errorHandler = (err: Error) => {
-        if (closed) return;
-        closed = true;
-        try {
-          controller.error(err);
-        } catch {
-          // Ignore error after close
-        }
-      };
+        const errorHandler = (err: Error) => {
+          if (closed) return;
+          closed = true;
+          try {
+            controller.error(err);
+          } catch {
+            // Ignore error after close
+          }
+        };
 
-      process.stdin.on("data", dataHandler);
-      process.stdin.on("end", endHandler);
-      process.stdin.on("close", endHandler);
-      process.stdin.on("error", errorHandler);
-    },
-    cancel(_reason) {
-      process.stdin.pause();
+        process.stdin.on("data", dataHandler);
+        process.stdin.on("end", endHandler);
+        process.stdin.on("close", endHandler);
+        process.stdin.on("error", errorHandler);
+      },
+      cancel(_reason) {
+        process.stdin.pause();
+      },
     },
-  });
+    { highWaterMark: 16 },
+  );
 
   let aborted = false;
   await sflow(stdinStream)
@@ -830,18 +832,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