claude-yes 1.24.2 → 1.26.0

package/ts/parseCliArgs.spec.ts

@@ -0,0 +1,220 @@
+import { describe, expect, it } from 'vitest';
+import { parseCliArgs } from './parseCliArgs';
+
+describe('CLI argument parsing', () => {
+  it('should parse cli name from first positional argument', () => {
+    const result = parseCliArgs(['node', '/path/to/cli', 'claude']);
+
+    expect(result.cli).toBe('claude');
+  });
+
+  it('should parse prompt from --prompt flag', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--prompt',
+      'hello world',
+      'claude',
+    ]);
+
+    expect(result.prompt).toBe('hello world');
+  });
+
+  it('should parse prompt from -- separator', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      'claude',
+      '--',
+      'hello',
+      'world',
+    ]);
+
+    expect(result.prompt).toBe('hello world');
+  });
+
+  it('should combine --prompt and -- prompt', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--prompt',
+      'part1',
+      'claude',
+      '--',
+      'part2',
+    ]);
+
+    expect(result.prompt).toBe('part1 part2');
+  });
+
+  it('should parse --idle flag', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--idle',
+      '30s',
+      'claude',
+    ]);
+
+    expect(result.exitOnIdle).toBe(30000);
+  });
+
+  it('should parse --exit-on-idle flag (deprecated)', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--exit-on-idle',
+      '1m',
+      'claude',
+    ]);
+
+    expect(result.exitOnIdle).toBe(60000);
+  });
+
+  it('should parse --robust flag', () => {
+    const result = parseCliArgs(['node', '/path/to/cli', '--robust', 'claude']);
+
+    expect(result.robust).toBe(true);
+  });
+
+  it('should parse --no-robust flag', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--no-robust',
+      'claude',
+    ]);
+
+    expect(result.robust).toBe(false);
+  });
+
+  it('should parse --queue flag', () => {
+    const result = parseCliArgs(['node', '/path/to/cli', '--queue', 'claude']);
+
+    expect(result.queue).toBe(true);
+  });
+
+  it('should parse --no-queue flag', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--no-queue',
+      'claude',
+    ]);
+
+    expect(result.queue).toBe(false);
+  });
+
+  it('should parse --logFile flag', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--logFile',
+      './output.log',
+      'claude',
+    ]);
+
+    expect(result.logFile).toBe('./output.log');
+  });
+
+  it('should parse --verbose flag', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--verbose',
+      'claude',
+    ]);
+
+    expect(result.verbose).toBe(true);
+  });
+
+  it('should pass through unknown CLI args to cliArgs', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      'claude',
+      '--unknown-flag',
+      'value',
+    ]);
+
+    expect(result.cliArgs).toContain('--unknown-flag');
+    expect(result.cliArgs).toContain('value');
+  });
+
+  it('should separate cli-yes args from cli args before --', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--robust',
+      'claude',
+      '--claude-arg',
+      '--',
+      'prompt',
+    ]);
+
+    expect(result.cli).toBe('claude');
+    expect(result.robust).toBe(true);
+    expect(result.cliArgs).toContain('--claude-arg');
+    expect(result.prompt).toBe('prompt');
+  });
+
+  it('should detect cli name from script name (claude-yes)', () => {
+    const result = parseCliArgs([
+      '/usr/bin/node',
+      '/usr/local/bin/claude-yes',
+      '--prompt',
+      'test',
+    ]);
+
+    expect(result.cli).toBe('claude');
+  });
+
+  it('should detect cli name from script name (codex-yes)', () => {
+    const result = parseCliArgs([
+      '/usr/bin/node',
+      '/usr/local/bin/codex-yes',
+      '--prompt',
+      'test',
+    ]);
+
+    expect(result.cli).toBe('codex');
+  });
+
+  it('should prefer script name over explicit cli argument', () => {
+    const result = parseCliArgs([
+      '/usr/bin/node',
+      '/usr/local/bin/claude-yes',
+      '--prompt',
+      'test',
+      'gemini',
+    ]);
+
+    // cliName (from script) takes precedence over positional arg
+    expect(result.cli).toBe('claude');
+  });
+
+  it('should handle empty cliArgs when no positional cli is provided', () => {
+    const result = parseCliArgs([
+      '/usr/bin/node',
+      '/usr/local/bin/claude-yes',
+      '--prompt',
+      'prompt',
+    ]);
+
+    expect(result.cliArgs).toEqual([]);
+    expect(result.prompt).toBe('prompt');
+  });
+
+  it('should include all args when no -- separator is present', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      'claude',
+      '--some-flag',
+      '--another-flag',
+    ]);
+
+    expect(result.cliArgs).toContain('--some-flag');
+    expect(result.cliArgs).toContain('--another-flag');
+  });
+});

