claude-yes 1.35.1 → 1.36.1

package/dist/cli.js

@@ -20633,12 +20633,94 @@ import { fromReadable } from "from-node-stream";
 import { createReadStream as createReadStream2, mkdirSync } from "fs";
 import { unlink } from "fs/promises";
 import { dirname } from "path";
+import { createServer } from "net";
 function createFifoStream(cli, customPath) {
-  if (process.platform !== "linux") {
+  if (process.platform === "win32") {
+    return createWindowsNamedPipe(cli, customPath);
+  } else if (process.platform === "linux") {
+    return createLinuxFifo(cli, customPath);
+  } else {
+    logger.warn(`[${cli}-yes] IPC not supported on platform: ${process.platform}`);
+    return null;
+  }
+}
+function createWindowsNamedPipe(cli, customPath) {
+  try {
+    let pipePath;
+    if (customPath) {
+      pipePath = customPath;
+    } else {
+      const timestamp = new Date().toISOString().replace(/\D/g, "").slice(0, 17);
+      const randomSuffix = Math.random().toString(36).substring(2, 5);
+      pipePath = `\\\\.\\pipe\\agent-yes-${timestamp}${randomSuffix}`;
+    }
+    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,
+      cleanup
+    };
+  } catch (error) {
+    logger.warn(`[${cli}-yes] Failed to create Windows named pipe:`, error);
     return null;
   }
+}
+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;
@@ -20647,12 +20729,19 @@ function createFifoStream(cli, customPath) {
       const randomSuffix = Math.random().toString(36).substring(2, 5);
       fifoPath = `/tmp/agent-yes-${timestamp}${randomSuffix}.stdin`;
     }
-    mkdirSync(dirname(fifoPath), { recursive: true });
-    const mkfifoResult = execaCommandSync(`mkfifo ${fifoPath}`, {
+    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}`);
       }
@@ -20732,7 +20821,7 @@ var init_fifo = __esm(() => {
 });
 
 // ts/pidStore.ts
-import { mkdir as mkdir3 } from "fs/promises";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 import path9 from "path";
 
 class SqliteAdapter {
@@ -20776,15 +20865,16 @@ class SqliteAdapter {
 
 class PidStore {
   db;
-  baseDir;
+  storeDir;
   dbPath;
   constructor(workingDir) {
-    this.baseDir = path9.resolve(workingDir, ".agent-yes");
-    this.dbPath = path9.join(this.baseDir, "pid.sqlite");
+    this.storeDir = path9.resolve(workingDir, ".agent-yes");
+    this.dbPath = path9.join(this.storeDir, "pid.sqlite");
   }
   async init() {
-    await mkdir3(path9.join(this.baseDir, "logs"), { recursive: true });
-    await mkdir3(path9.join(this.baseDir, "fifo"), { recursive: true });
+    await mkdir3(path9.join(this.storeDir, "logs"), { recursive: true });
+    await mkdir3(path9.join(this.storeDir, "fifo"), { recursive: true });
+    await this.ensureGitignore();
     this.db = new SqliteAdapter;
     await this.db.init(this.dbPath);
     this.db.run("PRAGMA journal_mode=WAL");
@@ -20856,10 +20946,14 @@ class PidStore {
     logger.debug(`[pidStore] Updated process ${pid} status=${status}`);
   }
   getLogPath(pid) {
-    return path9.resolve(this.baseDir, "logs", `${pid}.log`);
+    return path9.resolve(this.storeDir, "logs", `${pid}.log`);
   }
   getFifoPath(pid) {
-    return path9.resolve(this.baseDir, "fifo", `${pid}.stdin`);
+    if (process.platform === "win32") {
+      return `\\\\.\\pipe\\agent-yes-${pid}`;
+    } else {
+      return path9.resolve(this.storeDir, "fifo", `${pid}.stdin`);
+    }
   }
   async cleanStaleRecords() {
     const activeRecords = this.db.query("SELECT * FROM pid_records WHERE status != 'exited'");
@@ -20888,6 +20982,28 @@ class PidStore {
       return false;
     }
   }
+  async ensureGitignore() {
+    const gitignorePath = path9.join(this.storeDir, ".gitignore");
+    const gitignoreContent = `# Auto-generated .gitignore for agent-yes
+# Ignore all log files and runtime data
+logs/
+fifo/
+*.sqlite
+*.sqlite-*
+*.log
+*.raw.log
+*.lines.log
+*.debug.log
+`;
+    try {
+      await writeFile3(gitignorePath, gitignoreContent, { flag: "wx" });
+      logger.debug(`[pidStore] Created .gitignore in ${this.storeDir}`);
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        logger.warn(`[pidStore] Failed to create .gitignore:`, error);
+      }
+    }
+  }
   static async findActiveFifo(workingDir) {
     const store = new PidStore(workingDir);
     await store.init();
@@ -21026,8 +21142,11 @@ function getDefaultConfig() {
         fatal: []
       },
       amp: {
-        help: "",
-        install: "npm i -g @sourcegraph/amp",
+        help: "https://ampcode.com/",
+        install: {
+          bash: "curl -fsSL https://ampcode.com/install.sh | bash",
+          npm: "npm i -g @sourcegraph/amp"
+        },
         enter: [
           /^.{0,4} Approve /
         ]
@@ -21221,7 +21340,7 @@ __export(exports_ts, {
   CLIS_CONFIG: () => CLIS_CONFIG2
 });
 import { fromReadable as fromReadable3, fromWritable as fromWritable2 } from "from-node-stream";
-import { mkdir as mkdir7, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile4, writeFile as writeFile7 } from "fs/promises";
 import path13 from "path";
 async function agentYes2({
   cli,
@@ -21568,15 +21687,15 @@ ${prompt}` : prefix;
   }).by((s) => {
     if (!useFifo)
       return s;
-    const fifoResult = createFifoStream(cli, pidStore.getFifoPath(shell.pid));
-    if (!fifoResult)
+    const ipcResult = createFifoStream(cli, pidStore.getFifoPath(shell.pid));
+    if (!ipcResult)
       return s;
-    pendingExitCode.promise.finally(() => fifoResult.cleanup());
+    pendingExitCode.promise.finally(() => ipcResult.cleanup());
     process.stderr.write(`
   Append prompts: ${cli}-yes --append-prompt '...'
 
 `);
-    return s.merge(fifoResult.stream);
+    return s.merge(ipcResult.stream);
   }).onStart(async function promptOnStart() {
     logger.debug("Sending prompt message: " + JSON.stringify(prompt));
     if (prompt)
@@ -21598,7 +21717,7 @@ ${prompt}` : prefix;
     return await mkdir7(path13.dirname(rawLogPath), { recursive: true }).then(() => {
       logger.debug(`[${cli}-yes] raw logs streaming to ${rawLogPath}`);
       return f.forEach(async (chars) => {
-        await writeFile5(rawLogPath, chars, { flag: "a" }).catch(() => null);
+        await writeFile7(rawLogPath, chars, { flag: "a" }).catch(() => null);
       }).run();
     }).catch(() => f.run());
   }).by(function consoleResponder(e) {
@@ -21670,7 +21789,7 @@ ${prompt}` : prefix;
   })).to(fromWritable2(process.stdout));
   if (logPath) {
     await mkdir7(path13.dirname(logPath), { recursive: true }).catch(() => null);
-    await writeFile5(logPath, terminalRender.render()).catch(() => null);
+    await writeFile7(logPath, terminalRender.render()).catch(() => null);
     logger.info(`[${cli}-yes] Full logs saved to ${logPath}`);
   }
   const exitCode = await pendingExitCode.promise;
