claude-yes 1.28.0 → 1.30.0

package/ts/index.ts

@@ -1,17 +1,17 @@
+import { execaCommand, execaCommandSync, parseCommandString } from 'execa';
 import { fromReadable, fromWritable } from 'from-node-stream';
-import { appendFile, mkdir, rm, writeFile } from 'fs/promises';
+import { mkdir, writeFile } from 'fs/promises';
 import path from 'path';
 import DIE from 'phpdie';
 import sflow from 'sflow';
 import { TerminalTextRender } from 'terminal-render';
-import tsaComposer from 'tsa-composer';
 import rawConfig from '../cli-yes.config.js';
+import { catcher } from './catcher.js';
 import {
   extractSessionId,
   getSessionForCwd,
   storeSessionForCwd,
 } from './codexSessionManager.js';
-import { defineCliYesConfig } from './defineConfig.js';
 import { IdleWaiter } from './idleWaiter';
 import { ReadyManager } from './ReadyManager';
 import { removeControlCharacters } from './removeControlCharacters';
@@ -21,10 +21,11 @@ import {
   shouldUseLock,
   updateCurrentTaskStatus,
 } from './runningLock';
-import { catcher } from './tryCatch';
-import { deepMixin } from './utils';
 import { yesLog } from './yesLog';
 