package/ts/parseCliArgs.ts

@@ -0,0 +1,111 @@
+import enhancedMs from 'enhanced-ms';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { SUPPORTED_CLIS } from '.';
+
+/**
+ * Parse CLI arguments the same way cli.ts does
+ * This is a test helper that mirrors the parsing logic in cli.ts
+ */
+export function parseCliArgs(argv: string[]) {
+  // Detect cli name from script name (same logic as cli.ts:10-14)
+  const cliName = ((e?: string) => {
+    if (e === 'cli' || e === 'cli.ts') return undefined;
+    return e;
+  })(argv[1]?.split('/').pop()?.split('-')[0]);
+
+  // Parse args with yargs (same logic as cli.ts:16-73)
+  const parsedArgv = yargs(hideBin(argv))
+    .usage('Usage: $0 [cli] [cli-yes args] [agent-cli args] [--] [prompts...]')
+    .example(
+      '$0 claude --idle=30s -- solve all todos in my codebase, commit one by one',
+      'Run Claude with a 30 seconds idle timeout, and the prompt is everything after `--`',
+    )
+    .option('robust', {
+      type: 'boolean',
+      default: true,
+      description:
+        're-spawn Claude with --continue if it crashes, only works for claude yet',
+      alias: 'r',
+    })
+    .option('logFile', {
+      type: 'string',
+      description: 'Rendered log file to write to.',
+    })
+    .option('prompt', {
+      type: 'string',
+      description: 'Prompt to send to Claude (also can be passed after --)',
+      alias: 'p',
+    })
+    .option('verbose', {
+      type: 'boolean',
+      description: 'Enable verbose logging, will emit ./agent-yes.log',
+      default: false,
+    })
+    .option('exit-on-idle', {
+      type: 'string',
+      description: 'Exit after a period of inactivity, e.g., "5s" or "1m"',
+      deprecated: 'use --idle instead',
+      default: '60s',
+      alias: 'e',
+    })
+    .option('idle', {
+      type: 'string',
+      description: 'Exit after a period of inactivity, e.g., "5s" or "1m"',
+      alias: 'i',
+    })
+    .option('queue', {
+      type: 'boolean',
+      description:
+        'Queue Agent when spawning multiple agents in the same directory/repo, can be disabled with --no-queue',
+      default: true,
+    })
+    .positional('cli', {
+      describe:
+        'The AI CLI to run, e.g., claude, codex, copilot, cursor, gemini',
+      type: 'string',
+      choices: SUPPORTED_CLIS,
+      demandOption: false,
+      default: cliName,
+    })
+    .help()
+    .version()
+    .parserConfiguration({
+      'unknown-options-as-args': true,
+      'halt-at-non-option': true,
+    })
+    .parseSync();
+
+  // Extract cli args and dash prompt (same logic as cli.ts:76-91)
+  const optionalIndex = (e: number) => (0 <= e ? e : undefined);
+  const rawArgs = argv.slice(2);
+  const cliArgIndex = optionalIndex(rawArgs.indexOf(String(parsedArgv._[0])));
+  const dashIndex = optionalIndex(rawArgs.indexOf('--'));
+
+  const cliArgsForSpawn = parsedArgv._[0]
+    ? rawArgs.slice(cliArgIndex ?? 0, dashIndex ?? undefined)
+    : [];
+  const dashPrompt: string | undefined = dashIndex
+    ? rawArgs.slice(dashIndex + 1).join(' ')
+    : undefined;
+
+  // Return the config object that would be passed to cliYes (same logic as cli.ts:99-121)
+  return {
+    cli: (cliName ||
+      parsedArgv.cli ||
+      parsedArgv._[0]
+        ?.toString()
+        ?.replace?.(/-yes$/, '')) as (typeof SUPPORTED_CLIS)[number],
+    cliArgs: cliArgsForSpawn,
+    prompt: [parsedArgv.prompt, dashPrompt].join(' ').trim() || undefined,
+    exitOnIdle: Number(
+      (parsedArgv.idle || parsedArgv.exitOnIdle)?.replace(/.*/, (e) =>
+        String(enhancedMs(e)),
+      ) || 0,
+    ),
+    queue: parsedArgv.queue,
+    robust: parsedArgv.robust,
+    logFile: parsedArgv.logFile,
+    verbose: parsedArgv.verbose,
+  };
+}

