claude-yes 1.17.1 → 1.19.0

package/README.md

@@ -1,25 +1,51 @@
 # Yes! Claude
 
-A wrapper tool that automates interactions with the Claude CLI by automatically handling common prompts and responses.
+A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses. Originally designed for Claude CLI, now supports multiple AI coding assistants.
 
 ⚠️ **Important Security Warning**: Only run this on trusted repositories. This tool automatically responds to prompts and can execute commands without user confirmation. Be aware of potential prompt injection attacks where malicious code or instructions could be embedded in files or user inputs to manipulate the automated responses.
 
 ## Features
 
-- Same as `claude` command
-- Automatically responds to common prompts like "Yes, proceed" and "Yes"
-- So, this will Let claude keep run until your task done, and wait for your next prompt.
-- You can still Queue More Prompts or Cancel executing task by `ESC` or `Ctrl+C`
+- **Multi-CLI Support**: Works with Claude, Gemini, Codex, Copilot, and Cursor CLI tools
+- **Auto-Response**: Automatically responds to common prompts like "Yes, proceed" and "Yes"
+- **Continuous Operation**: Keeps the AI assistant running until your task is done, waiting for your next prompt
+- **Interactive Control**: You can still queue more prompts or cancel executing tasks with `ESC` or `Ctrl+C`
+- **Crash Recovery**: Automatically restarts crashed processes (where supported)
+- **Idle Detection**: Optional auto-exit when the AI becomes idle
 
-## Prerequirements
+## Prerequisites
 
-First, install Claude Code globally:
+Install the AI CLI tool(s) you want to use:
 
+### Claude
 ```bash
 npm install -g @anthropic-ai/claude-code
 ```
+Learn more: https://www.anthropic.com/claude-code
 
-Learn more about Claude Code: https://www.anthropic.com/claude-code
+### Gemini
+```bash
+# Install Gemini CLI (if available)
+# Check Google's documentation for installation instructions
+```
+
+### Codex
+```bash
+# Install Codex CLI (if available)
+# Check Microsoft's documentation for installation instructions
+```
+
+### GitHub Copilot
+```bash
+# Install GitHub Copilot CLI
+# Check GitHub's documentation for installation instructions
+```
+
+### Cursor
+```bash
+# Install Cursor agent CLI
+# Check Cursor's documentation for installation instructions
+```
 
 Then install this project:
 
@@ -29,49 +55,117 @@ npm install claude-yes -g
 
 ## Usage
 
-### claude-yes cli
+### Command Line Interface
 
 ```bash
-claude-yes [--exit-on-idle=60s] [claude-command] [claude-prompts]
-# works exactly same as `claude` command, and automatically says "Yes" to all yes/no prompts
+claude-yes [--cli=<tool>] [--exit-on-idle=60s] [tool-command] [prompts]
+```
+
+#### Examples
 
-# e.g.
+**Claude (default):**
+```bash
 claude-yes "run all tests and commit current changes"
 bunx claude-yes "Solve TODO.md"
+```
+
+**Other AI tools:**
+```bash
+# Use Gemini
+claude-yes --cli=gemini "help me debug this code"
 
-# Auto-exit when Claude becomes idle (useful for automation scripts)
+# Use Codex  
+claude-yes --cli=codex "refactor this function"
+
+# Use Copilot
+claude-yes --cli=copilot "generate unit tests"
+
+# Use Cursor
+claude-yes --cli=cursor "optimize performance"
+```
+
+**Auto-exit when idle (useful for automation):**
+```bash
 claude-yes --exit-on-idle=60s "run all tests and commit current changes"
+```
 
-# Alternative: use with claude-code-execute
+**Alternative with claude-code-execute:**
+```bash
 claude-code-execute claude-yes "your task here"
 ```
 
+### Supported CLI Tools
+
+| Tool | CLI Name | Description |
+|------|----------|-------------|
+| Claude | `claude` | Anthropic's Claude Code (default) |
+| Gemini | `gemini` | Google's Gemini CLI |
+| Codex | `codex` | Microsoft's Codex CLI |
+| Copilot | `copilot` | GitHub Copilot CLI |
+| Cursor | `cursor` | Cursor agent CLI |
+
 The tool will:
 