@@ -21682,7 +21801,7 @@ ${prompt}` : prefix;
       logger.info(`[${cli}-yes] Writing rendered logs to ${logFile}`);
     const logFilePath = path13.resolve(logFile);
     await mkdir7(path13.dirname(logFilePath), { recursive: true }).catch(() => null);
-    await writeFile5(logFilePath, terminalRender.render());
+    await writeFile7(logFilePath, terminalRender.render());
   }
   return { exitCode, logs: terminalRender.render() };
   async function sendEnter(waitms = 1000) {
@@ -21701,6 +21820,15 @@ ${prompt}` : prefix;
         resolve5();
       }, 1000))
     ]);
+    await Promise.race([
+      nextStdout.wait(),
+      new Promise((resolve5) => setTimeout(() => {
+        if (!nextStdout.ready) {
+          shell.write("\r");
+        }
+        resolve5();
+      }, 3000))
+    ]);
   }
   async function sendMessage3(message, { waitForReady = true } = {}) {
     if (waitForReady)
@@ -21772,7 +21900,7 @@ init_pidStore();
 await init_pty();
 var import_winston2 = __toESM(require_winston(), 1);
 import { fromReadable as fromReadable2, fromWritable } from "from-node-stream";
-import { mkdir as mkdir5, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
 import path11 from "path";
 var config = await init_agent_yes_config().then(() => exports_agent_yes_config).then((mod) => mod.default || mod);
 var CLIS_CONFIG = config.clis;
@@ -22121,15 +22249,15 @@ ${prompt}` : prefix;
   }).by((s) => {
     if (!useFifo)
       return s;
-    const fifoResult = createFifoStream(cli, pidStore.getFifoPath(shell.pid));
-    if (!fifoResult)
+    const ipcResult = createFifoStream(cli, pidStore.getFifoPath(shell.pid));
+    if (!ipcResult)
       return s;
-    pendingExitCode.promise.finally(() => fifoResult.cleanup());
+    pendingExitCode.promise.finally(() => ipcResult.cleanup());
     process.stderr.write(`
   Append prompts: ${cli}-yes --append-prompt '...'
 
 `);
-    return s.merge(fifoResult.stream);
+    return s.merge(ipcResult.stream);
   }).onStart(async function promptOnStart() {
     logger.debug("Sending prompt message: " + JSON.stringify(prompt));
     if (prompt)
@@ -22151,7 +22279,7 @@ ${prompt}` : prefix;
     return await mkdir5(path11.dirname(rawLogPath), { recursive: true }).then(() => {
       logger.debug(`[${cli}-yes] raw logs streaming to ${rawLogPath}`);
       return f.forEach(async (chars) => {
-        await writeFile3(rawLogPath, chars, { flag: "a" }).catch(() => null);
+        await writeFile4(rawLogPath, chars, { flag: "a" }).catch(() => null);
       }).run();
     }).catch(() => f.run());
   }).by(function consoleResponder(e) {
@@ -22223,7 +22351,7 @@ ${prompt}` : prefix;
   })).to(fromWritable(process.stdout));
   if (logPath) {
     await mkdir5(path11.dirname(logPath), { recursive: true }).catch(() => null);
-    await writeFile3(logPath, terminalRender.render()).catch(() => null);
+    await writeFile4(logPath, terminalRender.render()).catch(() => null);
     logger.info(`[${cli}-yes] Full logs saved to ${logPath}`);
   }
   const exitCode = await pendingExitCode.promise;
@@ -22235,7 +22363,7 @@ ${prompt}` : prefix;
       logger.info(`[${cli}-yes] Writing rendered logs to ${logFile}`);
     const logFilePath = path11.resolve(logFile);
     await mkdir5(path11.dirname(logFilePath), { recursive: true }).catch(() => null);
-    await writeFile3(logFilePath, terminalRender.render());
+    await writeFile4(logFilePath, terminalRender.render());
   }
   return { exitCode, logs: terminalRender.render() };
   async function sendEnter(waitms = 1000) {
@@ -22254,6 +22382,15 @@ ${prompt}` : prefix;
         resolve();
       }, 1000))
     ]);
+    await Promise.race([
+      nextStdout.wait(),
+      new Promise((resolve) => setTimeout(() => {
+        if (!nextStdout.ready) {
+          shell.write("\r");
+        }
+        resolve();
+      }, 3000))
+    ]);
   }
   async function sendMessage3(message, { waitForReady = true } = {}) {
     if (waitForReady)
@@ -24132,13 +24269,13 @@ function stringWidth3(string, options = {}) {
 }
 
 // node_modules/y18n/build/lib/platform-shims/node.js
-import { readFileSync as readFileSync4, statSync as statSync3, writeFile as writeFile4 } from "fs";
+import { readFileSync as readFileSync4, statSync as statSync3, writeFile as writeFile5 } from "fs";
 import { format as format3 } from "util";
 import { resolve as resolve3 } from "path";
 var node_default = {
   fs: {
     readFileSync: readFileSync4,
-    writeFile: writeFile4
+    writeFile: writeFile5
   },
   format: format3,
   resolve: resolve3,
@@ -27848,7 +27985,7 @@ var package_default = {
 // ts/parseCliArgs.ts
 function parseCliArgs(argv) {
   const cliName = argv[1]?.split(/[/\\]/).at(-1)?.replace(/(\.[jt]s)?$/, "").replace(/^(cli|agent)(-yes$)?/, "").replace(/^ay$/, "").replace(/-yes$/, "") || undefined;
-  const parsedArgv = yargs_default(hideBin(argv)).usage("Usage: $0 [cli] [agent-yes args] [agent-cli args] [--] [prompts...]").example("$0 claude --idle=30s -- solve all todos in my codebase, commit one by one", "Run Claude with a 30 seconds idle timeout, and the prompt is everything after `--`").option("robust", {
+  const parsedArgv = yargs_default(hideBin(argv)).usage("Usage: $0 [cli] [agent-yes args] [agent-cli args] [--] [prompts...]").example("$0 claude --idle=30s -- solve all todos in my codebase, commit one by one", "Run Claude with a 30 seconds idle timeout, and the prompt is everything after `--`").example("$0 claude --stdpush", "Run Claude with external stdin input enabled via --append-prompt").option("robust", {
     type: "boolean",
     default: true,
     description: "re-spawn Claude with --continue if it crashes, only works for claude yet",
@@ -27896,11 +28033,12 @@ function parseCliArgs(argv) {
     alias: "c"
   }).option("append-prompt", {
     type: "string",
-    description: "Send a prompt to the active agent's FIFO stdin in current directory"
-  }).option("fifo", {
+    description: "Send a prompt to the active agent's stdin in current directory"
+  }).option("stdpush", {
     type: "boolean",
-    description: "Enable FIFO input stream for additional stdin input (Linux only)",
-    default: false
+    description: "Enable external input stream to push additional data to stdin",
+    default: false,
+    alias: ["ipc", "fifo"]
   }).positional("cli", {
     describe: "The AI CLI to run, e.g., claude, codex, copilot, cursor, gemini",
     type: "string",
@@ -27973,7 +28111,7 @@ function parseCliArgs(argv) {
     resume: parsedArgv.continue,
     useSkills: parsedArgv.useSkills,
     appendPrompt: parsedArgv.appendPrompt,
-    useFifo: parsedArgv.fifo
+    useFifo: parsedArgv.stdpush || parsedArgv.ipc || parsedArgv.fifo
   };
 }
 
@@ -27996,7 +28134,7 @@ var logger2 = import_winston3.default.createLogger({
 
 // ts/pidStore.ts
 init_logger();
-import { mkdir as mkdir6 } from "fs/promises";
+import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
 import path12 from "path";
 
 class SqliteAdapter2 {
@@ -28040,15 +28178,16 @@ class SqliteAdapter2 {
 
 class PidStore2 {
   db;
-  baseDir;
+  storeDir;
   dbPath;
   constructor(workingDir) {
-    this.baseDir = path12.resolve(workingDir, ".agent-yes");
-    this.dbPath = path12.join(this.baseDir, "pid.sqlite");
+    this.storeDir = path12.resolve(workingDir, ".agent-yes");
+    this.dbPath = path12.join(this.storeDir, "pid.sqlite");
   }
   async init() {
-    await mkdir6(path12.join(this.baseDir, "logs"), { recursive: true });
-    await mkdir6(path12.join(this.baseDir, "fifo"), { recursive: true });
+    await mkdir6(path12.join(this.storeDir, "logs"), { recursive: true });
+    await mkdir6(path12.join(this.storeDir, "fifo"), { recursive: true });
+    await this.ensureGitignore();
     this.db = new SqliteAdapter2;
     await this.db.init(this.dbPath);
     this.db.run("PRAGMA journal_mode=WAL");
@@ -28120,10 +28259,14 @@ class PidStore2 {
     logger.debug(`[pidStore] Updated process ${pid} status=${status}`);
   }
   getLogPath(pid) {
-    return path12.resolve(this.baseDir, "logs", `${pid}.log`);
+    return path12.resolve(this.storeDir, "logs", `${pid}.log`);
   }
   getFifoPath(pid) {
-    return path12.resolve(this.baseDir, "fifo", `${pid}.stdin`);
+    if (process.platform === "win32") {
+      return `\\\\.\\pipe\\agent-yes-${pid}`;
+    } else {
+      return path12.resolve(this.storeDir, "fifo", `${pid}.stdin`);
+    }
   }
   async cleanStaleRecords() {
     const activeRecords = this.db.query("SELECT * FROM pid_records WHERE status != 'exited'");
@@ -28152,6 +28295,28 @@ class PidStore2 {
       return false;
     }
   }
+  async ensureGitignore() {
+    const gitignorePath = path12.join(this.storeDir, ".gitignore");
+    const gitignoreContent = `# Auto-generated .gitignore for agent-yes
+# Ignore all log files and runtime data
+logs/
+fifo/
+*.sqlite
+*.sqlite-*
+*.log
+*.raw.log
+*.lines.log
+*.debug.log
+`;
+    try {
+      await writeFile6(gitignorePath, gitignoreContent, { flag: "wx" });
+      logger.debug(`[pidStore] Created .gitignore in ${this.storeDir}`);
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        logger.warn(`[pidStore] Failed to create .gitignore:`, error);
+      }
+    }
+  }
   static async findActiveFifo(workingDir) {
     const store = new PidStore2(workingDir);
     await store.init();
@@ -28164,16 +28329,42 @@ class PidStore2 {
 // ts/cli.ts
 var config3 = parseCliArgs(process.argv);
 if (config3.appendPrompt) {
-  const fifoPath = await PidStore2.findActiveFifo(process.cwd());
-  if (!fifoPath) {
-    console.error("No active agent with FIFO found in current directory.");
+  const ipcPath = await PidStore2.findActiveFifo(process.cwd());
+  if (!ipcPath) {
+    console.error("No active agent with IPC found in current directory.");
+    process.exit(1);
+  }
+  try {
+    if (process.platform === "win32") {
+      const { connect } = await import("net");
+      await new Promise((resolve5, reject) => {
+        const client = connect(ipcPath);
+        client.on("connect", () => {
+          client.write(config3.appendPrompt + "\r");
+          client.end();
+          console.log(`Sent prompt to Windows named pipe: ${ipcPath}`);
+          resolve5();
+        });
+        client.on("error", (error) => {
+          console.error(`Failed to connect to named pipe: ${error}`);
+          reject(error);
+        });
+        setTimeout(() => {
+          client.destroy();
+          reject(new Error("Connection timeout"));
+        }, 5000);
+      });
+    } else {
+      const { writeFileSync: writeFileSync2, openSync, closeSync } = await import("fs");
+      const fd = openSync(ipcPath, "w");
+      writeFileSync2(fd, config3.appendPrompt + "\r");
+      closeSync(fd);
+      console.log(`Sent prompt to FIFO: ${ipcPath}`);
+    }
+  } catch (error) {
+    console.error(`Failed to send prompt: ${error}`);
     process.exit(1);
   }
-  const { writeFileSync: writeFileSync2, openSync, closeSync } = await import("fs");
-  const fd = openSync(fifoPath, "w");
-  writeFileSync2(fd, config3.appendPrompt + "\r");
-  closeSync(fd);
-  console.log(`Sent prompt to ${fifoPath}`);
   process.exit(0);
 }
 if (!config3.cli) {
@@ -28190,5 +28381,5 @@ var { exitCode } = await cliYes(config3);
 console.log("exiting process");
 process.exit(exitCode ?? 1);
 
-//# debugId=624A56792A6F741964756E2164756E21
+//# debugId=2520933E2CA2793364756E2164756E21
 //# sourceMappingURL=cli.js.map

package/dist/index.js

@@ -20631,12 +20631,94 @@ import { fromReadable } from "from-node-stream";
 import { createReadStream as createReadStream2, mkdirSync } from "fs";
 import { unlink } from "fs/promises";
 import { dirname } from "path";
+import { createServer } from "net";
 function createFifoStream(cli, customPath) {
-  if (process.platform !== "linux") {
+  if (process.platform === "win32") {
+    return createWindowsNamedPipe(cli, customPath);
+  } else if (process.platform === "linux") {
+    return createLinuxFifo(cli, customPath);
+  } else {
+    logger.warn(`[${cli}-yes] IPC not supported on platform: ${process.platform}`);
     return null;
   }
+}
+function createWindowsNamedPipe(cli, customPath) {
+  try {
+    let pipePath;
+    if (customPath) {
+      pipePath = customPath;
+    } else {
+      const timestamp = new Date().toISOString().replace(/\D/g, "").slice(0, 17);
+      const randomSuffix = Math.random().toString(36).substring(2, 5);
+      pipePath = `\\\\.\\pipe\\agent-yes-${timestamp}${randomSuffix}`;
+    }
+    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,
+      cleanup
+    };
+  } catch (error) {
+    logger.warn(`[${cli}-yes] Failed to create Windows named pipe:`, error);
+    return null;
+  }
+}
+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;
@@ -20645,12 +20727,19 @@ function createFifoStream(cli, customPath) {
       const randomSuffix = Math.random().toString(36).substring(2, 5);
       fifoPath = `/tmp/agent-yes-${timestamp}${randomSuffix}.stdin`;
     }
-    mkdirSync(dirname(fifoPath), { recursive: true });
-    const mkfifoResult = execaCommandSync(`mkfifo ${fifoPath}`, {
+    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}`);
       }