package/ts/postbuild.ts

@@ -2,15 +2,17 @@
 import { execaCommand } from 'execa';
 import { copyFile } from 'fs/promises';
 import * as pkg from '../package.json';
-import { CLI_CONFIGURES } from '.';
+import { CLIS_CONFIG } from '.';
 
 const src = 'dist/cli.js';
 await Promise.all(
-  Object.keys(CLI_CONFIGURES).map(async (cli) => {
+  Object.keys(CLIS_CONFIG).map(async (cli) => {
     const dst = `dist/${cli}-yes.js`;
-    if (!pkg.bin?.[cli as keyof typeof pkg.bin])
+    if (!(pkg.bin as Record<string, string>)?.[`${cli}-yes`]) {
+      console.log(`package.json Updated bin.${cli}-yes = ${dst}`);
       await execaCommand(`npm pkg set bin.${cli}-yes=${dst}`);
+    }
     await copyFile(src, dst);
-    console.log(`Created ${dst}`);
+    console.log(`${dst} Updated`);
   }),
 );

package/ts/runningLock.spec.ts

@@ -133,14 +133,21 @@ describe('runningLock', () => {
     });
 
     it('should not have gitRoot for non-git directory', async () => {
-      // /tmp is typically not a git repository
-      await acquireLock('/tmp', 'Non-git task');
+      // Create a temporary directory outside of any git repo
+      const tempDir = path.join('/tmp', 'test-non-git-' + Date.now());
+      await mkdir(tempDir, { recursive: true });
 
-      const lockData = await readLockFile();
-      expect(lockData.tasks[0].gitRoot).toBeUndefined();
-      expect(lockData.tasks[0].cwd).toBe('/tmp');
+      try {
+        await acquireLock(tempDir, 'Non-git task');
 
-      await releaseLock();
+        const lockData = await readLockFile();
+        expect(lockData.tasks[0].gitRoot).toBeUndefined();
+        expect(lockData.tasks[0].cwd).toBe(path.resolve(tempDir));
+
+        await releaseLock();
+      } finally {
+        await rm(tempDir, { recursive: true, force: true });
+      }
     });
   });
 