-1. run Claude Code
-2. Whenever claude stucked on yes/no prompts, Automatically say YES, YES, YES, YES, YES to claude
-3. When using `--exit-on-idle` flag, automatically exit when Claude becomes idle for 3 seconds (useful for automation scripts)
+1. Run the specified AI CLI tool
+2. Automatically respond "Yes" to common yes/no prompts
+3. Handle tool-specific patterns and responses
+4. When using `--exit-on-idle` flag, automatically exit when the tool becomes idle
 
 <!-- TODO: add usage As lib: call await claudeYes() and it returns render result -->
 
 ## Options
 
-- `--exit-on-idle`: Automatically exit when Claude becomes idle for 3 seconds. Useful for automation scripts where you want the process to terminate when Claude finishes its work.
+- `--cli=<tool>`: Specify which AI CLI tool to use (claude, gemini, codex, copilot, cursor). Defaults to `claude`.
+- `--exit-on-idle=<seconds>`: Automatically exit when the AI tool becomes idle for the specified duration. Useful for automation scripts.
 
-## Implementation
+## Library Usage
 
-The tool simply mirrors the terminal use node-pty and looks for "❯ 1. Yes" patterns to automatically respond with "\r" to proceed with Claude's prompts.
+You can also use this as a library in your Node.js projects:
 
+```typescript
+import claudeYes from 'claude-yes';
+
+// Use Claude
+await claudeYes({
+  prompt: 'help me solve all todos in my codebase',
+  cli: 'claude',
+  cliArgs: ['--verbose'],
+  exitOnIdle: 30000, // exit after 30 seconds of idle
+  continueOnCrash: true,
+  logFile: 'claude.log',
+});
+
+// Use other tools
+await claudeYes({
+  prompt: 'debug this function',
+  cli: 'gemini',
+  exitOnIdle: 60000,
+});
 ```
-❯ 1. Yes
-  2. No
-```
 
-The tool will automatically send "\r" when it detects this pattern.
+## Implementation
+
+The tool uses `node-pty` to spawn and manage AI CLI processes, with a sophisticated pattern-matching system that:
+
+1. **Detects Ready States**: Recognizes when each CLI tool is ready to accept input
+2. **Auto-Responds**: Automatically sends "Yes" responses to common prompts
+3. **Handles Fatal Errors**: Detects and responds to fatal error conditions
+4. **Manages Process Lifecycle**: Handles crashes, restarts, and graceful exits
+
+Each supported CLI has its own configuration defining:
+- **Ready patterns**: Regex patterns that indicate the tool is ready for input
+- **Enter patterns**: Patterns that trigger automatic "Yes" responses  
+- **Fatal patterns**: Patterns that indicate fatal errors requiring exit
+- **Binary mapping**: Maps logical names to actual executable names
+- **Argument handling**: Special argument processing (e.g., adding `--search` to Codex)
 
 ## Dependencies
 
-- `node-pty` - For spawning and managing the Claude CLI process
+- `node-pty` or `bun-pty` - For spawning and managing AI CLI processes
+- `from-node-stream` - Stream processing utilities
+- `sflow` - Functional stream processing
+- `terminal-render` - Terminal rendering and text processing
+- `phpdie` - Error handling utilities
 
 ## Inspiration
 

package/ReadyManager.ts

@@ -2,10 +2,8 @@ export class ReadyManager {
   private isReady = false;
   private readyQueue: (() => void)[] = [];
   wait() {
-    return new Promise<void>((resolve) => {
-      if (this.isReady) return resolve();
-      this.readyQueue.push(resolve);
-    });
+    if (this.isReady) return;
+    return new Promise<void>((resolve) => this.readyQueue.push(resolve));
   }
   unready() {
     this.isReady = false;

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,332 @@
+#!/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() {
+    if (this.isReady)
+      return;
+    return new Promise((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/],
+    fatal: []
+  },
+  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/],
+    fatal: []
+  },
+  cursor: {
+    binary: "cursor-agent",
+    ready: /\/ commands/,
+    enter: [/→ Run \(once\) \(y\) \(enter\)/, /▶ \[a\] Trust this workspace/],
+    fatal: []
+  }
+};
+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] || null;
+    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();
+        }
+      }
+      if (conf.fatal && Array.isArray(conf.fatal)) {
+        for (const rx of conf.fatal) {
+          if (e2.match(rx))
+            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=0E9D5C1D34AAD47764756E2164756E21
+//# sourceMappingURL=cli.js.map