claude-yes 1.14.2 → 1.15.1

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

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

package/cli.ts

@@ -1,47 +1,47 @@
 #!/usr/bin/env node
-import ms from "enhanced-ms";
-import minimist from "minimist";
-import claudeYes from ".";
+import ms from 'enhanced-ms';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+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 argv = yargs(hideBin(process.argv))
+  .usage('Usage: $0 [options] [--] [claude args]')
+  .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('exit-on-idle', {
+    type: 'string',
+    default: '60s',
+    description: 'Exit after being idle for specified duration',
+  })
+  .option('continue-on-crash', {
+    type: 'boolean',
+    default: true,
+    description: 'Continue running even if Claude crashes',
+  })
+  .option('log-file', {
+    type: 'string',
+    description: 'Path to log file for output logging',
+  })
+  .option('verbose', {
+    type: 'boolean',
+    default: false,
+    description: 'Enable verbose logging',
+  })
+  .parserConfiguration({
+    'unknown-options-as-args': true,
+    'halt-at-non-option': true,
+  })
+  .parseSync();
 
-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)];
+const { exitCode, logs } = await claudeYes({
+  exitOnIdle: argv.exitOnIdle != null ? ms(argv.exitOnIdle) : undefined,
+  claudeArgs: argv._.map((e) => String(e)),
+  continueOnCrash: argv.continueOnCrash,
+  logFile: argv.logFile,
+  verbose: argv.verbose,
 });
 
-
-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,
-});
+process.exit(exitCode ?? 1);

package/createIdleWatcher.ts

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