claude-yes 1.24.2 → 1.26.0

package/ts/index.ts

@@ -5,6 +5,8 @@ import DIE from 'phpdie';
 import sflow from 'sflow';
 import { TerminalTextRender } from 'terminal-render';
 import tsaComposer from 'tsa-composer';
+import rawConfig from '../cli-yes.config.js';
+import { defineCliYesConfig } from './defineConfig.js';
 import { IdleWaiter } from './idleWaiter';
 import { ReadyManager } from './ReadyManager';
 import { removeControlCharacters } from './removeControlCharacters';
@@ -14,73 +16,36 @@ import {
   shouldUseLock,
   updateCurrentTaskStatus,
 } from './runningLock';
-// const yesLog = tsaComposer()(async function yesLog(msg: string) {
-//   // await rm('agent-yes.log').catch(() => null); // ignore error if file doesn't exist
-//   await appendFile("agent-yes.log", `${msg}\n`).catch(() => null);
-// });
-
-export const CLI_CONFIGURES: Record<
-  string,
-  {
-    install?: string; // hint user for install command if not installed
-    binary?: string; // actual binary name if different from cli
-    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
-    ensureArgs?: (args: string[]) => string[]; // function to ensure certain args are present
-  }
-> = {
-  grok: {
-    install: 'npm install -g @vibe-kit/grok-cli',
-    ready: [/^  │ ❯ /],
-    enter: [/^   1. Yes/],
-  },
-  claude: {
-    install: 'npm install -g @anthropic-ai/claude-code',
-    // ready: [/^> /], // regex matcher for stdin ready
-    ready: [/\? for shortcuts/], // regex matcher for stdin ready
-    enter: [/❯ 1. Yes/, /❯ 1. Dark mode✔/, /Press Enter to continue…/],
-    fatal: [
-      /No conversation found to continue/,
-      /⎿  Claude usage limit reached\./,
-    ],
-  },
-  gemini: {
-    install: 'npm install -g @google/gemini-cli',
-    // match the agent prompt after initial lines; handled by index logic using line index
-    ready: [/Type your message/], // used with line index check
-    enter: [/│ ● 1. Yes, allow once/],
-    fatal: [],
-  },
-  codex: {
-    install: 'npm install -g @openai/codex-cli',
-    ready: [/⏎ send/],
-    enter: [
-      /> 1. Yes, allow Codex to work in this folder/,
-      /> 1. Approve and run now/,
-    ],
-    fatal: [/Error: The cursor position could not be read within/],
-    // add to codex --search by default when not provided by the user
-    ensureArgs: (args: string[]) => {
-      if (!args.includes('--search')) return ['--search', ...args];
-      return args;
-    },
-  },
-  copilot: {
-    install: 'npm install -g @github/copilot',
-    ready: [/^ +> /, /Ctrl\+c Exit/],
-    enter: [/ │ ❯ 1. Yes, proceed/, /❯ 1. Yes/],
-    fatal: [],
-  },
-  cursor: {
-    install: 'open https://cursor.com/ja/docs/cli/installation',
-    // map logical "cursor" cli name to actual binary name
-    binary: 'cursor-agent',
-    ready: [/\/ commands/],
-    enter: [/→ Run \(once\) \(y\) \(enter\)/, /▶ \[a\] Trust this workspace/],
-    fatal: [/^  Error: You've hit your usage limit/],
-  },
+import { catcher } from './tryCatch';
+import { deepMixin } from './utils';
+import { yesLog } from './yesLog';
+
+export type AgentCliConfig = {
+  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
+  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
+  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
+};
+export type CliYesConfig = {
+  clis: { [key: string]: AgentCliConfig };
 };
+
+// load user config from cli-yes.config.ts if exists
+export const config = await rawConfig;
+
+export const CLIS_CONFIG = config.clis as Record<
+  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
  * @param options Configuration options
@@ -96,77 +61,86 @@ export const CLI_CONFIGURES: Record<
  *
  * @example
  * ```typescript
- * import claudeYes from 'claude-yes';
- * await claudeYes({
+ * import cliYes from 'cli-yes';
+ * await cliYes({
  *   prompt: 'help me solve all todos in my codebase',
  *
  *   // optional
- *   cli: 'claude',
- *   cliArgs: ['--verbose'], // additional args to pass to claude
+ *   cliArgs: ['--verbose'], // additional args to pass to agent-cli
  *   exitOnIdle: 30000, // exit after 30 seconds of idle
- *   continueOnCrash: true, // restart if claude crashes, default is true
+ *   robust: true, // auto restart with --continue if claude crashes, default is true
  *   logFile: 'claude.log', // save logs to file
  *   disableLock: false, // disable running lock (default is false)
  * });
  * ```
  */
-export default async function claudeYes({
-  cli = 'claude',
+export default async function cliYes({
+  cli,
   cliArgs = [],
   prompt,
-  // continueOnCrash,
+  robust = true,
   cwd,
   env,
   exitOnIdle,
   logFile,
   removeControlCharactersFromStdout = false, // = !process.stdout.isTTY,
   verbose = false,
-  disableLock = false,
+  queue = true,
 }: {
-  cli?: (string & {}) | keyof typeof CLI_CONFIGURES;
+  cli: SUPPORTED_CLIS;
   cliArgs?: string[];
   prompt?: string;
-  // continueOnCrash?: boolean;
+  robust?: boolean;
   cwd?: string;
   env?: Record<string, string>;
   exitOnIdle?: number;
   logFile?: string;
   removeControlCharactersFromStdout?: boolean;
   verbose?: boolean;
-  disableLock?: boolean;
-} = {}) {
-  const continueArgs = {
-    codex: 'resume --last'.split(' '),
-    claude: '--continue'.split(' '),
-    gemini: [], // not possible yet
-  };
+  queue?: boolean;
+}) {
+  // those overrides seems only works in bun
+  // await Promise.allSettled([
+  //   import(path.join(process.cwd(), "cli-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(async (override) => deepMixin(config, override || {}))
+  //   .catch((error) => {
+  //     if (process.env.VERBOSE)
+  //       console.warn("Fail to load cli-yes.config.ts", error);
+  //   });
+
+  if (!cli) throw new Error(`cli is required`);
+  const conf = CLIS_CONFIG[cli] || DIE(`Unsupported cli tool: ${cli}`);
 
   // Acquire lock before starting agent (if in git repo or same cwd and lock is not disabled)
   const workingDir = cwd ?? process.cwd();
-  if (!disableLock && shouldUseLock(workingDir)) {
-    await acquireLock(workingDir, prompt ?? 'Interactive session');
-  }
-
-  // Register cleanup handlers for lock release
-  const cleanupLock = async () => {
-    if (!disableLock && shouldUseLock(workingDir)) {
-      await releaseLock().catch(() => null); // Ignore errors during cleanup
+  if (queue) {
+    if (queue && shouldUseLock(workingDir)) {
+      await acquireLock(workingDir, prompt ?? 'Interactive session');
     }
-  };
 
-  process.on('exit', () => {
-    if (!disableLock) {
-      releaseLock().catch(() => null);
-    }
-  });
-  process.on('SIGINT', async () => {
-    await cleanupLock();
-    process.exit(130);
-  });
-  process.on('SIGTERM', async () => {
-    await cleanupLock();
-    process.exit(143);
-  });
+    // Register cleanup handlers for lock release
+    const cleanupLock = async () => {
+      if (queue && shouldUseLock(workingDir)) {
+        await releaseLock().catch(() => null); // Ignore errors during cleanup
+      }
+    };
+
+    process.on('exit', () => {
+      if (queue) releaseLock().catch(() => null);
+    });
+    process.on('SIGINT', async (code) => {
+      await cleanupLock();
+      process.exit(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
@@ -192,21 +166,49 @@ export default async function claudeYes({
   });
 
   // Apply CLI specific configurations (moved to CLI_CONFIGURES)
-  const cliConf = (CLI_CONFIGURES as Record<string, any>)[cli] || {};
-  cliArgs = cliConf.ensureArgs?.(cliArgs) ?? cliArgs;
+  const cliConf = (CLIS_CONFIG as Record<string, AgentCliConfig>)[cli] || {};
+  cliArgs = cliConf.defaultArgs
+    ? [...cliConf.defaultArgs, ...cliArgs]
+    : cliArgs;
+
+  if (prompt && cliConf.promptArg) {
+    if (cliConf.promptArg === 'first-arg') {
+      cliArgs = [prompt, ...cliArgs];
+      prompt = undefined; // clear prompt to avoid sending later
+    } else if (cliConf.promptArg === 'last-arg') {
+      cliArgs = [...cliArgs, prompt];
+      prompt = undefined; // clear prompt to avoid sending later
+    } 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}`);
+    }
+  }
   const cliCommand = cliConf?.binary || cli;
 
-  let shell = tryCatch(
-    () => pty.spawn(cliCommand, cliArgs, getPtyOptions()),
+  let shell = catcher(
     (error: unknown) => {
       console.error(`Fatal: Failed to start ${cliCommand}.`);
-      if (cliConf?.install)
+      if (cliConf?.install && isCommandNotFoundError(error))
         console.error(
           `If you did not installed it yet, Please install it first: ${cliConf.install}`,
         );
       throw error;
+
+      function isCommandNotFoundError(e: unknown) {
+        if (e instanceof Error) {
+          return (
+            e.message.includes('command not found') ||
+            e.message.includes('ENOENT') ||
+            e.message.includes('spawn') // windows
+          );
+        }
+        return false;
+      }
     },
-  );
+    () => pty.spawn(cliCommand, cliArgs, getPtyOptions()),
+  )();
   const pendingExitCode = Promise.withResolvers<number | null>();
   let pendingExitCodeValue = null;
 
@@ -214,35 +216,35 @@ export default async function claudeYes({
   // npm install -g @anthropic-ai/claude-code
 
   async function onData(data: string) {
-    nextStdout.ready();
     // append data to the buffer, so we can process it later
     await outputWriter.write(data);
   }
 
   shell.onData(onData);
   shell.onExit(function onExit({ exitCode }) {
-    nextStdout.ready();
     stdinReady.unready(); // start buffer stdin
     const agentCrashed = exitCode !== 0;
-    const continueArg = (continueArgs as Record<string, string[]>)[cli];
-
-    // if (agentCrashed && continueOnCrash && continueArg) {
-    //   if (!continueArg) {
-    //     return console.warn(
-    //       `continueOnCrash is only supported for ${Object.keys(continueArgs).join(", ")} currently, not ${cli}`
-    //     );
-    //   }
-    //   if (isFatal) {
-    //     return pendingExitCode.resolve((pendingExitCodeValue = exitCode));
-    //   }
-
-    //   console.log(`${cli} crashed, restarting...`);
-
-    //   shell = pty.spawn(cli, continueArg, getPtyOptions());
-    //   shell.onData(onData);
-    //   shell.onExit(onExit);
-    //   return;
-    // }
+
+    if (agentCrashed && robust && conf?.restoreArgs) {
+      if (!conf.restoreArgs) {
+        return console.warn(
+          `robust is only supported for ${Object.entries(CLIS_CONFIG)
+            .filter(([_, v]) => v.restoreArgs)
+            .map(([k]) => k)
+            .join(', ')} currently, not ${cli}`,
+        );
+      }
+      if (isFatal) {
+        return pendingExitCode.resolve((pendingExitCodeValue = exitCode));
+      }
+
+      console.log(`${cli} crashed, restarting...`);
+
+      shell = pty.spawn(cli, conf.restoreArgs, getPtyOptions());
+      shell.onData(onData);
+      shell.onExit(onExit);
+      return;
+    }
     return pendingExitCode.resolve((pendingExitCodeValue = exitCode));
   });
 
@@ -294,7 +296,8 @@ export default async function claudeYes({
       readable: shellOutputStream.readable,
     })
     .forEach(() => idleWaiter.ping())
-    .forEach((text) => {
+    .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
@@ -306,7 +309,7 @@ export default async function claudeYes({
       // 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=${row}, col=${col}`);
+      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;
     })
@@ -317,33 +320,29 @@ export default async function claudeYes({
         .map((e) => removeControlCharacters(e))
         .map((e) => e.replaceAll('\r', '')) // remove carriage return
         .by((s) => {
-          if (cli === 'codex') 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
+          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
         })
-        // .forEach((e) => yesLog`output|${e}`) // for debugging
+        .forEach((e) => yesLog`output|${e}`) // for debugging
         // Generic auto-response handler driven by CLI_CONFIGURES
         .forEach(async (e, i) => {
-          const conf =
-            CLI_CONFIGURES[cli as keyof typeof CLI_CONFIGURES] || null;
-          if (!conf) return;
-
           // ready matcher: if matched, mark stdin ready
           if (conf.ready?.some((rx: RegExp) => e.match(rx))) {
-            // await yesLog`ready |${e}`;
+            await yesLog`ready |${e}`;
             if (cli === 'gemini' && i <= 80) return; // gemini initial noise, only after many lines
             stdinReady.ready();
           }
 
           // enter matchers: send Enter when any enter regex matches
           if (conf.enter?.some((rx: RegExp) => e.match(rx))) {
-            // await yesLog`enter |${e}`;
+            await yesLog`enter |${e}`;
             await sendEnter(300); // send Enter after 300ms idle wait
             return;
           }
 
           // fatal matchers: set isFatal flag when matched
           if (conf.fatal?.some((rx: RegExp) => e.match(rx))) {
-            // await yesLog`fatal |${e}`;
+            await yesLog`fatal |${e}`;
             isFatal = true;
             await exitAgent();
           }
@@ -364,7 +363,7 @@ export default async function claudeYes({
   console.log(`[${cli}-yes] ${cli} exited with code ${exitCode}`);
 
   // Update task status and release lock
-  if (!disableLock && shouldUseLock(workingDir)) {
+  if (queue && shouldUseLock(workingDir)) {
     await updateCurrentTaskStatus(
       exitCode === 0 ? 'completed' : 'failed',
     ).catch(() => null);
@@ -388,24 +387,40 @@ export default async function claudeYes({
     await idleWaiter.wait(waitms);
     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`;
-
+    await yesLog`sendEn| idleWaiter.wait(${String(waitms)}) took ${String(et - st)}ms`;
+    nextStdout.unready();
     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),
+      ),
+    ]);
   }
 
   async function sendMessage(message: string) {
     await stdinReady.wait();
     // show in-place message: write msg and move cursor back start
-    // await yesLog`send  |${message}`;
-    shell.write(message);
+    yesLog`send  |${message}`;
     nextStdout.unready();
+    shell.write(message);
     idleWaiter.ping(); // just sent a message, wait for echo
+    yesLog`waiting next stdout|${message}`;
     await nextStdout.wait();
-    await sendEnter();
+    yesLog`sending enter`;
+    await sendEnter(1000);
+    yesLog`sent enter`;
   }
 
   async function exitAgent() {
-    // continueOnCrash = false;
+    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');
 
@@ -437,11 +452,3 @@ export default async function claudeYes({
 }
 
 export { removeControlCharacters };
-
-function tryCatch<T, R>(fn: () => T, catchFn: (error: unknown) => R): T | R {
-  try {
-    return fn();
-  } catch (error) {
-    return catchFn(error);
-  }
-}