claude-yes 1.17.0 → 1.18.0

package/cli-idle.spec.ts

@@ -6,7 +6,7 @@ import { sleepms } from './utils';
 // 2025-08-11 ok
 it.skip('CLI --exit-on-idle flag with custom timeout', async () => {
   const p = exec(
-    `bunx tsx ./cli.ts --verbose --logFile=./cli-idle.log --exit-on-idle=3s "say hello and wait"`
+    `bunx tsx ./cli.ts --verbose --logFile=./cli-idle.log --exit-on-idle=3s "say hello and wait"`,
   );
   const tr = new TransformStream<string, string>();
   const output = await sflow(tr.readable).by(fromStdio(p)).log().text();

package/cli.test.ts

@@ -1,11 +1,11 @@
-import { execaCommand } from 'execa';
-import { fromStdio } from 'from-node-stream';
 import { exec } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { readFile, unlink } from 'node:fs/promises';
+import { execaCommand } from 'execa';
+import { fromStdio } from 'from-node-stream';
 import sflow from 'sflow';
 import { beforeAll, describe, expect, it } from 'vitest';
-import { createIdleWatcher } from './createIdleWatcher';
+import { IdleWaiter } from './idleWaiter';
 import { sleepms } from './utils';
 
 it('Write file with auto bypass prompts', async () => {
@@ -17,7 +17,7 @@ it('Write file with auto bypass prompts', async () => {
   }
 
   const p = exec(
-    `bunx tsx ./cli.ts --logFile=./cli-rendered.log --exit-on-idle=3s "just write {on: 1} into ./.cache/flag.json and wait"`
+    `bunx tsx ./cli.ts --logFile=./cli-rendered.log --exit-on-idle=3s "just write {on: 1} into ./.cache/flag.json and wait"`,
   );
   const pExitCode = new Promise<number | null>((r) => p.once('exit', r));
 
@@ -34,12 +34,13 @@ it('Write file with auto bypass prompts', async () => {
 
   // ping function to exit claude when idle
 
-  const { ping } = createIdleWatcher(() => exit(), 3000);
+  const idleWaiter = new IdleWaiter();
+  idleWaiter.wait(3000).then(() => exit());
 
   const output = await sflow(tr.readable)
     .by(fromStdio(p))
     .log()
-    .forEach(() => ping())
+    .forEach(() => idleWaiter.ping())
     .text();
 
   // expect the file exists

package/cli.ts

@@ -1,35 +1,44 @@
 #!/usr/bin/env node
-import ms from 'enhanced-ms';
+import enhancedMs from 'enhanced-ms';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import claudeYes from '.';
 
 // cli entry point
 const argv = yargs(hideBin(process.argv))
-  .usage('Usage: $0 [options] [--] [claude args]')
+  .usage('Usage: $0 [options] [claude args] [--] [prompts...]')
   .example(
     '$0 --exit-on-idle=30s --continue-on-crash "help me solve all todos in my codebase"',
-    'Run Claude with a 30 seconds idle timeout and continue on crash'
+    'Run Claude with a 30 seconds idle timeout and continue on crash',
   )
-  .option('exit-on-idle', {
-    type: 'string',
-    default: '60s',
-    description:
-      'Exit after being idle for specified duration, default 1min, set to 0 to disable this behaviour',
-  })
   .option('continue-on-crash', {
     type: 'boolean',
     default: true,
-    description: 'Continue running even if Claude crashes',
+    description:
+      'spawn Claude with --continue if it crashes, only works for claude',
   })
   .option('log-file', {
     type: 'string',
-    description: 'Path to log file for output logging',
+    description: 'Log file to write to',
+  })
+  .option('cli', {
+    type: 'string',
+    description:
+      'Claude CLI command, e.g. "claude,gemini,codex,cursor,copilot", default is "claude"',
+  })
+  .option('prompt', {
+    type: 'string',
+    description: 'Prompt to send to Claude',
+    alias: 'p',
   })
   .option('verbose', {
     type: 'boolean',
-    default: false,
     description: 'Enable verbose logging',
+    default: false,
+  })
+  .option('exit-on-idle', {
+    type: 'string',
+    description: 'Exit after a period of inactivity, e.g., "5s" or "1m"',
   })
   .parserConfiguration({
     'unknown-options-as-args': true,
@@ -37,9 +46,38 @@ const argv = yargs(hideBin(process.argv))
   })
   .parseSync();
 
+// detect cli name for cli, while package.json have multiple bin link: {"claude-yes": "cli.js", "codex-yes": "cli.js", "gemini-yes": "cli.js"}
+if (!argv.cli) {
+  const cliName = process.argv[1]?.split('/').pop()?.split('-')[0];
+  argv.cli = cliName || 'claude';
+}
+
+// Support: everything after a literal `--` is a prompt string. Example:
+//   claude-yes --exit-on-idle=30s -- "help me refactor this"
+// In that example the prompt will be `help me refactor this` and won't be
+// passed as args to the underlying CLI binary.
+const rawArgs = process.argv.slice(2);
+const dashIndex = rawArgs.indexOf('--');
+let promptFromDash: string | undefined = undefined;
+let cliArgsForSpawn: string[] = [];
+if (dashIndex !== -1) {
+  // join everything after `--` into a single prompt string
+  const after = rawArgs.slice(dashIndex + 1);
+  promptFromDash = after.join(' ');
+  // use everything before `--` as the cli args
+  cliArgsForSpawn = rawArgs.slice(0, dashIndex).map(String);
+} else {
+  // fallback to yargs parsed positional args when `--` is not used
+  cliArgsForSpawn = argv._.map((e) => String(e));
+}
+
+console.clear();
 const { exitCode, logs } = await claudeYes({
-  exitOnIdle: argv.exitOnIdle != null ? ms(argv.exitOnIdle) : undefined,
-  claudeArgs: argv._.map((e) => String(e)),
+  cli: argv.cli,
+  // prefer explicit --prompt / -p; otherwise use the text after `--` if present
+  prompt: argv.prompt || promptFromDash,
+  exitOnIdle: argv.exitOnIdle ? enhancedMs(argv.exitOnIdle) : undefined,
+  cliArgs: cliArgsForSpawn,
   continueOnCrash: argv.continueOnCrash,
   logFile: argv.logFile,
   verbose: argv.verbose,

package/dist/claude-yes.js

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// cli.ts
+import enhancedMs from "enhanced-ms";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// dist/index.js
+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";
+class IdleWaiter {
+  lastActivityTime = Date.now();
+  checkInterval = 100;
+  constructor() {
+    this.ping();
+  }
+  ping() {
+    this.lastActivityTime = Date.now();
+    return this;
+  }
+  async wait(ms) {
+    while (this.lastActivityTime >= Date.now() - ms)
+      await new Promise((resolve) => setTimeout(resolve, this.checkInterval));
+  }
+}
+
+class ReadyManager {
+  isReady = false;
+  readyQueue = [];
+  wait() {
+    return new Promise((resolve) => {
+      if (this.isReady)
+        return resolve();
+      this.readyQueue.push(resolve);
+    });
+  }
+  unready() {
+    this.isReady = false;
+  }
+  ready() {
+    this.isReady = true;
+    if (!this.readyQueue.length)
+      return;
+    this.readyQueue.splice(0).map((resolve) => resolve());
+  }
+}
+function removeControlCharacters(str) {
+  return str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
+}
+var CLI_CONFIGURES = {
+  claude: {
+    ready: /^> /,
+    enter: [/❯ 1. Yes/, /❯ 1. Dark mode✔/, /Press Enter to continue…/],
+    fatal: [
+      /No conversation found to continue/,
+      /⎿ {2}Claude usage limit reached\./
+    ]
+  },
+  gemini: {
+    ready: /Type your message/,
+    enter: [/│ ● 1. Yes, allow once/]
+  },
+  codex: {
+    ready: /⏎ send/,
+    enter: [/ > 1. Approve/, /> 1. Yes, allow Codex to work in this folder/],
+    fatal: [/Error: The cursor position could not be read within/],
+    ensureArgs: (args) => {
+      if (!args.includes("--search"))
+        return ["--search", ...args];
+      return args;
+    }
+  },
+  copilot: {
+    ready: /^  > /,
+    enter: [/ │ ❯ 1. Yes, proceed/, /❯ 1. Yes/]
+  },
+  cursor: {
+    binary: "cursor-agent",
+    ready: /\/ commands/,
+    enter: [/→ Run \(once\) \(y\) \(enter\)/, /▶ \[a\] Trust this workspace/]
+  }
+};
+async function claudeYes({
+  cli = "claude",
+  cliArgs = [],
+  prompt,
+  continueOnCrash,
+  cwd,
+  env,
+  exitOnIdle,
+  logFile,
+  removeControlCharactersFromStdout = false,
+  verbose = false
+} = {}) {
+  const continueArgs = {
+    codex: "resume --last".split(" "),
+    claude: "--continue".split(" "),
+    gemini: []
+  };
+  process.stdin.setRawMode?.(true);
+  let isFatal = false;
+  const stdinReady = new ReadyManager;
+  const shellOutputStream = new TransformStream;
+  const outputWriter = shellOutputStream.writable.getWriter();
+  const pty = await import("node-pty").catch(async () => await import("bun-pty")).catch(async () => DIE("Please install node-pty or bun-pty, run this: bun install bun-pty"));
+  const getPtyOptions = () => ({
+    name: "xterm-color",
+    ...getTerminalDimensions(),
+    cwd: cwd ?? process.cwd(),
+    env: env ?? process.env
+  });
+  const cliConf = CLI_CONFIGURES[cli] || {};
+  cliArgs = cliConf.ensureArgs?.(cliArgs) ?? cliArgs;
+  const cliCommand = cliConf?.binary || cli;
+  let shell = pty.spawn(cliCommand, cliArgs, getPtyOptions());
+  const pendingExitCode = Promise.withResolvers();
+  let pendingExitCodeValue = null;
+  async function onData(data) {
+    await outputWriter.write(data);
+  }
+  shell.onData(onData);
+  shell.onExit(function onExit({ exitCode: exitCode2 }) {
+    stdinReady.unready();
+    const agentCrashed = exitCode2 !== 0;
+    const continueArg = continueArgs[cli];
+    if (agentCrashed && continueOnCrash && continueArg) {
+      if (!continueArg) {
+        return console.warn(`continueOnCrash is only supported for ${Object.keys(continueArgs).join(", ")} currently, not ${cli}`);
+      }
+      if (isFatal) {
+        console.log(`${cli} crashed with "No conversation found to continue", exiting...`);
+        return pendingExitCode.resolve(pendingExitCodeValue = exitCode2);
+      }
+      console.log(`${cli} crashed, restarting...`);
+      shell = pty.spawn(cli, continueArg, getPtyOptions());
+      shell.onData(onData);
+      shell.onExit(onExit);
+      return;
+    }
+    return pendingExitCode.resolve(pendingExitCodeValue = exitCode2);
+  });
+  process.stdout.on("resize", () => {
+    const { cols, rows } = getTerminalDimensions();
+    shell.resize(cols, rows);
+  });
+  const terminalRender = new TerminalTextRender;
+  const isStillWorkingQ = () => terminalRender.render().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");
+        return;
+      }
+      console.log("[${cli}-yes] ${cli} is idle, exiting...");
+      await exitAgent();
+    });
+  sflow(fromReadable(process.stdin)).map((buffer) => buffer.toString()).by({
+    writable: new WritableStream({
+      write: async (data) => {
+        await stdinReady.wait();
+        shell.write(data);
+      }
+    }),
+    readable: shellOutputStream.readable
+  }).forEach(() => idleWaiter.ping()).forEach((text) => {
+    terminalRender.write(text);
+    if (process.stdin.isTTY)
+      return;
+    if (text.includes("\x1B[6n"))
+      return;
+    const rendered = terminalRender.render();
+    const row = rendered.split(`
+`).length + 1;
+    const col = (rendered.split(`
+`).slice(-1)[0]?.length || 0) + 1;
+    shell.write(`\x1B[${row};${col}R`);
+  }).forkTo((e) => e.map((e2) => removeControlCharacters(e2)).map((e2) => e2.replaceAll("\r", "")).lines({ EOL: "NONE" }).forEach(async (e2, i) => {
+    const conf = CLI_CONFIGURES[cli] || {};
+    if (!conf)
+      return;
+    try {
+      if (conf.ready) {
+        if (cli === "gemini" && conf.ready instanceof RegExp) {
+          if (e2.match(conf.ready) && i > 80)
+            return stdinReady.ready();
+        } else if (e2.match(conf.ready)) {
+          return stdinReady.ready();
+        }
+      }
+      if (conf.enter && Array.isArray(conf.enter)) {
+        for (const rx of conf.enter) {
+          if (e2.match(rx))
+            return await sendEnter();
+        }
+      } else if (conf.enter && conf.enter instanceof RegExp) {
+        if (e2.match(conf.enter))
+          return await sendEnter();
+      }
+      if (conf.fatal && Array.isArray(conf.fatal)) {
+        for (const rx of conf.fatal) {
+          if (e2.match(rx))
+            return isFatal = true;
+        }
+      } else if (conf.fatal && conf.fatal instanceof RegExp) {
+        if (e2.match(conf.fatal))
+          return isFatal = true;
+      }
+    } catch (err) {
+      return;
+    }
+  }).run()).map((e) => removeControlCharactersFromStdout ? removeControlCharacters(e) : e).to(fromWritable(process.stdout)).then(() => null);
+  if (prompt)
+    (async () => {
+      await sendMessage(prompt);
+    })();
+  const exitCode = await pendingExitCode.promise;
+  console.log(`[${cli}-yes] ${cli} exited with code ${exitCode}`);
+  if (logFile) {
+    verbose && console.log(`[${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());
+  }
+  return { exitCode, logs: terminalRender.render() };
+  async function sendEnter(waitms = 1000) {
+    const st = Date.now();
+    await idleWaiter.wait(waitms);
+    const et = Date.now();
+    process.stdout.write(`\ridleWaiter.wait(${waitms}) took ${et - st}ms\r`);
+    shell.write("\r");
+  }
+  async function sendMessage(message) {
+    await stdinReady.wait();
+    shell.write(message);
+    idleWaiter.ping();
+    await sendEnter();
+  }
+  async function exitAgent() {
+    continueOnCrash = false;
+    await sendMessage("/exit");
+    let exited = false;
+    await Promise.race([
+      pendingExitCode.promise.then(() => exited = true),
+      new Promise((resolve) => setTimeout(() => {
+        if (exited)
+          return;
+        shell.kill();
+        resolve();
+      }, 5000))
+    ]);
+  }
+  function getTerminalDimensions() {
+    return {
+      cols: Math.max(process.stdout.columns, 80),
+      rows: process.stdout.rows
+    };
+  }
+}
+
+// cli.ts
+var argv = yargs(hideBin(process.argv)).usage("Usage: $0 [options] [claude args] [--] [prompts...]").example('$0 --exit-on-idle=30s --continue-on-crash "help me solve all todos in my codebase"', "Run Claude with a 30 seconds idle timeout and continue on crash").option("continue-on-crash", {
+  type: "boolean",
+  default: true,
+  description: "spawn Claude with --continue if it crashes, only works for claude"
+}).option("log-file", {
+  type: "string",
+  description: "Log file to write to"
+}).option("cli", {
+  type: "string",
+  description: 'Claude CLI command, e.g. "claude,gemini,codex,cursor,copilot", default is "claude"'
+}).option("prompt", {
+  type: "string",
+  description: "Prompt to send to Claude",
+  alias: "p"
+}).option("verbose", {
+  type: "boolean",
+  description: "Enable verbose logging",
+  default: false
+}).option("exit-on-idle", {
+  type: "string",
+  description: 'Exit after a period of inactivity, e.g., "5s" or "1m"'
+}).parserConfiguration({
+  "unknown-options-as-args": true,
+  "halt-at-non-option": true
+}).parseSync();
+if (!argv.cli) {
+  const cliName = process.argv[1]?.split("/").pop()?.split("-")[0];
+  argv.cli = cliName || "claude";
+}
+var rawArgs = process.argv.slice(2);
+var dashIndex = rawArgs.indexOf("--");
+var promptFromDash = undefined;
+var cliArgsForSpawn = [];
+if (dashIndex !== -1) {
+  const after = rawArgs.slice(dashIndex + 1);
+  promptFromDash = after.join(" ");
+  cliArgsForSpawn = rawArgs.slice(0, dashIndex).map(String);
+} else {
+  cliArgsForSpawn = argv._.map((e) => String(e));
+}
+console.clear();
+var { exitCode, logs } = await claudeYes({
+  cli: argv.cli,
+  prompt: argv.prompt || promptFromDash,
+  exitOnIdle: argv.exitOnIdle ? enhancedMs(argv.exitOnIdle) : undefined,
+  cliArgs: cliArgsForSpawn,
+  continueOnCrash: argv.continueOnCrash,
+  logFile: argv.logFile,
+  verbose: argv.verbose
+});
+process.exit(exitCode ?? 1);
+
+//# debugId=C444081B11389E6E64756E2164756E21
+//# sourceMappingURL=cli.js.map