claude-yes 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 snomiao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# Yes! Claude
+
+A wrapper tool that automates interactions with the Claude CLI by automatically handling common prompts and responses.
+
+⚠️ **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`
+
+## Prerequirements
+
+First, install Claude Code globally:
+
+```bash
+npm install -g @anthropic-ai/claude-code
+```
+
+Learn more about Claude Code: https://www.anthropic.com/claude-code
+
+Then install this project:
+
+```bash
+npm install claude-yes -g
+```
+
+## Usage
+
+### claude-yes cli
+
+```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
+
+# e.g.
+claude-yes "run all tests and commit current changes"
+bunx claude-yes "Solve TODO.md"
+
+# Auto-exit when Claude becomes idle (useful for automation scripts)
+claude-yes --exit-on-idle=60s "run all tests and commit current changes"
+
+# Alternative: use with claude-code-execute
+claude-code-execute claude-yes "your task here"
+```
+
+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)
+
+<!-- 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.
+
+## Implementation
+
+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.
+
+```
+❯ 1. Yes
+  2. No
+```
+
+The tool will automatically send "\r" when it detects this pattern.
+
+## Dependencies
+
+- `node-pty` - For spawning and managing the Claude CLI process
+
+## Inspiration
+
+This project was inspired by: [Claude Code full auto while I sleep : r/ClaudeAI](https://www.reddit.com/r/ClaudeAI/comments/1klk6aw/claude_code_full_auto_while_i_sleep/)
+
+## License
+
+MIT

package/ReadyManager.ts

@@ -0,0 +1,18 @@
+export class ReadyManager {
+  private isReady = false;
+  private readyQueue: (() => void)[] = [];
+  wait() {
+    return new Promise<void>((resolve) => {
+      if (this.isReady) return resolve();
+      this.readyQueue.push(resolve);
+    });
+  }
+  unready() {
+    this.isReady = false;
+  }
+  ready() {
+    this.isReady = true;
+    if (!this.readyQueue.length) return; // check len for performance
+    this.readyQueue.splice(0).map((resolve) => resolve());
+  }
+}

package/cli-idle.spec.ts

@@ -0,0 +1,17 @@
+import { exec } from 'child_process';
+import { fromStdio } from 'from-node-stream';
+import sflow from 'sflow';
+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"`,
+  );
+  const tr = new TransformStream<string, string>();
+  const output = await sflow(tr.readable).by(fromStdio(p)).log().text();
+  console.log(output);
+  expect(output).toContain('hello');
+  await sleepms(1000); // wait for process exit
+  expect(p.exitCode).toBe(0);
+}, 20e3);

package/cli.test.ts

@@ -0,0 +1,63 @@
+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 { IdleWaiter } from "./idleWaiter";
+import { sleepms } from "./utils";
+
+it("Write file with auto bypass prompts", async () => {
+  const flagFile = "./.cache/flag.json";
+  await cleanup();
+  async function cleanup() {
+    await unlink(flagFile).catch(() => {});
+    await unlink("./cli-rendered.log").catch(() => {});
+  }
+
+  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"`
+  );
+  const pExitCode = new Promise<number | null>((r) => p.once("exit", r));
+
+  const tr = new TransformStream<string, string>();
+  const w = tr.writable.getWriter();
+
+  const exit = async () =>
+    await sflow(["\r", "/exit", "\r", "\r"])
+      .forEach(async (e) => {
+        await sleepms(200);
+        await w.write(e);
+      })
+      .run();
+
+  // ping function to exit claude when idle
+
+  const idleWaiter = new IdleWaiter()
+  idleWaiter.wait(3000).then(() => exit());
+
+  const output = await sflow(tr.readable)
+    .by(fromStdio(p))
+    .log()
+    .forEach(() => idleWaiter.ping())
+    .text();
+
+  // expect the file exists
+  expect(existsSync(flagFile)).toBe(true);
+  // expect the output contains the file path
+  expect(output).toContain(flagFile);
+
+  // expect the file content to be 'on'
+  expect(await new Response(await readFile(flagFile)).json()).toEqual({
+    on: 1,
+  });
+
+  expect(await pExitCode).toBe(0); // expect the process to exit successfully
+  expect(await readFile("./cli-rendered.log", "utf8")).toBeTruthy();
+
+  // clean
+  await cleanup();
+
+  // it usually takes 13s to run (10s for claude to solve this problem, 3s for idle watcher to exit)
+}, 30e3);

package/cli.ts

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+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] [--] [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();
+
+// 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({
+  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,
+});
+
+process.exit(exitCode ?? 1);

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() {
+    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: []
+  },
+  gemini: {
+    ready: "",
+    enter: []
+  },
+  codex: {
+    ready: "",
+    enter: [],
+    ensureArgs: (args) => {
+      if (!args.includes("--search"))
+        return ["--search", ...args];
+      return args;
+    }
+  },
+  copilot: {},
+  cursor: {
+    binary: "cursor-agent"
+  }
+};
+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()).map((e) => e.replaceAll("\x1A", "")).by({
+    writable: new WritableStream({
+      write: async (data) => {
+        await idleWaiter.wait(200);
+        shell.write(data);
+      }
+    }),
+    readable: shellOutputStream.readable
+  }).forEach(() => idleWaiter.ping()).forEach((text) => terminalRender.write(text)).forEach((txt) => {
+    if (process.stdin.isTTY)
+      return;
+    if (txt.includes("\x1B[6n"))
+      return;
+    const rendered = terminalRender.render();
+    const row = rendered.split(`
+`).length + 1;
+    const col = (rendered.split(`
+`).slice(-1)[0]?.length || 0) + 1;
+  }).forkTo((e) => e.map((e2) => removeControlCharacters(e2)).map((e2) => e2.replaceAll("\r", "")).lines({ EOL: "NONE" }).forEach(async (e2) => {
+    if (cli !== "claude")
+      return;
+    if (e2.match(/^> /))
+      return stdinReady.ready();
+    if (e2.match(/❯ 1. Yes/))
+      return await sendEnter();
+    if (e2.match(/❯ 1. Dark mode✔|Press Enter to continue…/))
+      return await sendEnter();
+    if (e2.match(/No conversation found to continue/))
+      return isFatal = true;
+    if (e2.match(/⎿ {2}Claude usage limit reached./))
+      return isFatal = true;
+  }).forEach(async (e2, i) => {
+    if (cli !== "gemini")
+      return;
+    if (e2.match(/ > {3}Type your message/) && i > 80) {
+      return stdinReady.ready();
+    }
+    if (e2.match(/│ ● 1. Yes, allow once/))
+      return await sendEnter();
+  }).forEach(async (e2) => {
+    if (cli === "codex") {
+      if (e2.match(/ > 1. Approve/))
+        return await sendEnter();
+      if (e2.match(/Error: The cursor position could not be read within/))
+        return isFatal = true;
+      if (e2.match(/> 1. Yes, allow Codex to work in this folder/))
+        return await sendEnter();
+      if (e2.match(/⏎ send/))
+        return stdinReady.ready();
+      return;
+    }
+    if (cli === "cursor") {
+      if (e2.match(/\/ commands/))
+        return stdinReady.ready();
+      if (e2.match(/→ Run \(once\) \(y\) \(enter\)/))
+        return await sendEnter();
+      if (e2.match(/▶ \[a\] Trust this workspace/))
+        return await sendEnter();
+    }
+  }).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=81134D71621755A164756E2164756E21
+//# sourceMappingURL=cli.js.map