+export { parseCliArgs } from './parseCliArgs';
+export { removeControlCharacters };
+
 export type AgentCliConfig = {
   install?: string; // hint user for install command if not installed
   version?: string; // hint user for version command to check if installed
@@ -36,6 +37,7 @@ export type AgentCliConfig = {
   defaultArgs?: string[]; // function to ensure certain args are present
   noEOL?: boolean; // if true, do not split lines by \n, used for codex, which uses cursor-move csi code instead of \n to move lines
   promptArg?: (string & {}) | 'first-arg' | 'last-arg'; // argument name to pass the prompt, e.g. --prompt, or first-arg for positional arg
+  bunx?: boolean; // if true, use bunx to run the binary
 };
 export type CliYesConfig = {
   clis: { [key: string]: AgentCliConfig };
@@ -91,6 +93,7 @@ export default async function cliYes({
   removeControlCharactersFromStdout = false, // = !process.stdout.isTTY,
   verbose = false,
   queue = true,
+  install = false,
 }: {
   cli: SUPPORTED_CLIS;
   cliArgs?: string[];
@@ -103,6 +106,7 @@ export default async function cliYes({
   removeControlCharactersFromStdout?: boolean;
   verbose?: boolean;
   queue?: boolean;
+  install?: boolean; // if true, install the cli tool if not installed, e.g. will run `npm install -g cursor-agent`
 }) {
   // those overrides seems only works in bun
   // await Promise.allSettled([
@@ -118,7 +122,11 @@ export default async function cliYes({
   //   });
 
   if (!cli) throw new Error(`cli is required`);
-  const conf = CLIS_CONFIG[cli] || DIE(`Unsupported cli tool: ${cli}`);
+  const conf =
+    CLIS_CONFIG[cli] ||
+    DIE(
+      `Unsupported cli tool: ${cli}, current process.argv: ${process.argv.join(' ')}`,
+    );
 
   // Acquire lock before starting agent (if in git repo or same cwd and lock is not disabled)
   const workingDir = cwd ?? process.cwd();
@@ -157,17 +165,29 @@ export default async function cliYes({
   // const pty = await import('node-pty');
 
   // its recommened to use bun-pty in windows
-  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 pty = await (globalThis.Bun
+    ? import('bun-pty')
+    : import('node-pty')
+  ).catch(async () =>
+    DIE('Please install node-pty or bun-pty, run this: bun install bun-pty'),
+  );
+
+  // Detect if running as sub-agent
+  const isSubAgent = !!process.env.CLAUDE_PPID;
+  if (isSubAgent) {
+    console.log(
+      `[${cli}-yes] Running as sub-agent (CLAUDE_PPID=${process.env.CLAUDE_PPID})`,
     );
+  }
 
   const getPtyOptions = () => ({
     name: 'xterm-color',
     ...getTerminalDimensions(),
     cwd: cwd ?? process.cwd(),
-    env: env ?? (process.env as Record<string, string>),
+    env: {
+      ...(env ?? (process.env as Record<string, string>)),
+      CLAUDE_PPID: String(process.ppid),
+    },
   });
 
   // Apply CLI specific configurations (moved to CLI_CONFIGURES)
@@ -211,34 +231,60 @@ export default async function cliYes({
   }
   const cliCommand = cliConf?.binary || cli;
 
+  const spawn = () => {
+    // const [bin, ...args] = [...parseCommandString((cliConf.bunx ? 'bunx --bun ' : '') + cliCommand), ...(cliArgs)];
+    // console.log(`Spawning ${bin} with args: ${JSON.stringify(args)}`);
+    // return pty.spawn(bin!, args, getPtyOptions());
+    return pty.spawn(cliCommand, cliArgs, getPtyOptions());
+  };
   let shell = catcher(
-    (error: unknown) => {
+    // error handler
+    (error: unknown, fn, ...args) => {
       console.error(`Fatal: Failed to start ${cliCommand}.`);
+
       if (cliConf?.install && isCommandNotFoundError(error))
+        if (install) {
+          console.log(`Attempting to install ${cli}...`);
+          execaCommandSync(cliConf.install, { stdio: 'inherit' });
+          console.log(
+            `${cli} installed successfully. Please rerun the command.`,
+          );
+          return spawn();
+        }
+      console.error(
+        `If you did not installed it yet, Please install it first: ${cliConf.install}`,
+      );
+
+      if (
+        globalThis.Bun &&
+        error instanceof Error &&
+        error.stack?.includes('bun-pty')
+      ) {
+        // try to fix bun-pty issues
         console.error(
-          `If you did not installed it yet, Please install it first: ${cliConf.install}`,
+          `Detected bun-pty issue, attempted to fix it. Please try again.`,
         );
+        require('./fix-pty.js');
+        // unable to retry with same process, so exit here.
+      }
       throw error;
 
       function isCommandNotFoundError(e: unknown) {
         if (e instanceof Error) {
           return (
-            e.message.includes('command not found') ||
-            e.message.includes('ENOENT') ||
+            e.message.includes('command not found') || // unix
+            e.message.includes('ENOENT') || // unix
             e.message.includes('spawn') // windows
           );
         }
         return false;
       }
     },
-    () => pty.spawn(cliCommand, cliArgs, getPtyOptions()),
+    spawn,
   )();
   const pendingExitCode = Promise.withResolvers<number | null>();
   let pendingExitCodeValue = null;
 
-  // TODO handle error if claude is not installed, show msg:
-  // npm install -g @anthropic-ai/claude-code
-
   async function onData(data: string) {
     // append data to the buffer, so we can process it later
     await outputWriter.write(data);
@@ -496,5 +542,3 @@ export default async function cliYes({
     };
   }
 }
-
-export { removeControlCharacters };

package/ts/parseCliArgs.ts

@@ -1,4 +1,4 @@
-import enhancedMs from 'enhanced-ms';
+import ms from 'ms';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { SUPPORTED_CLIS } from '.';
@@ -12,7 +12,7 @@ export function parseCliArgs(argv: string[]) {
   const scriptName = argv[1]?.split(/[\/\\]/).pop();
   const cliName = ((e?: string) => {
     if (e === 'cli' || e === 'cli.ts' || e === 'cli.js') return undefined;
-    return e?.replace(/-yes$/, '');
+    return e?.replace(/-yes(\.[jt]s)?$/, '');
   })(scriptName);
 
   // Parse args with yargs (same logic as cli.ts:16-73)
@@ -87,12 +87,14 @@ export function parseCliArgs(argv: string[]) {
     ? rawArgs.slice(cliArgIndex ?? 0, dashIndex ?? undefined)
     : [];
   const dashPrompt: string | undefined =
-    dashIndex !== undefined
-      ? rawArgs.slice(dashIndex + 1).join(' ')
-      : undefined;
+    dashIndex === undefined
+      ? undefined
+      : rawArgs.slice(dashIndex + 1).join(' ');
 
   // Return the config object that would be passed to cliYes (same logic as cli.ts:99-121)
   return {
+    cwd: process.cwd(),
+    env: process.env as Record<string, string>,
     cli: (cliName ||
       parsedArgv.cli ||
       parsedArgv._[0]
@@ -103,7 +105,7 @@ export function parseCliArgs(argv: string[]) {
       [parsedArgv.prompt, dashPrompt].filter(Boolean).join(' ') || undefined,
     exitOnIdle: Number(
       (parsedArgv.idle || parsedArgv.exitOnIdle)?.replace(/.*/, (e) =>
-        String(enhancedMs(e)),
+        String(ms(e as ms.StringValue)),
       ) || 0,
     ),
     queue: parsedArgv.queue,

package/ts/removeControlCharacters.spec.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+import { removeControlCharacters } from './removeControlCharacters';
+
+describe('removeControlCharacters', () => {
+  it('should remove ANSI escape sequences', () => {
+    const input = '\u001b[31mRed text\u001b[0m';
+    const expected = 'Red text';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should remove cursor positioning codes', () => {
+    const input = '\u001b[1;1HHello\u001b[2;1HWorld';
+    const expected = 'HelloWorld';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should remove color codes', () => {
+    const input = '\u001b[32mGreen\u001b[0m \u001b[31mRed\u001b[0m';
+    const expected = 'Green Red';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should remove complex ANSI sequences', () => {
+    const input = '\u001b[1;33;40mYellow on black\u001b[0m';
+    const expected = 'Yellow on black';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should handle empty string', () => {
+    expect(removeControlCharacters('')).toBe('');
+  });
+
+  it('should handle string with no control characters', () => {
+    const input = 'Plain text with no escape sequences';
+    expect(removeControlCharacters(input)).toBe(input);
+  });
+
+  it('should remove CSI sequences with multiple parameters', () => {
+    const input = '\u001b[38;5;196mBright red\u001b[0m';
+    const expected = 'Bright red';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should remove C1 control characters', () => {
+    const input = '\u009b[32mGreen text\u009b[0m';
+    const expected = 'Green text';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should handle mixed control and regular characters', () => {
+    const input =
+      'Start\u001b[1mBold\u001b[0mMiddle\u001b[4mUnderline\u001b[0mEnd';
+    const expected = 'StartBoldMiddleUnderlineEnd';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should preserve spaces and newlines', () => {
+    const input = 'Line 1\u001b[31m\nRed Line 2\u001b[0m\n\nLine 4';
+    const expected = 'Line 1\nRed Line 2\n\nLine 4';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should handle cursor movement sequences', () => {
+    const input = '\u001b[2AUp\u001b[3BDown\u001b[4CRight\u001b[5DLeft';
+    const expected = 'UpDownRightLeft';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should handle erase sequences', () => {
+    const input = 'Text\u001b[2JClear\u001b[KLine';
+    const expected = 'TextClearLine';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+});

package/ts/utils.spec.ts

@@ -0,0 +1,169 @@
+import { describe, expect, it } from 'vitest';
+import { type DeepPartial, deepMixin, sleepms } from './utils';
+
+describe('utils', () => {
+  describe('sleepms', () => {
+    it('should return a promise', () => {
+      const result = sleepms(100);
+      expect(result).toBeInstanceOf(Promise);
+    });
+
+    it('should resolve after some time', async () => {
+      const start = Date.now();
+      await sleepms(10);
+      const end = Date.now();
+      expect(end - start).toBeGreaterThanOrEqual(5); // Allow some margin
+    });
+
+    it('should handle zero milliseconds', async () => {
+      const start = Date.now();
+      await sleepms(0);
+      const end = Date.now();
+      expect(end - start).toBeLessThan(50); // Should be quick
+    });
+  });
+
+  describe('deepMixin', () => {
+    it('should merge simple properties', () => {
+      const target = { a: 1, b: 2 };
+      const source = { b: 3, c: 4 };
+      const result = deepMixin(target, source);
+
+      expect(result).toEqual({ a: 1, b: 3, c: 4 });
+      expect(result).toBe(target); // Should modify original object
+    });
+
+    it('should merge nested objects', () => {
+      const target = {
+        user: { name: 'John', age: 30 },
+        settings: { theme: 'dark' },
+      };
+      const source: DeepPartial<typeof target> = {
+        user: { age: 31 },
+        settings: { language: 'en' } as any,
+      };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({
+        user: { name: 'John', age: 31 },
+        settings: { theme: 'dark', language: 'en' },
+      });
+    });
+
+    it('should create nested objects when target property is null', () => {
+      const target: any = { config: null };
+      const source = { config: { enabled: true } };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({
+        config: { enabled: true },
+      });
+    });
+
+    it('should create nested objects when target property is primitive', () => {
+      const target: any = { config: 'string' };
+      const source = { config: { enabled: true } };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({
+        config: { enabled: true },
+      });
+    });
+
+    it('should handle arrays by replacing them', () => {
+      const target = { items: [1, 2, 3] };
+      const source = { items: [4, 5] };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({ items: [4, 5] });
+    });
+
+    it('should ignore undefined values', () => {
+      const target = { a: 1, b: 2 };
+      const source = { a: undefined, c: 3 };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    it('should handle null values', () => {
+      const target = { a: 1, b: 2 };
+      const source = { a: null, c: 3 };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({ a: null, b: 2, c: 3 });
+    });
+
+    it('should handle deeply nested structures', () => {
+      const target = {
+        level1: {
+          level2: {
+            level3: { value: 'old' },
+          },
+        },
+      };
+      const source = {
+        level1: {
+          level2: {
+            level3: { value: 'new', extra: 'added' },
+          },
+        },
+      };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({
+        level1: {
+          level2: {
+            level3: { value: 'new', extra: 'added' },
+          },
+        },
+      });
+    });
+
+    it('should handle empty objects', () => {
+      const target = {};
+      const source = {};
+
+      const result = deepMixin(target, source);
+
+      expect(result).toEqual({});
+      expect(result).toBe(target);
+    });
+
+    it('should handle complex mixed types', () => {
+      const target: any = {
+        string: 'value',
+        number: 42,
+        boolean: true,
+        object: { nested: 'value' },
+        array: [1, 2, 3],
+      };
+      const source: any = {
+        string: 'new value',
+        number: 100,
+        boolean: false,
+        object: { nested: 'new value', added: 'property' },
+        array: [4, 5],
+        newProp: 'added',
+      };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({
+        string: 'new value',
+        number: 100,
+        boolean: false,
+        object: { nested: 'new value', added: 'property' },
+        array: [4, 5],
+        newProp: 'added',
+      });
+    });
+  });
+});

package/ts/yesLog.spec.ts

@@ -0,0 +1,74 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+describe('yesLog', () => {
+  const originalVerbose = process.env.VERBOSE;
+
+  beforeEach(() => {
+    // Reset modules to ensure fresh state
+    delete require.cache[require.resolve('./yesLog')];
+  });
+
+  afterEach(() => {
+    // Restore original VERBOSE setting
+    if (originalVerbose !== undefined) {
+      process.env.VERBOSE = originalVerbose;
+    } else {
+      delete process.env.VERBOSE;
+    }
+  });
+
+  it('should not crash when VERBOSE is not set', async () => {
+    delete process.env.VERBOSE;
+
+    const { yesLog } = await import('./yesLog');
+
+    // Should not throw and returns undefined
+    const result = yesLog`Test message`;
+    expect(result).toBeUndefined();
+  });
+
+  it('should be callable with template literals', async () => {
+    delete process.env.VERBOSE;
+
+    const { yesLog } = await import('./yesLog');
+
+    // Should not throw with variables
+    const variable = 'test value';
+    const result = yesLog`Message with ${variable}`;
+    expect(result).toBeUndefined();
+  });
+
+  it('should handle multiple calls', async () => {
+    delete process.env.VERBOSE;
+
+    const { yesLog } = await import('./yesLog');
+
+    // Multiple calls should not throw
+    expect(yesLog`First message`).toBeUndefined();
+    expect(yesLog`Second message`).toBeUndefined();
+    expect(yesLog`Third message`).toBeUndefined();
+  });
+
+  it('should work when VERBOSE is set', async () => {
+    process.env.VERBOSE = '1';
+
+    const { yesLog } = await import('./yesLog');
+
+    // Should not throw even when verbose
+    expect(yesLog`Verbose message`).toBeUndefined();
+  });
+
+  it('should handle template literals with different types', async () => {
+    delete process.env.VERBOSE;
+
+    const { yesLog } = await import('./yesLog');
+
+    const number = 42;
+    const object = { key: 'value' };
+    const array = [1, 2, 3];
+
+    expect(yesLog`Number: ${number}`).toBeUndefined();
+    expect(yesLog`Object: ${object}`).toBeUndefined();
+    expect(yesLog`Array: ${array}`).toBeUndefined();
+  });
+});

package/ts/yesLog.ts

@@ -1,6 +1,6 @@
 import { appendFileSync, rmSync } from 'node:fs';
 import tsaComposer from 'tsa-composer';
-import { catcher } from './tryCatch';
+import { catcher } from './catcher';
 
 let initial = true;
 

package/ts/tryCatch.ts

@@ -1,25 +0,0 @@
-// 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);
-    }
-  };
-}