claude-yes 1.36.4 → 1.37.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-yes",
-  "version": "1.36.4",
+  "version": "1.37.1",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",
@@ -66,6 +66,8 @@
     "postbuild": "bun ./ts/postbuild.ts",
     "demo": "bun run build && bun link && claude-yes -- demo",
     "dev": "bun ts/index.ts",
+    "dev:tsgo": "tsgo ts/cli.ts",
+    "test:tsgo": "tsgo --test",
     "fmt": "oxlint --fix --fix-suggestions && oxfmt",
     "_prepack": "bun run build",
     "prepare": "husky",
@@ -91,6 +93,7 @@
     "@types/ms": "^2.1.0",
     "@types/node": "^25.0.10",
     "@types/yargs": "^17.0.35",
+    "@typescript/native-preview": "^7.0.0-dev.20260124.1",
     "cpu-wait": "^0.0.10",
     "execa": "^9.6.1",
     "husky": "^9.1.7",
@@ -125,25 +128,5 @@
   },
   "engines": {
     "node": ">=22.0.0"
-  },
-  "_release": {
-    "branches": [
-      "main"
-    ],
-    "plugins": [
-      "@semantic-release/commit-analyzer",
-      "@semantic-release/release-notes-generator",
-      "@semantic-release/changelog",
-      "@semantic-release/npm",
-      [
-        "@semantic-release/exec",
-        {
-          "publishCmd": "npm pkg set name=claude-yes"
-        }
-      ],
-      "@semantic-release/npm",
-      "@semantic-release/git",
-      "@semantic-release/github"
-    ]
   }
 }

package/ts/index.ts

@@ -21,6 +21,22 @@ import { createFifoStream } from "./beta/fifo.ts";
 import { PidStore } from "./pidStore.ts";
 import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
 import winston from "winston";
+import { sendEnter, sendMessage, type MessageContext } from "./core/messaging.ts";
+import {
+  initializeLogPaths,
+  setupDebugLogging,
+  saveLogFile,
+  saveDeprecatedLogFile,
+  type LogPaths,
+} from "./core/logging.ts";
+import { spawnAgent, getTerminalDimensions } from "./core/spawner.ts";
+import { AgentContext } from "./core/context.ts";
+import { createAutoResponseHandler } from "./core/responders.ts";
+import {
+  handleConsoleControlCodes,
+  createTerminateSignalHandler,
+  createTerminatorStream,
+} from "./core/streamHelpers.ts";
 
 export { removeControlCharacters };
 
@@ -175,44 +191,16 @@ export default async function agentYes({
 
   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();
 
   logger.debug(`Using ${ptyPackage} for pseudo terminal management.`);
 
-  let logPath: string | false = false;
-  let rawLogPath: string | false = false;
-  let rawLinesLogPath: string | false = false;
-  let debuggingLogsPath: string | false = false;
-
   // Detect if running as sub-agent
   const isSubAgent = !!process.env.CLAUDE_PPID;
   if (isSubAgent)
     logger.info(`[${cli}-yes] Running as sub-agent (CLAUDE_PPID=${process.env.CLAUDE_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;
@@ -327,118 +315,46 @@ export default async function agentYes({
       logger.warn(`Unknown promptArg format: ${cliConf.promptArg}`);
     }
   }
-  // Determine the actual cli command to run
-
-  // Helper function to get install command based on platform/availability
-  const getInstallCommand = (
-    installConfig:
-      | string
-      | { powershell?: string; bash?: string; npm?: string; unix?: string; windows?: string },
-  ): string | null => {
-    if (typeof installConfig === "string") {
-      return installConfig;
-    }
 
-    const isWindows = process.platform === "win32";
-    const platform = isWindows ? "windows" : "unix";
-
-    // Try platform-specific commands first
-    if (installConfig[platform]) {
-      return installConfig[platform];
-    }
-
-    // Try shell-specific commands
-    if (isWindows && installConfig.powershell) {
-      return installConfig.powershell;
-    }
-
-    if (!isWindows && installConfig.bash) {
-      return installConfig.bash;
-    }
-
-    // Fallback to npm if available
-    if (installConfig.npm) {
-      return installConfig.npm;
-    }
-
-    return null;
-  };
-
-  const spawn = () => {
-    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;
+  // Spawn the agent CLI process
+  const ptyEnv = { ...(env ?? (process.env as Record<string, string>)) };
+  const ptyOptions = {
+    name: "xterm-color",
+    ...getTerminalDimensions(),
+    cwd: cwd ?? process.cwd(),
+    env: ptyEnv,
   };
 
-  let shell = catcher(
-    // error handler
-    (error: unknown, _fn, ..._args) => {
-      logger.error(`Fatal: Failed to start ${cli}.`);
-
-      const isNotFound = isCommandNotFoundError(error);
-      if (cliConf?.install && isNotFound) {
-        const installCmd = getInstallCommand(cliConf.install);
-        if (!installCmd) {
-          logger.error(`No suitable install command found for ${cli} on this platform`);
-          throw error;
-        }
-
-        logger.info(`Please install the cli by run ${installCmd}`);
-
-        if (install) {
-          logger.info(`Attempting to install ${cli}...`);
-          execaCommandSync(installCmd, { 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: ${installCmd}`);
-          throw error;
-        }
-      }
-
-      if (globalThis.Bun && error instanceof Error && error.stack?.includes("bun-pty")) {
-        // try to fix bun-pty issues
-        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;
-
-      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
-          );
-        }
-        return false;
-      }
-    },
-    spawn,
-  )();
+  let shell = spawnAgent({
+    cli,
+    cliConf,
+    cliArgs,
+    verbose,
+    install,
+    ptyOptions,
+  });
 
   // Register process in pidStore and compute log paths
   await pidStore.registerProcess({ pid: shell.pid, cli, args: cliArgs, prompt });
