claude-yes 1.31.1 → 1.32.1

package/ts/index.ts

@@ -1,57 +1,65 @@
-import { execaCommand, execaCommandSync, parseCommandString } from 'execa';
-import { fromReadable, fromWritable } from 'from-node-stream';
-import { mkdir, writeFile } from 'fs/promises';
-import path from 'path';
-import DIE from 'phpdie';
-import sflow from 'sflow';
-import { TerminalTextRender } from 'terminal-render';
-import rawConfig from '../cli-yes.config.js';
-import { catcher } from './catcher.js';
+import { execaCommandSync, parseCommandString } from "execa";
+import { fromReadable, fromWritable } from "from-node-stream";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import DIE from "phpdie";
+import sflow from "sflow";
+import { TerminalTextRender } from "terminal-render";
+import { catcher } from "./catcher.ts";
 import {
   extractSessionId,
   getSessionForCwd,
   storeSessionForCwd,
-} from './codexSessionManager.js';
-import { IdleWaiter } from './idleWaiter';
-import { ReadyManager } from './ReadyManager';
-import { removeControlCharacters } from './removeControlCharacters';
-import {
-  acquireLock,
-  releaseLock,
-  shouldUseLock,
-  updateCurrentTaskStatus,
-} from './runningLock';
-import { yesLog } from './yesLog';
-
-export { parseCliArgs } from './parseCliArgs';
+} from "./resume/codexSessionManager.ts";
+import { IdleWaiter } from "./idleWaiter.ts";
+import pty, { ptyPackage } from "./pty.ts";
+import { ReadyManager } from "./ReadyManager.ts";
+import { removeControlCharacters } from "./removeControlCharacters.ts";
+import { acquireLock, releaseLock, shouldUseLock } from "./runningLock.ts";
+import { logger } from "./logger.ts";
+import { createFifoStream } from "./beta/fifo.ts";
+import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
+import winston from "winston";
+import { mapObject, pipe } from "rambda";
+
 export { removeControlCharacters };
 
 export type AgentCliConfig = {
+  // cli
   install?: string; // hint user for install command if not installed
   version?: string; // hint user for version command to check if installed
   binary?: string; // actual binary name if different from cli, e.g. cursor -> cursor-agent
+  defaultArgs?: string[]; // function to ensure certain args are present
+
+  // status detect, and actions
   ready?: RegExp[]; // regex matcher for stdin ready, or line index for gemini
-  enter?: RegExp[]; // array of regex to match for sending Enter
   fatal?: RegExp[]; // array of regex to match for fatal errors
+  exitCommands?: string[]; // commands to exit the cli gracefully
+  promptArg?: (string & {}) | "first-arg" | "last-arg"; // argument name to pass the prompt, e.g. --prompt, or first-arg for positional arg
+
+  // handle special format
+  noEOL?: boolean; // if true, do not split lines by \n when handling inputs, e.g. for codex, which uses cursor-move csi code instead of \n to move lines
+
+  // auto responds
+  enter?: RegExp[]; // array of regex to match for sending Enter
+  typingRespond?: { [message: string]: RegExp[] }; // type specified message to a specified pattern
+
+  // crash/resuming-session behaviour
   restoreArgs?: string[]; // arguments to continue the session when crashed
-  defaultArgs?: string[]; // function to ensure certain args are present
-  noEOL?: boolean; // if true, do not split lines by \n, used for codex, which uses cursor-move csi code instead of \n to move lines
-  promptArg?: (string & {}) | 'first-arg' | 'last-arg'; // argument name to pass the prompt, e.g. --prompt, or first-arg for positional arg
-  bunx?: boolean; // if true, use bunx to run the binary
+  restartWithoutContinueArg?: RegExp[]; // array of regex to match for errors that require restart without continue args
 };
-export type CliYesConfig = {
+export type AgentYesConfig = {
+  configDir?: string; // directory to store agent-yes config files, e.g. session store
+  logsDir?: string; // directory to store agent-yes log files
   clis: { [key: string]: AgentCliConfig };
 };
 
-// load user config from cli-yes.config.ts if exists
-export const config = await rawConfig;
-
+// load user config from agent-yes.config.ts if exists
+export const config = await import("../agent-yes.config.ts").then((mod) => mod.default || mod);
 export const CLIS_CONFIG = config.clis as Record<
-  keyof Awaited<typeof config>['clis'],
+  keyof Awaited<typeof config>["clis"],
   AgentCliConfig
 >;
-export type SUPPORTED_CLIS = keyof typeof CLIS_CONFIG;
-export const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG) as SUPPORTED_CLIS[];
 
 /**
  * Main function to run agent-cli with automatic yes/no responses
@@ -68,20 +76,20 @@ export const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG) as SUPPORTED_CLIS[];
  *
  * @example
  * ```typescript
- * import cliYes from 'cli-yes';
- * await cliYes({
+ * import agentYes from 'agent-yes';
+ * await agentYes({
  *   prompt: 'help me solve all todos in my codebase',
  *
  *   // optional
  *   cliArgs: ['--verbose'], // additional args to pass to agent-cli
  *   exitOnIdle: 30000, // exit after 30 seconds of idle
  *   robust: true, // auto restart with --continue if claude crashes, default is true
- *   logFile: 'claude.log', // save logs to file
+ *   logFile: 'claude-output.log', // save logs to file
  *   disableLock: false, // disable running lock (default is false)
  * });
  * ```
  */