@@ -20730,7 +20819,7 @@ var init_fifo = __esm(() => {
 });
 
 // ts/pidStore.ts
-import { mkdir as mkdir3 } from "fs/promises";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 import path9 from "path";
 
 class SqliteAdapter {
@@ -20774,15 +20863,16 @@ class SqliteAdapter {
 
 class PidStore {
   db;
-  baseDir;
+  storeDir;
   dbPath;
   constructor(workingDir) {
-    this.baseDir = path9.resolve(workingDir, ".agent-yes");
-    this.dbPath = path9.join(this.baseDir, "pid.sqlite");
+    this.storeDir = path9.resolve(workingDir, ".agent-yes");
+    this.dbPath = path9.join(this.storeDir, "pid.sqlite");
   }
   async init() {
-    await mkdir3(path9.join(this.baseDir, "logs"), { recursive: true });
-    await mkdir3(path9.join(this.baseDir, "fifo"), { recursive: true });
+    await mkdir3(path9.join(this.storeDir, "logs"), { recursive: true });
+    await mkdir3(path9.join(this.storeDir, "fifo"), { recursive: true });
+    await this.ensureGitignore();
     this.db = new SqliteAdapter;
     await this.db.init(this.dbPath);
     this.db.run("PRAGMA journal_mode=WAL");
@@ -20854,10 +20944,14 @@ class PidStore {
     logger.debug(`[pidStore] Updated process ${pid} status=${status}`);
   }
   getLogPath(pid) {
-    return path9.resolve(this.baseDir, "logs", `${pid}.log`);
+    return path9.resolve(this.storeDir, "logs", `${pid}.log`);
   }
   getFifoPath(pid) {
-    return path9.resolve(this.baseDir, "fifo", `${pid}.stdin`);
+    if (process.platform === "win32") {
+      return `\\\\.\\pipe\\agent-yes-${pid}`;
+    } else {
+      return path9.resolve(this.storeDir, "fifo", `${pid}.stdin`);
+    }
   }
   async cleanStaleRecords() {
     const activeRecords = this.db.query("SELECT * FROM pid_records WHERE status != 'exited'");
@@ -20886,6 +20980,28 @@ class PidStore {
       return false;
     }
   }
+  async ensureGitignore() {
+    const gitignorePath = path9.join(this.storeDir, ".gitignore");
+    const gitignoreContent = `# Auto-generated .gitignore for agent-yes
+# Ignore all log files and runtime data
+logs/
+fifo/
+*.sqlite
+*.sqlite-*
+*.log
+*.raw.log
+*.lines.log
+*.debug.log
+`;
+    try {
+      await writeFile3(gitignorePath, gitignoreContent, { flag: "wx" });
+      logger.debug(`[pidStore] Created .gitignore in ${this.storeDir}`);
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        logger.warn(`[pidStore] Failed to create .gitignore:`, error);
+      }
+    }
+  }
   static async findActiveFifo(workingDir) {
     const store = new PidStore(workingDir);
     await store.init();
@@ -21024,8 +21140,11 @@ function getDefaultConfig() {
         fatal: []
       },
       amp: {
-        help: "",
-        install: "npm i -g @sourcegraph/amp",
+        help: "https://ampcode.com/",
+        install: {
+          bash: "curl -fsSL https://ampcode.com/install.sh | bash",
+          npm: "npm i -g @sourcegraph/amp"
+        },
         enter: [
           /^.{0,4} Approve /
         ]
@@ -21195,7 +21314,7 @@ init_pidStore();
 await init_pty();
 var import_winston2 = __toESM(require_winston(), 1);
 import { fromReadable as fromReadable2, fromWritable } from "from-node-stream";
-import { mkdir as mkdir5, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
 import path11 from "path";
 var config = await init_agent_yes_config().then(() => exports_agent_yes_config).then((mod) => mod.default || mod);
 var CLIS_CONFIG = config.clis;
@@ -21544,15 +21663,15 @@ ${prompt}` : prefix;
   }).by((s) => {
     if (!useFifo)
       return s;
-    const fifoResult = createFifoStream(cli, pidStore.getFifoPath(shell.pid));
-    if (!fifoResult)
+    const ipcResult = createFifoStream(cli, pidStore.getFifoPath(shell.pid));
+    if (!ipcResult)
       return s;
-    pendingExitCode.promise.finally(() => fifoResult.cleanup());
+    pendingExitCode.promise.finally(() => ipcResult.cleanup());
     process.stderr.write(`
   Append prompts: ${cli}-yes --append-prompt '...'
 
 `);
-    return s.merge(fifoResult.stream);
+    return s.merge(ipcResult.stream);
   }).onStart(async function promptOnStart() {
     logger.debug("Sending prompt message: " + JSON.stringify(prompt));
     if (prompt)
@@ -21574,7 +21693,7 @@ ${prompt}` : prefix;
     return await mkdir5(path11.dirname(rawLogPath), { recursive: true }).then(() => {
       logger.debug(`[${cli}-yes] raw logs streaming to ${rawLogPath}`);
       return f.forEach(async (chars) => {
-        await writeFile3(rawLogPath, chars, { flag: "a" }).catch(() => null);
+        await writeFile4(rawLogPath, chars, { flag: "a" }).catch(() => null);
       }).run();
     }).catch(() => f.run());
   }).by(function consoleResponder(e) {
@@ -21646,7 +21765,7 @@ ${prompt}` : prefix;
   })).to(fromWritable(process.stdout));
   if (logPath) {
     await mkdir5(path11.dirname(logPath), { recursive: true }).catch(() => null);
-    await writeFile3(logPath, terminalRender.render()).catch(() => null);
+    await writeFile4(logPath, terminalRender.render()).catch(() => null);
     logger.info(`[${cli}-yes] Full logs saved to ${logPath}`);
   }
   const exitCode = await pendingExitCode.promise;
@@ -21658,7 +21777,7 @@ ${prompt}` : prefix;
       logger.info(`[${cli}-yes] Writing rendered logs to ${logFile}`);
     const logFilePath = path11.resolve(logFile);
     await mkdir5(path11.dirname(logFilePath), { recursive: true }).catch(() => null);
-    await writeFile3(logFilePath, terminalRender.render());
+    await writeFile4(logFilePath, terminalRender.render());
   }
   return { exitCode, logs: terminalRender.render() };
   async function sendEnter(waitms = 1000) {
@@ -21677,6 +21796,15 @@ ${prompt}` : prefix;
         resolve();
       }, 1000))
     ]);
+    await Promise.race([
+      nextStdout.wait(),
+      new Promise((resolve) => setTimeout(() => {
+        if (!nextStdout.ready) {
+          shell.write("\r");
+        }
+        resolve();
+      }, 3000))
+    ]);
   }
   async function sendMessage3(message, { waitForReady = true } = {}) {
     if (waitForReady)
@@ -21725,5 +21853,5 @@ export {
   CLIS_CONFIG
 };
 
-//# debugId=41F67CAFCE0253CB64756E2164756E21
+//# debugId=581E1D2585250E0F64756E2164756E21
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-yes",
-  "version": "1.35.1",
+  "version": "1.36.1",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

package/ts/cli.ts

@@ -10,18 +10,48 @@ import { PidStore } from "./pidStore.ts";
 // Parse CLI arguments
 const config = parseCliArgs(process.argv);
 
-// Handle --append-prompt: write to active FIFO and exit
+// Handle --append-prompt: write to active IPC (FIFO/Named Pipe) and exit
 if (config.appendPrompt) {
-  const fifoPath = await PidStore.findActiveFifo(process.cwd());
-  if (!fifoPath) {
-    console.error("No active agent with FIFO found in current directory.");
+  const ipcPath = await PidStore.findActiveFifo(process.cwd());
+  if (!ipcPath) {
+    console.error("No active agent with IPC found in current directory.");
+    process.exit(1);
+  }
+
+  try {
+    if (process.platform === "win32") {
+      // Windows named pipe
+      const { connect } = await import("net");
+      await new Promise<void>((resolve, reject) => {
+        const client = connect(ipcPath);
+        client.on('connect', () => {
+          client.write(config.appendPrompt + "\r");
+          client.end();
+          console.log(`Sent prompt to Windows named pipe: ${ipcPath}`);
+          resolve();
+        });
+        client.on('error', (error) => {
+          console.error(`Failed to connect to named pipe: ${error}`);
+          reject(error);
+        });
+        // Timeout after 5 seconds
+        setTimeout(() => {
+          client.destroy();
+          reject(new Error('Connection timeout'));
+        }, 5000);
+      });
+    } else {
+      // Linux FIFO (original implementation)
+      const { writeFileSync, openSync, closeSync } = await import("fs");
+      const fd = openSync(ipcPath, "w");
+      writeFileSync(fd, config.appendPrompt + "\r");
+      closeSync(fd);
+      console.log(`Sent prompt to FIFO: ${ipcPath}`);
+    }
+  } catch (error) {
+    console.error(`Failed to send prompt: ${error}`);
     process.exit(1);
   }
-  const { writeFileSync, openSync, closeSync } = await import("fs");
-  const fd = openSync(fifoPath, "w");
-  writeFileSync(fd, config.appendPrompt + "\r");
-  closeSync(fd);
-  console.log(`Sent prompt to ${fifoPath}`);
   process.exit(0);
 }
 

package/ts/index.ts

@@ -580,14 +580,14 @@ export default async function agentYes({
       });
     })
 
-    // read from FIFO if available, e.g. /tmp/agent-yes-*.stdin, which can be used to send additional input from other processes
+    // read from IPC stream if available (FIFO on Linux, Named Pipes on Windows)
     .by((s) => {
       if (!useFifo) return s;
-      const fifoResult = createFifoStream(cli, pidStore.getFifoPath(shell.pid));
-      if (!fifoResult) return s;
-      pendingExitCode.promise.finally(() => fifoResult.cleanup());
+      const ipcResult = createFifoStream(cli, pidStore.getFifoPath(shell.pid));
+      if (!ipcResult) return s;
+      pendingExitCode.promise.finally(() => ipcResult.cleanup());
       process.stderr.write(`\n  Append prompts: ${cli}-yes --append-prompt '...'\n\n`);
-      return s.merge(fifoResult.stream);
+      return s.merge(ipcResult.stream);
     })
 
     // .map((e) => e.replaceAll('\x1a', '')) // remove ctrl+z from user's input, to prevent bug (but this seems bug)
@@ -808,6 +808,19 @@ export default async function agentYes({
         }, 1000),
       ),
     ]);
+
+    // retry the second time if not received any output in 3 second after sending Enter
+    await Promise.race([
+      nextStdout.wait(),
+      new Promise<void>((resolve) =>
+        setTimeout(() => {
+          if (!nextStdout.ready) {
+            shell.write("\r");
+          }
+          resolve();
+        }, 3000),
+      ),
+    ]);
   }
 
   async function sendMessage(message: string, { waitForReady = true } = {}) {

package/ts/parseCliArgs.ts

@@ -27,6 +27,10 @@ export function parseCliArgs(argv: string[]) {
       "$0 claude --idle=30s -- solve all todos in my codebase, commit one by one",
       "Run Claude with a 30 seconds idle timeout, and the prompt is everything after `--`",
     )
+    .example(
+      "$0 claude --stdpush",
+      "Run Claude with external stdin input enabled via --append-prompt",
+    )
     // TODO: add a --docker option, will tell cli.ts to start docker process with tty and handles all stdio forwarding
 
     .option("robust", {
@@ -91,12 +95,13 @@ export function parseCliArgs(argv: string[]) {
     })
     .option("append-prompt", {
       type: "string",
-      description: "Send a prompt to the active agent's FIFO stdin in current directory",
+      description: "Send a prompt to the active agent's stdin in current directory",
     })
-    .option("fifo", {
+    .option("stdpush", {
       type: "boolean",
-      description: "Enable FIFO input stream for additional stdin input (Linux only)",
+      description: "Enable external input stream to push additional data to stdin",
       default: false,
+      alias: ["ipc", "fifo"], // backward compatibility
     })
     .positional("cli", {
       describe: "The AI CLI to run, e.g., claude, codex, copilot, cursor, gemini",
@@ -191,6 +196,6 @@ export function parseCliArgs(argv: string[]) {
     resume: parsedArgv.continue, // Note: intentional use resume here to avoid preserved keyword (continue)
     useSkills: parsedArgv.useSkills,
     appendPrompt: parsedArgv.appendPrompt,
-    useFifo: parsedArgv.fifo,
+    useFifo: parsedArgv.stdpush || parsedArgv.ipc || parsedArgv.fifo, // Support --stdpush, --ipc, and --fifo (backward compatibility)
   };
 }

package/ts/pidStore.ts

@@ -1,4 +1,4 @@
-import { mkdir } from "fs/promises";
+import { mkdir, writeFile } from "fs/promises";
 import path from "path";
 import { logger } from "./logger.ts";
 
@@ -67,17 +67,20 @@ class SqliteAdapter {
 
 export class PidStore {
   protected db!: SqliteAdapter;
-  private baseDir: string;
+  private storeDir: string;
   private dbPath: string;
 
   constructor(workingDir: string) {
-    this.baseDir = path.resolve(workingDir, ".agent-yes");
-    this.dbPath = path.join(this.baseDir, "pid.sqlite");
+    this.storeDir = path.resolve(workingDir, ".agent-yes");
+    this.dbPath = path.join(this.storeDir, "pid.sqlite");
   }
 
   async init(): Promise<void> {
-    await mkdir(path.join(this.baseDir, "logs"), { recursive: true });
-    await mkdir(path.join(this.baseDir, "fifo"), { recursive: true });
+    await mkdir(path.join(this.storeDir, "logs"), { recursive: true });
+    await mkdir(path.join(this.storeDir, "fifo"), { recursive: true });
+
+    // Auto-generate .gitignore for .agent-yes directory
+    await this.ensureGitignore();
 
     this.db = new SqliteAdapter();
     await this.db.init(this.dbPath);
@@ -182,11 +185,17 @@ export class PidStore {
   }
 
   getLogPath(pid: number): string {
-    return path.resolve(this.baseDir, "logs", `${pid}.log`);
+    return path.resolve(this.storeDir, "logs", `${pid}.log`);
   }
 
   getFifoPath(pid: number): string {
-    return path.resolve(this.baseDir, "fifo", `${pid}.stdin`);
+    if (process.platform === "win32") {
+      // Windows named pipe format
+      return `\\\\.\\pipe\\agent-yes-${pid}`;
+    } else {
+      // Linux FIFO file path
+      return path.resolve(this.storeDir, "fifo", `${pid}.stdin`);
+    }
   }
 
   async cleanStaleRecords(): Promise<void> {
@@ -226,6 +235,31 @@ export class PidStore {
     }
   }
 
+  private async ensureGitignore(): Promise<void> {
+    const gitignorePath = path.join(this.storeDir, ".gitignore");
+    const gitignoreContent = `# Auto-generated .gitignore for agent-yes
+# Ignore all log files and runtime data
+logs/
+fifo/
+*.sqlite
+*.sqlite-*
+*.log
+*.raw.log
+*.lines.log
+*.debug.log
+`;
+
+    try {
+      await writeFile(gitignorePath, gitignoreContent, { flag: 'wx' }); // wx = create only if doesn't exist
+      logger.debug(`[pidStore] Created .gitignore in ${this.storeDir}`);
+    } catch (error: any) {
+      if (error.code !== 'EEXIST') {
+        logger.warn(`[pidStore] Failed to create .gitignore:`, error);
+      }
+      // If file exists, that's fine - don't overwrite existing gitignore
+    }
+  }
+
   static async findActiveFifo(workingDir: string): Promise<string | null> {
     const store = new PidStore(workingDir);
     await store.init();