-  logPath = pidStore.getLogPath(shell.pid);
-  rawLogPath = path.resolve(path.dirname(logPath), `${shell.pid}.raw.log`);
-  rawLinesLogPath = path.resolve(path.dirname(logPath), `${shell.pid}.lines.log`);
-  debuggingLogsPath = path.resolve(path.dirname(logPath), `${shell.pid}.debug.log`);
-
-  if (debuggingLogsPath)
-    logger.add(
-      new winston.transports.File({
-        filename: debuggingLogsPath,
-        level: "debug",
-      }),
-    );
+  const logPaths = initializeLogPaths(pidStore, shell.pid);
+  setupDebugLogging(logPaths.debuggingLogsPath);
+
+  // Create agent context
+  const ctx = new AgentContext({
+    shell,
+    pidStore,
+    logPaths,
+    cli,
+    cliConf,
+    verbose,
+    robust,
+  });
+
+  // force ready after 10s to avoid stuck forever if the ready-word mismatched
+  sleep(10e3).then(() => {
+    if (!ctx.stdinReady.isReady) ctx.stdinReady.ready();
+    if (!ctx.stdinFirstReady.isReady) ctx.stdinFirstReady.ready();
+  });
 
   const pendingExitCode = Promise.withResolvers<number | null>();
 