-export default async function cliYes({
+export default async function agentYes({
   cli,
   cliArgs = [],
   prompt,
@@ -92,8 +100,11 @@ export default async function cliYes({
   logFile,
   removeControlCharactersFromStdout = false, // = !process.stdout.isTTY,
   verbose = false,
-  queue = true,
+  queue = false,
   install = false,
+  resume = false,
+  useSkills = false,
+  useFifo = false,
 }: {
   cli: SUPPORTED_CLIS;
   cliArgs?: string[];
@@ -107,32 +118,33 @@ export default async function cliYes({
   verbose?: boolean;
   queue?: boolean;
   install?: boolean; // if true, install the cli tool if not installed, e.g. will run `npm install -g cursor-agent`
+  resume?: boolean; // if true, resume previous session in current cwd if any
+  useSkills?: boolean; // if true, prepend SKILL.md header to the prompt for non-Claude agents
+  useFifo?: boolean; // if true, enable FIFO input stream on Linux for additional stdin input
 }) {
   // those overrides seems only works in bun
   // await Promise.allSettled([
-  //   import(path.join(process.cwd(), "cli-yes.config")),
+  //   import(path.join(process.cwd(), "agent-yes.config")),
   // ])
   //   .then((e) => e.flatMap((e) => (e.status === "fulfilled" ? [e.value] : [])))
   //   .then(e=>e.at(0))
-  //   .then((e) => e.default as ReturnType<typeof defineCliYesConfig>)
+  //   .then((e) => e.default as ReturnType<typeof defineAgentYesConfig>)
   //   .then(async (override) => deepMixin(config, override || {}))
   //   .catch((error) => {
   //     if (process.env.VERBOSE)
-  //       console.warn("Fail to load cli-yes.config.ts", error);
+  //       console.warn("Fail to load agent-yes.config.ts", error);
   //   });
 
   if (!cli) throw new Error(`cli is required`);
   const conf =
     CLIS_CONFIG[cli] ||
-    DIE(
-      `Unsupported cli tool: ${cli}, current process.argv: ${process.argv.join(' ')}`,
-    );
+    DIE(`Unsupported cli tool: ${cli}, current process.argv: ${process.argv.join(" ")}`);
 
   // Acquire lock before starting agent (if in git repo or same cwd and lock is not disabled)
   const workingDir = cwd ?? process.cwd();
   if (queue) {
     if (queue && shouldUseLock(workingDir)) {
-      await acquireLock(workingDir, prompt ?? 'Interactive session');
+      await acquireLock(workingDir, prompt ?? "Interactive session");
     }
 
     // Register cleanup handlers for lock release
@@ -142,129 +154,227 @@ export default async function cliYes({
       }
     };
 
-    process.on('exit', () => {
+    process.on("exit", () => {
       if (queue) releaseLock().catch(() => null);
     });
-    process.on('SIGINT', async (code) => {
+    process.on("SIGINT", async (code) => {
       await cleanupLock();
       process.exit(code);
     });
-    process.on('SIGTERM', async (code) => {
+    process.on("SIGTERM", async (code) => {
       await cleanupLock();
       process.exit(code);
     });
   }
 
   process.stdin.setRawMode?.(true); // must be called any stdout/stdin usage
+
   let isFatal = false; // when true, do not restart on crash, and exit agent
+  let shouldRestartWithoutContinue = false; // when true, restart without continue args
+
   const stdinReady = new ReadyManager();
+  const stdinFirstReady = new ReadyManager(); // if user send ctrl+c before
+
+  // force ready after 10s to avoid stuck forever if the ready-word mismatched
+  sleep(10e3).then(() => {
+    if (!stdinReady.isReady) stdinReady.ready();
+    if (!stdinFirstReady.isReady) stdinFirstReady.ready();
+  });
   const nextStdout = new ReadyManager();
 
   const shellOutputStream = new TransformStream<string, string>();
   const outputWriter = shellOutputStream.writable.getWriter();
-  // const pty = await import('node-pty');
 
-  // its recommened to use bun-pty in windows
-  const pty = await (globalThis.Bun
-    ? import('bun-pty')
-    : import('node-pty')
-  ).catch(async () =>
-    DIE('Please install node-pty or bun-pty, run this: bun install bun-pty'),
-  );
+  logger.debug(`Using ${ptyPackage} for pseudo terminal management.`);
+
+  const datetime = new Date().toISOString().replace(/\D/g, "").slice(0, 17);
+  const logPath = config.logsDir && path.resolve(config.logsDir, `${cli}-yes-${datetime}.log`);
+  const rawLogPath =
+    config.logsDir && path.resolve(config.logsDir, `${cli}-yes-${datetime}.raw.log`);
+  const rawLinesLogPath =
+    config.logsDir && path.resolve(config.logsDir, `${cli}-yes-${datetime}.lines.log`);
+  const debuggingLogsPath =
+    config.logsDir && path.resolve(config.logsDir, `${cli}-yes-${datetime}.debug.log`);
+
+  // add
+  if (debuggingLogsPath)
+    logger.add(
+      new winston.transports.File({
+        filename: debuggingLogsPath,
+        level: "debug",
+      }),
+    );
 
   // Detect if running as sub-agent
   const isSubAgent = !!process.env.CLAUDE_PPID;
-  if (isSubAgent) {
-    console.log(
-      `[${cli}-yes] Running as sub-agent (CLAUDE_PPID=${process.env.CLAUDE_PPID})`,
-    );
-  }
+  if (isSubAgent)
+    logger.info(`[${cli}-yes] Running as sub-agent (CLAUDE_PPID=${process.env.CLAUDE_PPID})`);
 
-  const getPtyOptions = () => ({
-    name: 'xterm-color',
-    ...getTerminalDimensions(),
-    cwd: cwd ?? process.cwd(),
-    env: {
-      ...(env ?? (process.env as Record<string, string>)),
-      CLAUDE_PPID: String(process.ppid),
-    },
-  });
+  const getPtyOptions = () => {
+    const ptyEnv = { ...(env ?? (process.env as Record<string, string>)) };
+    return {
+      name: "xterm-color",
+      ...getTerminalDimensions(),
+      cwd: cwd ?? process.cwd(),
+      env: ptyEnv,
+    };
+  };
 
   // Apply CLI specific configurations (moved to CLI_CONFIGURES)
   const cliConf = (CLIS_CONFIG as Record<string, AgentCliConfig>)[cli] || {};
-  cliArgs = cliConf.defaultArgs
-    ? [...cliConf.defaultArgs, ...cliArgs]
-    : cliArgs;
+  cliArgs = cliConf.defaultArgs ? [...cliConf.defaultArgs, ...cliArgs] : cliArgs;
+
+  // If enabled, read SKILL.md header and prepend to the prompt for non-Claude agents
+  try {
+    const workingDir = cwd ?? process.cwd();
+    if (useSkills && cli !== "claude") {
+      // Find git root to determine search boundary
+      let gitRoot: string | null = null;
+      try {
+        const result = execaCommandSync("git rev-parse --show-toplevel", {
+          cwd: workingDir,
+          reject: false,
+        });
+        if (result.exitCode === 0) {
+          gitRoot = result.stdout.trim();
+        }
+      } catch {
+        // Not a git repo, will only check cwd
+      }
+
+      // Walk up from cwd to git root (or stop at filesystem root) collecting SKILL.md files
+      const skillHeaders: string[] = [];
+      let currentDir = workingDir;
+      const searchLimit = gitRoot || path.parse(currentDir).root;
+
+      while (true) {
+        const skillPath = path.resolve(currentDir, "SKILL.md");
+        const md = await readFile(skillPath, "utf8").catch(() => null);
+        if (md) {
+          // Extract header (content before first level-2 heading `## `)
+          const headerMatch = md.match(/^[\s\S]*?(?=\n##\s)/);
+          const headerRaw = (headerMatch ? headerMatch[0] : md).trim();
+          if (headerRaw) {
+            skillHeaders.push(headerRaw);
+            if (verbose)
+              logger.info(`[skills] Found SKILL.md in ${currentDir} (${headerRaw.length} chars)`);
+          }
+        }
+
+        // Stop if we've reached git root or filesystem root
+        if (currentDir === searchLimit) break;
+
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) break; // Reached filesystem root
+        currentDir = parentDir;
+      }
+
+      if (skillHeaders.length > 0) {
+        // Combine all headers (most specific first)
+        const combined = skillHeaders.join("\n\n---\n\n");
+        const MAX = 2000; // increased limit for multiple skills
+        const header = combined.length > MAX ? combined.slice(0, MAX) + "…" : combined;
+        const prefix = `Use this repository skill as context:\n\n${header}`;
+        prompt = prompt ? `${prefix}\n\n${prompt}` : prefix;
+        if (verbose)
+          logger.info(
+            `[skills] Injected ${skillHeaders.length} SKILL.md header(s) (${header.length} chars total)`,
+          );
+      } else {
+        if (verbose) logger.info("[skills] No SKILL.md found in directory hierarchy");
+      }
+    }
+  } catch (error) {
+    // Non-fatal; continue without skills
+    if (verbose) logger.warn("[skills] Failed to inject SKILL.md header:", { error });
+  }
 
   // Handle --continue flag for codex session restoration
-  const continueIndex = cliArgs.indexOf('--continue');
-  if (continueIndex !== -1 && cli === 'codex') {
-    // Remove the --continue flag from args
-    cliArgs.splice(continueIndex, 1);
-
-    // Try to get stored session for this directory
-    const storedSessionId = await getSessionForCwd(workingDir);
-    if (storedSessionId) {
-      // Replace or add resume args
-      cliArgs = ['resume', storedSessionId, ...cliArgs];
-      await yesLog`continue|using stored session ID: ${storedSessionId}`;
+  if (resume) {
+    if (cli === "codex" && resume) {
+      // Try to get stored session for this directory
+      const storedSessionId = await getSessionForCwd(workingDir);
+      if (storedSessionId) {
+        // Replace or add resume args
+        cliArgs = ["resume", storedSessionId, ...cliArgs];
+        await logger.debug(`resume|using stored session ID: ${storedSessionId}`);
+      } else {
+        throw new Error(
+          `No stored session found for codex in directory: ${workingDir}, please try without resume option.`,
+        );
+      }
+    } else if (cli === "claude") {
+      // just add --continue flag for claude
+      cliArgs = ["--continue", ...cliArgs];
+      await logger.debug(`resume|adding --continue flag for claude`);
+    } else if (cli === "gemini") {
+      // Gemini supports session resume natively via --resume flag
+      // Sessions are project/directory-specific by default (stored in ~/.gemini/tmp/<project_hash>/chats/)
+      cliArgs = ["--resume", ...cliArgs];
+      await logger.debug(`resume|adding --resume flag for gemini`);
     } else {
-      // Fallback to --last if no stored session
-      cliArgs = ['resume', '--last', ...cliArgs];
-      await yesLog`continue|no stored session, using --last`;
+      throw new Error(
+        `Resume option is not supported for cli: ${cli}, make a feature request if you want it. https://github.com/snomiao/agent-yes/issues`,
+      );
     }
   }
 
+  // If possible pass prompt via cli args, its usually faster than stdin
   if (prompt && cliConf.promptArg) {
-    if (cliConf.promptArg === 'first-arg') {
+    if (cliConf.promptArg === "first-arg") {
       cliArgs = [prompt, ...cliArgs];
       prompt = undefined; // clear prompt to avoid sending later
-    } else if (cliConf.promptArg === 'last-arg') {
+    } else if (cliConf.promptArg === "last-arg") {
       cliArgs = [...cliArgs, prompt];
       prompt = undefined; // clear prompt to avoid sending later
-    } else if (cliConf.promptArg.startsWith('--')) {
+    } else if (cliConf.promptArg.startsWith("--")) {
       cliArgs = [cliConf.promptArg, prompt, ...cliArgs];
       prompt = undefined; // clear prompt to avoid sending later
     } else {
-      console.warn(`Unknown promptArg format: ${cliConf.promptArg}`);
+      logger.warn(`Unknown promptArg format: ${cliConf.promptArg}`);
     }
   }
-  const cliCommand = cliConf?.binary || cli;
+  // Determine the actual cli command to run
 
   const spawn = () => {
-    // const [bin, ...args] = [...parseCommandString((cliConf.bunx ? 'bunx --bun ' : '') + cliCommand), ...(cliArgs)];
-    // console.log(`Spawning ${bin} with args: ${JSON.stringify(args)}`);
-    // return pty.spawn(bin!, args, getPtyOptions());
-    return pty.spawn(cliCommand, cliArgs, getPtyOptions());
+    const cliCommand = cliConf?.binary || cli;
+    let [bin, ...args] = [...parseCommandString(cliCommand), ...cliArgs];
+    if (verbose) logger.info(`Spawning ${bin} with args: ${JSON.stringify(args)}`);
+    logger.info(`Spawning ${bin} with args: ${JSON.stringify(args)}`);
+    // throw new Error(JSON.stringify([bin!, args, getPtyOptions()]))
+    const spawned = pty.spawn(bin!, args, getPtyOptions());
+    logger.info(`[${cli}-yes] Spawned ${bin} with PID ${spawned.pid}`);
+    // if (globalThis.Bun)
+    //   args = args.map((arg) => `'${arg.replace(/'/g, "\\'")}'`);
+    return spawned;
   };
+
   let shell = catcher(
     // error handler
-    (error: unknown, fn, ...args) => {
-      console.error(`Fatal: Failed to start ${cliCommand}.`);
+    (error: unknown, _fn, ..._args) => {
+      logger.error(`Fatal: Failed to start ${cli}.`);
+
+      const isNotFound = isCommandNotFoundError(error);
+      if (cliConf?.install && isNotFound) {
+        logger.info(`Please install the cli by run ${cliConf.install}`);
 
-      if (cliConf?.install && isCommandNotFoundError(error))
         if (install) {
-          console.log(`Attempting to install ${cli}...`);
-          execaCommandSync(cliConf.install, { stdio: 'inherit' });
-          console.log(
-            `${cli} installed successfully. Please rerun the command.`,
-          );
+          logger.info(`Attempting to install ${cli}...`);
+          execaCommandSync(cliConf.install, { stdio: "inherit" });
+          logger.info(`${cli} installed successfully. Please rerun the command.`);
           return spawn();
+        } else {
+          logger.error(
+            `If you did not installed it yet, Please install it first: ${cliConf.install}`,
+          );
+          throw error;
         }
-      console.error(
-        `If you did not installed it yet, Please install it first: ${cliConf.install}`,
-      );
+      }
 
-      if (
-        globalThis.Bun &&
-        error instanceof Error &&
-        error.stack?.includes('bun-pty')
-      ) {
+      if (globalThis.Bun && error instanceof Error && error.stack?.includes("bun-pty")) {
         // try to fix bun-pty issues
-        console.error(
-          `Detected bun-pty issue, attempted to fix it. Please try again.`,
-        );
-        require('./fix-pty.js');
+        logger.error(`Detected bun-pty issue, attempted to fix it. Please try again.`);
+        require("./pty-fix");
         // unable to retry with same process, so exit here.
       }
       throw error;
@@ -272,9 +382,9 @@ export default async function cliYes({
       function isCommandNotFoundError(e: unknown) {
         if (e instanceof Error) {
           return (
-            e.message.includes('command not found') || // unix
-            e.message.includes('ENOENT') || // unix
-            e.message.includes('spawn') // windows
+            e.message.includes("command not found") || // unix
+            e.message.includes("ENOENT") || // unix
+            e.message.includes("spawn") // windows
           );
         }
         return false;
@@ -283,7 +393,6 @@ export default async function cliYes({
     spawn,
   )();
   const pendingExitCode = Promise.withResolvers<number | null>();
-  let pendingExitCodeValue = null;
 
   async function onData(data: string) {
     // append data to the buffer, so we can process it later
@@ -295,31 +404,50 @@ export default async function cliYes({
     stdinReady.unready(); // start buffer stdin
     const agentCrashed = exitCode !== 0;
 
+    // Handle restart without continue args (e.g., "No conversation found to continue")
+    // logger.debug(``, { shouldRestartWithoutContinue, robust })
+    if (shouldRestartWithoutContinue) {
+      shouldRestartWithoutContinue = false; // reset flag
+      isFatal = false; // reset fatal flag to allow restart
+
+      // Restart without continue args - use original cliArgs without restoreArgs
+      const cliCommand = cliConf?.binary || cli;
+      let [bin, ...args] = [
+        ...parseCommandString(cliCommand),
+        ...cliArgs.filter((arg) => !["--continue", "--resume"].includes(arg)),
+      ];
+      logger.info(`Restarting ${cli} ${JSON.stringify([bin, ...args])}`);
+
+      shell = pty.spawn(bin!, args, getPtyOptions());
+      shell.onData(onData);
+      shell.onExit(onExit);
+      return;
+    }
+
     if (agentCrashed && robust && conf?.restoreArgs) {
       if (!conf.restoreArgs) {
-        return console.warn(
+        logger.warn(
           `robust is only supported for ${Object.entries(CLIS_CONFIG)
             .filter(([_, v]) => v.restoreArgs)
             .map(([k]) => k)
-            .join(', ')} currently, not ${cli}`,
+            .join(", ")} currently, not ${cli}`,
         );
+        return;
       }
-      if (isFatal) {
-        return pendingExitCode.resolve((pendingExitCodeValue = exitCode));
-      }
+      if (isFatal) return pendingExitCode.resolve(exitCode);
 
-      console.log(`${cli} crashed, restarting...`);
+      logger.info(`${cli} crashed, restarting...`);
 
       // For codex, try to use stored session ID for this directory
       let restoreArgs = conf.restoreArgs;
-      if (cli === 'codex') {
+      if (cli === "codex") {
         const storedSessionId = await getSessionForCwd(workingDir);
         if (storedSessionId) {
           // Use specific session ID instead of --last
-          restoreArgs = ['resume', storedSessionId];
-          await yesLog`restore|using stored session ID: ${storedSessionId}`;
+          restoreArgs = ["resume", storedSessionId];
+          logger.debug(`restore|using stored session ID: ${storedSessionId}`);
         } else {
-          await yesLog`restore|no stored session, using default restore args`;
+          logger.debug(`restore|no stored session, using default restore args`);
         }
       }
 
@@ -328,11 +456,11 @@ export default async function cliYes({
       shell.onExit(onExit);
       return;
     }
-    return pendingExitCode.resolve((pendingExitCodeValue = exitCode));
+    return pendingExitCode.resolve(exitCode);
   });
 
-  // when current tty resized, resize the pty
-  process.stdout.on('resize', () => {
+  // when current tty resized, resize the pty too
+  process.stdout.on("resize", () => {
     const { cols, rows } = getTerminalDimensions(); // minimum 80 columns to avoid layout issues
     shell.resize(cols, rows); // minimum 80 columns to avoid layout issues
   });
@@ -341,133 +469,240 @@ export default async function cliYes({
   const isStillWorkingQ = () =>
     terminalRender
       .render()
-      .replace(/\s+/g, ' ')
+      .replace(/\s+/g, " ")
       .match(/esc to interrupt|to run in background/);
 
   const idleWaiter = new IdleWaiter();
   if (exitOnIdle)
     idleWaiter.wait(exitOnIdle).then(async () => {
       if (isStillWorkingQ()) {
-        console.log(
-          '[${cli}-yes] ${cli} is idle, but seems still working, not exiting yet',
-        );
+        logger.warn("[${cli}-yes] ${cli} is idle, but seems still working, not exiting yet");
         return;
       }
 
-      console.log('[${cli}-yes] ${cli} is idle, exiting...');
+      logger.info("[${cli}-yes] ${cli} is idle, exiting...");
       await exitAgent();
     });
 
-  // console.log(
-  //   `[${cli}-yes] Started ${cli} with args: ${[cliCommand, ...cliArgs].join(" ")}`
-  // );
   // Message streaming
 
-  sflow(fromReadable<Buffer>(process.stdin))
+  // Message streaming with stdin and optional FIFO (Linux only)
+
+  await sflow(fromReadable<Buffer>(process.stdin))
     .map((buffer) => buffer.toString())
-    // .map((e) => e.replaceAll('\x1a', '')) // remove ctrl+z from user's input (seems bug)
+
+    .by(function handleTerminateSignals(s) {
+      let aborted = false;
+      return s.map((chunk) => {
+        // handle CTRL+Z and filter it out, as I dont know how to support it yet
+        if (!aborted && chunk === "\u001A") {
+          return "";
+        }
+        // handle CTRL+C, when stdin is not ready (no response from agent yet, usually this is when agent loading)
+        if (!aborted && !stdinReady.isReady && chunk === "\u0003") {
+          logger.error("User aborted: SIGINT");
+          shell.kill("SIGINT");
+          pendingExitCode.resolve(130); // SIGINT
+          aborted = true;
+          return chunk; // still pass into agent, but they prob be killed XD
+        }
+        return chunk; // normal inputs
+      });
+    })
+
+    // read from FIFO if available, e.g. /tmp/agent-yes-*.stdin, which can be used to send additional input from other processes
+    .by((s) => {
+      if (!useFifo) return s;
+      const fifoResult = createFifoStream(cli);
+      if (!fifoResult) return s;
+      pendingExitCode.promise.finally(() => fifoResult.cleanup());
+      return s.merge(fifoResult.stream);
+    })
+
+    // .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
-    // pipe
+
+    .onStart(async function promptOnStart() {
+      // send prompt when start
+      logger.debug("Sending prompt message: " + JSON.stringify(prompt));
+      if (prompt) await sendMessage(prompt);
+    })
+
+    // pipe content by shell
     .by({
       writable: new WritableStream<string>({
         write: async (data) => {
           await stdinReady.wait();
-          // await idleWaiter.wait(20); // wait for idle for 200ms to avoid messing up claude's input
           shell.write(data);
         },
       }),
       readable: shellOutputStream.readable,
     })
+
     .forEach(() => idleWaiter.ping())
     .forEach(() => nextStdout.ready())
-    .forEach(async (text) => {
-      terminalRender.write(text);
-      // todo: .onStatus((msg)=> shell.write(msg))
-      if (process.stdin.isTTY) return; // only handle it when stdin is not tty
-      if (!text.includes('\u001b[6n')) return; // only asked for cursor position
-      // todo: use terminalRender API to get cursor position when new version is available
-      // xterm replies CSI row; column R if asked cursor position
-      // https://en.wikipedia.org/wiki/ANSI_escape_code#:~:text=citation%20needed%5D-,xterm%20replies,-CSI%20row%C2%A0%3B
-      // when agent asking position, respond with row; col
-      // const rendered = terminalRender.render();
-      const { col, row } = terminalRender.getCursorPosition();
-      shell.write(`\u001b[${row};${col}R`); // reply cli when getting cursor position
-      await yesLog`cursor|respond position: row=${String(row)}, col=${String(col)}`;
-      // const row = rendered.split('\n').length + 1;
-      // const col = (rendered.split('\n').slice(-1)[0]?.length || 0) + 1;
-    })
 
-    // auto-response
-    .forkTo((e) =>
-      e
-        .map((e) => removeControlCharacters(e))
-        .map((e) => e.replaceAll('\r', '')) // remove carriage return
-        .by((s) => {
-          if (conf.noEOL) return s; // codex use cursor-move csi code insteadof \n to move lines, so the output have no \n at all, this hack prevents stuck on unended line
-          return s.lines({ EOL: 'NONE' }); // other clis use ink, which is rerendering the block based on \n lines
+    .forkTo(async function rawLogger(f) {
+      if (!rawLogPath) return f.run(); // no stream
+
+      // try stream the raw log for realtime debugging, including control chars, note: it will be a huge file
+      return await mkdir(path.dirname(rawLogPath), { recursive: true })
+        .then(() => {
+          logger.debug(`[${cli}-yes] raw logs streaming to ${rawLogPath}`);
+          return f
+            .forEach(async (chars) => {
+              await writeFile(rawLogPath, chars, { flag: "a" }).catch(() => null);
+            })
+            .run();
         })
-        .forEach((e) => yesLog`output|${e}`) // for debugging
-        // Generic auto-response handler driven by CLI_CONFIGURES
-        .forEach(async (e, i) => {
-          // ready matcher: if matched, mark stdin ready
-          if (conf.ready?.some((rx: RegExp) => e.match(rx))) {
-            await yesLog`ready |${e}`;
-            if (cli === 'gemini' && i <= 80) return; // gemini initial noise, only after many lines
-            stdinReady.ready();
-          }
+        .catch(() => f.run());
+    })
 
-          // enter matchers: send Enter when any enter regex matches
-          if (conf.enter?.some((rx: RegExp) => e.match(rx))) {
-            await yesLog`enter |${e}`;
-            await sendEnter(300); // send Enter after 300ms idle wait
-            return;
+    // handle cursor position requests and render terminal output
+    .by(function consoleResponder(e) {
+      // wait for cli ready and send prompt if provided
+      if (cli === "codex") shell.write(`\u001b[1;1R`); // send cursor position response when stdin is not tty
+      return e.forEach((text) => {
+        // render terminal output for log file
+        terminalRender.write(text);
+
+        // Handle Device Attributes query (DA) - ESC[c or ESC[0c
+        // This must be handled regardless of TTY status
+        if (text.includes("\u001b[c") || text.includes("\u001b[0c")) {
+          // Respond shell with VT100 with Advanced Video Option
+          shell.write("\u001b[?1;2c");
+          if (verbose) {
+            logger.debug("device|respond DA: VT100 with Advanced Video Option");
           }
+          return;
+        }
 
-          // fatal matchers: set isFatal flag when matched
-          if (conf.fatal?.some((rx: RegExp) => e.match(rx))) {
-            await yesLog`fatal |${e}`;
-            isFatal = true;
-            await exitAgent();
-          }
+        // todo: .onStatus((msg)=> shell.write(msg))
+        if (process.stdin.isTTY) return; // only handle it when stdin is not tty, because tty already handled this
+
+        if (!text.includes("\u001b[6n")) return; // only asked for cursor position
+        // todo: use terminalRender API to get cursor position when new version is available
+        // xterm replies CSI row; column R if asked cursor position
+        // https://en.wikipedia.org/wiki/ANSI_escape_code#:~:text=citation%20needed%5D-,xterm%20replies,-CSI%20row%C2%A0%3B
+        // when agent asking position, respond with row; col
+        // const rendered = terminalRender.render();
+        const { col, row } = terminalRender.getCursorPosition();
+        shell.write(`\u001b[${row};${col}R`); // reply cli when getting cursor position
+        logger.debug(`cursor|respond position: row=${String(row)}, col=${String(col)}`);
+        // const row = rendered.split('\n').length + 1;
+        // const col = (rendered.split('\n').slice(-1)[0]?.length || 0) + 1;
+      });
+    })
 
-          // session ID capture for codex
-          if (cli === 'codex') {
-            const sessionId = extractSessionId(e);
-            if (sessionId) {
-              await yesLog`session|captured session ID: ${sessionId}`;
-              await storeSessionForCwd(workingDir, sessionId);
+    // auto-response
+    .forkTo(function autoResponse(e) {
+      return (
+        e
+          .map((e) => removeControlCharacters(e))
+          // .map((e) => e.replaceAll("\r", "")) // remove carriage return
+          .by((s) => {
+            if (conf.noEOL) return s; // codex use cursor-move csi code insteadof \n to move lines, so the output have no \n at all, this hack prevents stuck on unended line
+            return s.lines({ EOL: "NONE" }); // other clis use ink, which is rerendering the block based on \n lines
+          })
+
+          // .forkTo(async function rawLinesLogger(f) {
+          //   if (!rawLinesLogPath) return f.run(); // no stream
+          //   // try stream the raw log for realtime debugging, including control chars, note: it will be a huge file
+          //   return await mkdir(path.dirname(rawLinesLogPath), { recursive: true })
+          //     .then(() => {
+          //       logger.debug(`[${cli}-yes] raw lines logs streaming to ${rawLinesLogPath}`);
+          //       return f
+          //         .forEach(async (chars, i) => {
+          //           await writeFile(rawLinesLogPath, `L${i}|` + chars, { flag: "a" }).catch(() => null);
+          //         })
+          //         .run();
+          //     })
+          //     .catch(() => f.run());
+          // })
+
+          // Generic auto-response handler driven by CLI_CONFIGURES
+          .forEach(async function autoResponseOnChunk(e, i) {
+            logger.debug(`stdout|${e}`);
+            // ready matcher: if matched, mark stdin ready
+            if (conf.ready?.some((rx: RegExp) => e.match(rx))) {
+              logger.debug(`ready |${e}`);
+              if (cli === "gemini" && i <= 80) return; // gemini initial noise, only after many lines
+              stdinReady.ready();
+              stdinFirstReady.ready();
             }
-          }
-        })
-        .run(),
-    )
-    .map((e) =>
-      removeControlCharactersFromStdout ? removeControlCharacters(e) : e,
+            // enter matchers: send Enter when any enter regex matches
+
+            if (conf.enter?.some((rx: RegExp) => e.match(rx))) {
+              logger.debug(`enter |${e}`);
+              return await sendEnter(400); // wait for idle for a short while and then send Enter
+            }
+
+            // typingRespond matcher: if matched, send the specified message
+            const typingResponded = await sflow(Object.entries(conf.typingRespond ?? {}))
+              .filter(([_sendString, onThePatterns]) => onThePatterns.some((rx) => e.match(rx)))
+              .map(async ([sendString]) => await sendMessage(sendString, { waitForReady: false }))
+              .toCount();
+            if (typingResponded) return;
+
+            // fatal matchers: set isFatal flag when matched
+            if (conf.fatal?.some((rx: RegExp) => e.match(rx))) {
+              logger.debug(`fatal |${e}`);
+              isFatal = true;
+              await exitAgent();
+            }
+
+            // restartWithoutContinueArg matchers: set flag to restart without continue args
+            if (conf.restartWithoutContinueArg?.some((rx: RegExp) => e.match(rx))) {
+              await logger.debug(`restart-without-continue|${e}`);
+              shouldRestartWithoutContinue = true;
+              isFatal = true; // also set fatal to trigger exit
+              await exitAgent();
+            }
+
+            // session ID capture for codex
+            if (cli === "codex") {
+              const sessionId = extractSessionId(e);
+              if (sessionId) {
+                await logger.debug(`session|captured session ID: ${sessionId}`);
+                await storeSessionForCwd(workingDir, sessionId);
+              }
+            }
+          })
+          .run()
+      );
+    })
+    .by((s) => (removeControlCharactersFromStdout ? s.map((e) => removeControlCharacters(e)) : s))
+
+    // terminate whole stream when shell did exited (already crash-handled)
+    .by(
+      new TransformStream({
+        start: function terminator(ctrl) {
+          pendingExitCode.promise.then(() => ctrl.terminate());
+        },
+        transform: (e, ctrl) => ctrl.enqueue(e),
+        flush: (ctrl) => ctrl.terminate(),
+      }),
     )
-    .to(fromWritable(process.stdout))
-    .then(() => null); // run it immediately without await
-
-  // wait for cli ready and send prompt if provided
-  if (cli === 'codex') shell.write(`\u001b[1;1R`); // send cursor position response when stdin is not tty
-  if (prompt) await sendMessage(prompt);
-
-  const exitCode = await pendingExitCode.promise; // wait for the shell to exit
-  console.log(`[${cli}-yes] ${cli} exited with code ${exitCode}`);
-
-  // Update task status and release lock
-  if (queue && shouldUseLock(workingDir)) {
-    await updateCurrentTaskStatus(
-      exitCode === 0 ? 'completed' : 'failed',
-    ).catch(() => null);
-    await releaseLock().catch(() => null);
+    .to(fromWritable(process.stdout));
+
+  if (logPath) {
+    await mkdir(path.dirname(logPath), { recursive: true }).catch(() => null);
+    await writeFile(logPath, terminalRender.render()).catch(() => null);
+    logger.info(`[${cli}-yes] Full logs saved to ${logPath}`);
   }
 
+  // and then get its exitcode
+  const exitCode = await pendingExitCode.promise;
+  logger.info(`[${cli}-yes] ${cli} exited with code ${exitCode}`);
+
+  // Update task status.writable release lock
+  await outputWriter.close();
+
+  // deprecated logFile option, we have logPath now, but keep for backward compatibility
   if (logFile) {
-    verbose && console.log(`[${cli}-yes] Writing rendered logs to ${logFile}`);
+    if (verbose) logger.info(`[${cli}-yes] Writing rendered logs to ${logFile}`);
     const logFilePath = path.resolve(logFile);
-    await mkdir(path.dirname(logFilePath), { recursive: true }).catch(
-      () => null,
-    );
+    await mkdir(path.dirname(logFilePath), { recursive: true }).catch(() => null);
     await writeFile(logFilePath, terminalRender.render());
   }
 
@@ -476,19 +711,21 @@ export default async function cliYes({
   async function sendEnter(waitms = 1000) {
     // wait for idle for a bit to let agent cli finish rendering
     const st = Date.now();
-    await idleWaiter.wait(waitms);
+    await idleWaiter.wait(waitms); // wait for idle a while
     const et = Date.now();
     // process.stdout.write(`\ridleWaiter.wait(${waitms}) took ${et - st}ms\r`);
-    await yesLog`sendEn| idleWaiter.wait(${String(waitms)}) took ${String(et - st)}ms`;
+    logger.debug(`sendEn| idleWaiter.wait(${String(waitms)}) took ${String(et - st)}ms`);
     nextStdout.unready();
-    shell.write('\r');
+    // send the enter key
+    shell.write("\r");
+
     // retry once if not received any output in 1 second after sending Enter
     await Promise.race([
       nextStdout.wait(),
       new Promise<void>((resolve) =>
         setTimeout(() => {
           if (!nextStdout.ready) {
-            shell.write('\r');
+            shell.write("\r");
           }
           resolve();
         }, 1000),
@@ -496,25 +733,25 @@ export default async function cliYes({
     ]);
   }
 
-  async function sendMessage(message: string) {
-    await stdinReady.wait();
+  async function sendMessage(message: string, { waitForReady = true } = {}) {
+    if (waitForReady) await stdinReady.wait();
     // show in-place message: write msg and move cursor back start
-    yesLog`send  |${message}`;
+    logger.debug(`send  |${message}`);
     nextStdout.unready();
     shell.write(message);
     idleWaiter.ping(); // just sent a message, wait for echo
-    yesLog`waiting next stdout|${message}`;
+    logger.debug(`waiting next stdout|${message}`);
     await nextStdout.wait();
-    yesLog`sending enter`;
+    logger.debug(`sending enter`);
     await sendEnter(1000);
-    yesLog`sent enter`;
+    logger.debug(`sent enter`);
   }
 
   async function exitAgent() {
     robust = false; // disable robust to avoid auto restart
 
     // send exit command to the shell, must sleep a bit to avoid claude treat it as pasted input
-    await sendMessage('/exit');
+    for (const cmd of cliConf.exitCommands ?? ["/exit"]) await sendMessage(cmd);
 
     // wait for shell to exit or kill it with a timeout
     let exited = false;
@@ -542,3 +779,7 @@ export default async function cliYes({
     };
   }
 }
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}