claude-yes 1.10.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,77 @@
+# 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 run until your task done, and wait for your next prompt.
+
+## Installation
+
+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 yes-claude -g
+```
+
+## Usage
+
+
+```bash
+yes-claude [command] [prompts] [--exit-on-idle]
+# works exactly same as `claude` command, and automatically says "Yes" to all yes/no prompts
+
+# e.g.
+yes-claude "run all tests and commit current changes"
+bunx yes-claude "Solve TODO.md"
+
+# Auto-exit when Claude becomes idle (useful for automation)
+yes-claude "run all tests and commit current changes" --exit-on-idle
+
+```
+
+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)
+
+## 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
+- `sflow` - For stream processing and data flow management
+- `from-node-stream` - For converting Node.js streams to web streams
+
+## 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/cli.test.ts

@@ -0,0 +1,71 @@
+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 sflow from "sflow";
+import { beforeAll, describe, expect, it } from "vitest";
+import { createIdleWatcher } from "./createIdleWatcher";
+import { sleepms } from './utils';
+
+beforeAll(async () => {
+    await execaCommand(`bun run build`)
+        .then(() => console.log('Build successful')
+        )
+})
+
+describe('CLI Tests', () => {
+    it('Write file with auto bypass permission prompt', async () => {
+        const flagFile = './.cache/flag.json';
+        // clean
+        await unlink(flagFile).catch(() => { });
+
+        const p = exec(`node dist/cli.js --exit-on-idle=3s "just write {on: 1} into ./.cache/flag.json"`);
+        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 { ping } = createIdleWatcher(() => exit(), 3000);
+
+        const output = (await sflow(tr.readable).by(fromStdio(p)).log()
+            .forEach(() => 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(p.exitCode).toBe(0); // expect the process to exit successfully
+
+        // 30 seconds timeout for this test, it usually takes 13s to run (10s for claude to solve this problem, 3s for idle watcher to exit)
+    }, 30e3);
+
+    it.skip('CLI --exit-on-idle flag with default timeout', async () => {
+        const p = exec(`node dist/cli.js "echo hello" --exit-on-idle`);
+        const tr = new TransformStream<string, string>()
+        const output = (await sflow(tr.readable).by(fromStdio(p)).log().text())
+        expect(output).toContain('hello');
+        await sleepms(1000); // wait for process exit
+        expect(p.exitCode).toBe(0);
+    }, 30e3);
+    
+    it('CLI --exit-on-idle flag with custom timeout', async () => {
+        const p = exec(`node dist/cli.js --exit-on-idle=1s "echo hello"`);
+        const tr = new TransformStream<string, string>()
+        const output = (await sflow(tr.readable).by(fromStdio(p)).log().text())
+        expect(output).toContain('hello');
+        await sleepms(1000); // wait for process exit
+        expect(p.exitCode).toBe(0);
+    }, 30e3);
+})
+

package/cli.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import ms from "enhanced-ms";
+import minimist from "minimist";
+import claudeYes from ".";
+
+// cli entry point
+const args = minimist(process.argv.slice(2), {
+    string: ['exit-on-idle'],
+    boolean: ['continue-on-crash'],
+    // boolean: ['exit-on-idle'],
+    default: {
+        'exit-on-idle': '60s',
+        'continue-on-crash': true,
+    }
+});
+
+const { 'exit-on-idle': exitOnIdleArg, 'continue-on-crash': continueOnCrashArg, ...rest } = args;
+const claudeArgs = Object.entries(rest).flatMap(([key, value]) => {
+    if (key === '_') return value as string[];
+    if (typeof value === 'boolean') return value ? [`--${key}`] : [];
+    return [`--${key}`, String(value)];
+});
+
+
+let exitOnIdle: boolean | number | undefined;
+if (typeof exitOnIdleArg === 'string') {
+    if (exitOnIdleArg === '') {
+        exitOnIdle = true; // default timeout will be used
+    } else {
+        exitOnIdle = ms(exitOnIdleArg); // parse duration string like "5s", "30s", "1m"
+    }
+} else {
+    exitOnIdle = undefined;
+}
+
+
+// console.debug('Parsed args:', {
+//     exitOnIdle,
+//     continueOnCrash: continueOnCrashArg,
+//     claudeArgs,
+// });
+
+await claudeYes({
+    exitOnIdle,
+    claudeArgs,
+    continueOnCrash: continueOnCrashArg,
+});

package/createIdleWatcher.spec.ts

@@ -0,0 +1,41 @@
+import { expect, it } from 'vitest';
+import { createIdleWatcher } from "./createIdleWatcher";
+import { sleepms } from "./utils";
+
+it('createIdleWatcher should trigger onIdle after timeout', async () => {
+    let idleTriggered = false;
+    const watcher = createIdleWatcher(() => {
+        idleTriggered = true;
+    }, 100);
+
+    watcher.ping();
+    await sleepms(150);
+    expect(idleTriggered).toBe(true);
+}, 1000);
+
+it.concurrent('createIdleWatcher should reset timeout on ping', async () => {
+    let idleTriggered = false;
+    const watcher = createIdleWatcher(() => {
+        idleTriggered = true;
+    }, 100);
+
+    watcher.ping();
+    await sleepms(50);
+    watcher.ping();
+    await sleepms(50);
+    expect(idleTriggered).toBe(false);
+    await sleepms(100);
+    expect(idleTriggered).toBe(true);
+}, 1000);
+
+it.concurrent('createIdleWatcher should update lastActiveTime on ping', async () => {
+    const watcher = createIdleWatcher(() => { }, 1000);
+
+    const initialTime = watcher.getLastActiveTime();
+    await sleepms(50);
+    watcher.ping();
+    const updatedTime = watcher.getLastActiveTime();
+
+    expect(updatedTime.getTime()).toBeGreaterThan(initialTime.getTime());
+}, 1000);
+

package/createIdleWatcher.ts

@@ -0,0 +1,18 @@
+
+export function createIdleWatcher(onIdle: () => void, idleTimeout: number): { ping: () => void; getLastActiveTime: () => Date; } {
+    let lastActiveTime = new Date();
+    let idleTimeoutId: NodeJS.Timeout | null = null;
+    return {
+        ping: () => {
+            if (idleTimeoutId) {
+                clearTimeout(idleTimeoutId);
+            }
+            idleTimeoutId = setTimeout(() => {
+                clearTimeout(idleTimeoutId!);
+                onIdle();
+            }, idleTimeout);
+            lastActiveTime = new Date();
+        },
+        getLastActiveTime: () => lastActiveTime
+    };
+}