@@ -449,18 +365,18 @@ export default async function agentYes({
 
   shell.onData(onData);
   shell.onExit(async function onExit({ exitCode }) {
-    stdinReady.unready(); // start buffer stdin
+    ctx.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) {
+    if (ctx.shouldRestartWithoutContinue) {
       await pidStore.updateStatus(shell.pid, "exited", {
         exitReason: "restarted",
         exitCode: exitCode ?? undefined,
       });
-      shouldRestartWithoutContinue = false; // reset flag
-      isFatal = false; // reset fatal flag to allow restart
+      ctx.shouldRestartWithoutContinue = false; // reset flag
+      ctx.isFatal = false; // reset fatal flag to allow restart
 
       // Restart without continue args - use original cliArgs without restoreArgs
       const cliCommand = cliConf?.binary || cli;
@@ -487,7 +403,7 @@ export default async function agentYes({
         );
         return;
       }
-      if (isFatal) {
+      if (ctx.isFatal) {
         await pidStore.updateStatus(shell.pid, "exited", {
           exitReason: "fatal",
           exitCode: exitCode ?? undefined,
@@ -541,9 +457,8 @@ export default async function agentYes({
       .replace(/\s+/g, " ")
       .match(/esc to interrupt|to run in background/);
 
-  const idleWaiter = new IdleWaiter();
   if (exitOnIdle)
-    idleWaiter.wait(exitOnIdle).then(async () => {
+    ctx.idleWaiter.wait(exitOnIdle).then(async () => {
       await pidStore.updateStatus(shell.pid, "idle").catch(() => null);
       if (isStillWorkingQ()) {
         logger.warn("[${cli}-yes] ${cli} is idle, but seems still working, not exiting yet");
@@ -562,22 +477,11 @@ export default async function agentYes({
     .map((buffer) => buffer.toString())
 
     .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
+      const handler = createTerminateSignalHandler(ctx.stdinReady, (exitCode) => {
+        shell.kill("SIGINT");
+        pendingExitCode.resolve(exitCode);
       });
+      return s.map(handler);
     })
 
     // read from IPC stream if available (FIFO on Linux, Named Pipes on Windows)
@@ -596,14 +500,14 @@ export default async function agentYes({
     .onStart(async function promptOnStart() {
       // send prompt when start
       logger.debug("Sending prompt message: " + JSON.stringify(prompt));
-      if (prompt) await sendMessage(prompt);
+      if (prompt) await sendMessage(ctx.messageContext, prompt);
     })
 
     // pipe content by shell
     .by({
       writable: new WritableStream<string>({
         write: async (data) => {
-          await stdinReady.wait();
+          await ctx.stdinReady.wait();
           shell.write(data);
         },
       }),
@@ -611,21 +515,21 @@ export default async function agentYes({
     })
 
     .forEach(() => {
-      idleWaiter.ping();
+      ctx.idleWaiter.ping();
       pidStore.updateStatus(shell.pid, "active").catch(() => null);
     })
-    .forEach(() => nextStdout.ready())
+    .forEach(() => ctx.nextStdout.ready())
 
     .forkTo(async function rawLogger(f) {
-      if (!rawLogPath) return f.run(); // no stream
+      if (!ctx.logPaths.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 })
+      return await mkdir(path.dirname(ctx.logPaths.rawLogPath), { recursive: true })
         .then(() => {
-          logger.debug(`[${cli}-yes] raw logs streaming to ${rawLogPath}`);
+          logger.debug(`[${cli}-yes] raw logs streaming to ${ctx.logPaths.rawLogPath}`);
           return f
             .forEach(async (chars) => {
-              await writeFile(rawLogPath, chars, { flag: "a" }).catch(() => null);
+              await writeFile(ctx.logPaths.rawLogPath!, chars, { flag: "a" }).catch(() => null);
             })
             .run();
         })
@@ -636,36 +540,7 @@ export default async function agentYes({
     .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;
-        }
-
-        // 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;
-      });
+      return e.forEach((text) => handleConsoleControlCodes(text, shell, terminalRender, cli, verbose));
     })
 
     // auto-response
@@ -695,75 +570,19 @@ export default async function agentYes({
           // })
 
           // 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();
-            }
-            // 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);
-              }
-            }
-          })
+          .forEach(async (line, lineIndex) =>
+            createAutoResponseHandler(line, lineIndex, { ctx, conf, cli, workingDir, exitAgent }),
+          )
           .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(),
-      }),
-    )
+    .by(createTerminatorStream(pendingExitCode.promise))
     .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}`);
-  }
+  await saveLogFile(ctx.logPaths.logPath, terminalRender.render());
 
   // and then get its exitcode
   const exitCode = await pendingExitCode.promise;
@@ -776,72 +595,15 @@ export default async function agentYes({
   await outputWriter.close();
 
   // deprecated logFile option, we have logPath now, but keep for backward compatibility
-  if (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 writeFile(logFilePath, terminalRender.render());
-  }
+  await saveDeprecatedLogFile(logFile, terminalRender.render(), verbose);
 
   return { exitCode, logs: terminalRender.render() };
 
-  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); // wait for idle a while
-    const et = Date.now();
-    // process.stdout.write(`\ridleWaiter.wait(${waitms}) took ${et - st}ms\r`);
-    logger.debug(`sendEn| idleWaiter.wait(${String(waitms)}) took ${String(et - st)}ms`);
-    nextStdout.unready();
-    // 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");
-          }
-          resolve();
-        }, 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 } = {}) {
-    if (waitForReady) await stdinReady.wait();
-    // show in-place message: write msg and move cursor back start
-    logger.debug(`send  |${message}`);
-    nextStdout.unready();
-    shell.write(message);
-    idleWaiter.ping(); // just sent a message, wait for echo
-    logger.debug(`waiting next stdout|${message}`);
-    await nextStdout.wait();
-    logger.debug(`sending enter`);
-    await sendEnter(1000);
-    logger.debug(`sent enter`);
-  }
-
   async function exitAgent() {
-    robust = false; // disable robust to avoid auto restart
+    ctx.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
-    for (const cmd of cliConf.exitCommands ?? ["/exit"]) await sendMessage(cmd);
+    for (const cmd of cliConf.exitCommands ?? ["/exit"]) await sendMessage(ctx.messageContext, cmd);
 
     // wait for shell to exit or kill it with a timeout
     let exited = false;
@@ -858,16 +620,6 @@ export default async function agentYes({
       ), // 5 seconds timeout
     ]);
   }
-
-  function getTerminalDimensions() {
-    if (!process.stdout.isTTY) return { cols: 80, rows: 30 }; // default size when not tty
-    return {
-      // TODO: enforce minimum cols/rows to avoid layout issues
-      // cols: Math.max(process.stdout.columns, 80),
-      cols: Math.min(Math.max(20, process.stdout.columns), 80),
-      rows: process.stdout.rows,
-    };
-  }
 }
 
 function sleep(ms: number) {

package/ts/parseCliArgs.ts

@@ -196,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.stdpush || parsedArgv.ipc || parsedArgv.fifo, // Support --stdpush, --ipc, and --fifo (backward compatibility)
+    useFifo: Boolean(parsedArgv.stdpush || parsedArgv.ipc || parsedArgv.fifo), // Support --stdpush, --ipc, and --fifo (backward compatibility)
   };
 }

package/ts/pidStore.ts

@@ -247,6 +247,10 @@ fifo/
 *.raw.log
 *.lines.log
 *.debug.log
+
+# Ignore .gitignore itself
+.gitignore
+
 `;
 
     try {