@@ -247,31 +254,27 @@ describe('runningLock', () => {
 
   describe('concurrent access', () => {
     it('should handle multiple tasks from different processes', async () => {
-      // Simulate multiple processes by using different PIDs in the lock file
+      // Acquire first task
       await acquireLock(TEST_DIR, 'Task 1');
 
-      // Manually add another task with our PID + 1 (simulating another process)
-      const lockData = await readLockFile();
-      lockData.tasks.push({
-        cwd: '/tmp',
-        task: 'Task 2',
-        pid: process.pid + 1,
-        status: 'running',
-        startedAt: Date.now(),
-        lockedAt: Date.now(),
-      });
-      await writeFile(LOCK_FILE, JSON.stringify(lockData, null, 2));
+      // Verify the task exists
+      let lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].task).toBe('Task 1');
 
-      // Read and verify both tasks exist
-      const updatedLockData = await readLockFile();
-      expect(updatedLockData.tasks).toHaveLength(2);
+      // Acquire a second task with the same PID (should replace the first)
+      await acquireLock('/tmp', 'Task 2');
+
+      // Should have only one task (the latest one)
+      lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].task).toBe('Task 2');
 
       await releaseLock();
 
-      // After release, only the "other process" task should remain
+      // After release, no tasks should remain
       const finalLockData = await readLockFile();
-      expect(finalLockData.tasks).toHaveLength(1);
-      expect(finalLockData.tasks[0].pid).toBe(process.pid + 1);
+      expect(finalLockData.tasks).toHaveLength(0);
     });
 
     it('should not duplicate tasks with same PID', async () => {
@@ -411,13 +414,16 @@ describe('runningLock', () => {
     });
 
     it('should allow different directories without git repos', async () => {
-      // Create lock for /tmp
+      // Test that when we already have a task, acquiring a new one replaces it
+      // (since both use the same PID)
+
+      // Create lock for /tmp manually
       const lock = {
         tasks: [
           {
             cwd: '/tmp',
             task: 'Tmp task',
-            pid: process.pid + 1,
+            pid: process.pid,
             status: 'running' as const,
             startedAt: Date.now(),
             lockedAt: Date.now(),
@@ -426,12 +432,18 @@ describe('runningLock', () => {
       };
       await writeFile(LOCK_FILE, JSON.stringify(lock, null, 2));
 
-      // Acquire lock for different directory
+      // Verify initial state
+      let lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].task).toBe('Tmp task');
+
+      // Acquire lock for different directory (should replace the existing task)
       await acquireLock(TEST_DIR, 'Test task');
 
-      // Both should coexist
-      const lockData = await readLockFile();
-      expect(lockData.tasks).toHaveLength(2);
+      // Should only have the new task
+      lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].task).toBe('Test task');
 
       await releaseLock();
     });
@@ -470,7 +482,9 @@ async function cleanupLockFile() {
 async function readLockFile(): Promise<{ tasks: Task[] }> {
   try {
     const content = await readFile(LOCK_FILE, 'utf8');
-    return JSON.parse(content);
+    const lockFile = JSON.parse(content);
+    // Don't clean stale locks in tests - we want to see the raw data
+    return lockFile;
   } catch {
     return { tasks: [] };
   }

package/ts/tryCatch.ts

@@ -0,0 +1,25 @@
+// curried overload
+export function catcher<F extends (...args: any[]) => any, R>(
+  catchFn: (error: unknown) => R,
+): (fn: F) => (...args: Parameters<F>) => ReturnType<F> | R;
+
+// direct overload
+export function catcher<F extends (...args: any[]) => any, R>(
+  catchFn: (error: unknown) => R,
+  fn: F,
+): (...args: Parameters<F>) => ReturnType<F> | R;
+
+// implementation
+export function catcher<F extends (...args: any[]) => any, R>(
+  catchFn: (error: unknown) => R,
+  fn?: F,
+) {
+  if (!fn) return (fn: F) => catcher(catchFn, fn) as any;
+  return (...args: Parameters<F>) => {
+    try {
+      return fn(...args);
+    } catch (error) {
+      return catchFn(error);
+    }
+  };
+}

package/ts/utils.ts

@@ -1,3 +1,23 @@
 export function sleepms(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+export function deepMixin<T>(target: T, source: DeepPartial<T>): T {
+  for (const key in source) {
+    if (
+      source[key] &&
+      typeof source[key] === 'object' &&
+      !Array.isArray(source[key])
+    ) {
+      if (!target[key] || typeof target[key] !== 'object') {
+        (target as any)[key] = {};
+      }
+      deepMixin(target[key], source[key] as any);
+    } else if (source[key] !== undefined) {
+      (target as any)[key] = source[key];
+    }
+  }
+  return target;
+}
+export type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};

package/ts/yesLog.ts

@@ -0,0 +1,27 @@
+import { appendFileSync, rmSync } from 'node:fs';
+import tsaComposer from 'tsa-composer';
+import { catcher } from './tryCatch';
+
+let initial = true;
+
+/**
+ * Log messages to agent-yes.log file
+ * Each message is appended as a new line
+ * The log file is cleared on the first call
+ *
+ * use only for debug, enabled when process.env.VERBOSE is set
+ */
+export const yesLog = tsaComposer()(
+  catcher(
+    (error) => {
+      console.error('yesLog error:', error);
+    },
+    function yesLog(msg: string) {
+      // process.stdout.write(`${msg}\r`); // touch process to avoid "The process is not running a TTY." error
+      if (!process.env.VERBOSE) return; // no-op if not verbose
+      if (initial) rmSync('./agent-yes.log'); // ignore error if file doesn't exist
+      initial = false;
+      appendFileSync('./agent-yes.log', `${msg}\n`);
+    },
+  ),
+);

package/ts/cli.test.ts

@@ -1,63 +0,0 @@
-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);