claude-yes 1.29.2 → 1.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-yes",
-  "version": "1.29.2",
+  "version": "1.30.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "claude",
@@ -50,13 +50,15 @@
   },
   "files": [
     "ts/*.ts",
-    "dist"
+    "dist",
+    "scripts"
   ],
   "scripts": {
     "build": "bun run build:index && bun run build:cli",
     "postbuild": "bun ./ts/postbuild.ts",
-    "build:cli": "bun build ts/cli.ts --outdir=dist --target=node --sourcemap --external=node-pty --external=bun-pty --external=from-node-stream",
-    "build:index": "bun build ts/index.ts --outdir=dist --target=node --sourcemap --external=node-pty --external=bun-pty --external=from-node-stream",
+    "build:cli": "bun build ts/cli.ts --outdir=dist --target=node --sourcemap --external=bun-pty --external=node-pty --external=from-node-stream --external=bun",
+    "build:index": "bun build ts/index.ts --outdir=dist --target=node --sourcemap --external=bun-pty --external=node-pty --external=from-node-stream --external=bun",
+    "demo": "bun run build && bun link && claude-yes -- demo",
     "dev": "bun ts/index.ts",
     "fmt": "bunx @biomejs/biome check --fix && bunx sort-package-json",
     "prepack": "bun run build",
@@ -89,8 +91,11 @@
     ]
   },
   "dependencies": {
+    "@types/ms": "^2.1.0",
+    "bun": "^1.3.1",
     "bun-pty": "^0.3.2",
-    "from-node-stream": "^0.0.11"
+    "from-node-stream": "^0.0.11",
+    "ms": "^2.1.3"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.2.5",
@@ -103,7 +108,6 @@
     "@types/node": "^24.0.10",
     "@types/yargs": "^17.0.33",
     "cpu-wait": "^0.0.10",
-    "enhanced-ms": "^4.1.0",
     "execa": "^9.6.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.1.4",
@@ -119,7 +123,7 @@
     "yargs": "^18.0.0"
   },
   "peerDependencies": {
-    "node-pty": "^1.0.0",
+    "node-pty": "^1.1.0-beta38",
     "typescript": "^5.8.3"
   }
 }

package/ts/{tryCatch.spec.ts → catcher.spec.ts}

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
-import { catcher } from './tryCatch';
+import { catcher } from './catcher';
 
-describe('tryCatch', () => {
+describe('catcher', () => {
   describe('curried overload', () => {
     it('should return a function when called with only catchFn', () => {
       const catchFn = () => 'error';
@@ -9,10 +9,14 @@ describe('tryCatch', () => {
       expect(typeof result).toBe('function');
     });
 
-    it('should catch errors and call catchFn', () => {
+    it('should catch errors and call catchFn with error, function, and args', () => {
       let catchedError: unknown;
-      const catchFn = (error: unknown) => {
+      let catchedFn: unknown;
+      let catchedArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
         catchedError = error;
+        catchedFn = fn;
+        catchedArgs = args;
         return 'caught';
       };
 
@@ -27,6 +31,8 @@ describe('tryCatch', () => {
 
       expect(result).toBe('caught');
       expect(catchedError).toBeInstanceOf(Error);
+      expect(catchedFn).toBe(errorFn);
+      expect(catchedArgs).toEqual(['arg1', 'arg2']);
       expect(calledArgs).toEqual(['arg1', 'arg2']);
     });
 
@@ -53,10 +59,14 @@ describe('tryCatch', () => {
   });
 
   describe('direct overload', () => {
-    it('should catch errors and call catchFn directly', () => {
+    it('should catch errors and call catchFn with error, function, and args directly', () => {
       let catchedError: unknown;
-      const catchFn = (error: unknown) => {
+      let catchedFn: unknown;
+      let catchedArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
         catchedError = error;
+        catchedFn = fn;
+        catchedArgs = args;
         return 'caught';
       };
 
@@ -71,6 +81,8 @@ describe('tryCatch', () => {
 
       expect(result).toBe('caught');
       expect(catchedError).toBeInstanceOf(Error);
+      expect(catchedFn).toBe(errorFn);
+      expect(catchedArgs).toEqual(['arg1', 'arg2']);
       expect(calledArgs).toEqual(['arg1', 'arg2']);
     });
 
@@ -97,40 +109,52 @@ describe('tryCatch', () => {
   });
 
   describe('error handling', () => {
-    it('should handle different error types', () => {
+    it('should handle different error types and pass function context', () => {
       const results: unknown[] = [];
-      const catchFn = (error: unknown) => {
+      const functions: unknown[] = [];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
         results.push(error);
+        functions.push(fn);
         return 'handled';
       };
 
       // String error
-      const stringErrorFn = catcher(catchFn, () => {
+      const stringErrorFn = () => {
         throw 'string error';
-      });
-      expect(stringErrorFn()).toBe('handled');
+      };
+      const wrappedStringFn = catcher(catchFn, stringErrorFn);
+      expect(wrappedStringFn()).toBe('handled');
       expect(results[0]).toBe('string error');
+      expect(functions[0]).toBe(stringErrorFn);
 
       // Object error
       const objectError = { message: 'object error' };
-      const objectErrorFn = catcher(catchFn, () => {
+      const objectErrorFn = () => {
         throw objectError;
-      });
-      expect(objectErrorFn()).toBe('handled');
+      };
+      const wrappedObjectFn = catcher(catchFn, objectErrorFn);
+      expect(wrappedObjectFn()).toBe('handled');
       expect(results[1]).toBe(objectError);
+      expect(functions[1]).toBe(objectErrorFn);
 
       // null error
-      const nullErrorFn = catcher(catchFn, () => {
+      const nullErrorFn = () => {
         throw null;
-      });
-      expect(nullErrorFn()).toBe('handled');
+      };
+      const wrappedNullFn = catcher(catchFn, nullErrorFn);
+      expect(wrappedNullFn()).toBe('handled');
       expect(results[2]).toBe(null);
+      expect(functions[2]).toBe(nullErrorFn);
     });
 
-    it('should preserve function parameters', () => {
+    it('should preserve function parameters and pass them to catchFn', () => {
       let caughtError: unknown;
-      const catchFn = (error: unknown) => {
+      let caughtFn: unknown;
+      let caughtArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
         caughtError = error;
+        caughtFn = fn;
+        caughtArgs = args;
         return 'caught';
       };
 
@@ -151,12 +175,18 @@ describe('tryCatch', () => {
       expect(wrappedFn(10, 'error', false)).toBe('caught');
       expect(testArgs).toEqual([10, 'error', false]);
       expect(caughtError).toBeInstanceOf(Error);
+      expect(caughtFn).toBe(testFn);
+      expect(caughtArgs).toEqual([10, 'error', false]);
     });
 
     it('should handle functions with no parameters', () => {
       let caughtError: unknown;
-      const catchFn = (error: unknown) => {
+      let caughtFn: unknown;
+      let caughtArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
         caughtError = error;
+        caughtFn = fn;
+        caughtArgs = args;
         return 'no params caught';
       };
 
@@ -172,6 +202,8 @@ describe('tryCatch', () => {
       expect(result).toBe('no params caught');
       expect(called).toBe(true);
       expect(caughtError).toBeInstanceOf(Error);
+      expect(caughtFn).toBe(noParamsFn);
+      expect(caughtArgs).toEqual([]);
     });
 
     it('should handle functions returning different types', () => {
@@ -194,7 +226,8 @@ describe('tryCatch', () => {
 
   describe('type safety', () => {
     it('should maintain function signature', () => {
-      const catchFn = (error: unknown) => 'error';
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) =>
+        'error';
       const originalFn = (a: number, b: string): string => `${a}-${b}`;
 
       const wrappedFn = catcher(catchFn, originalFn);
@@ -203,5 +236,25 @@ describe('tryCatch', () => {
       const result: string = wrappedFn(1, 'test');
       expect(result).toBe('1-test');
     });
+
+    it('should pass function reference and arguments to catchFn', () => {
+      let capturedFn: unknown;
+      let capturedArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+        capturedFn = fn;
+        capturedArgs = args;
+        return 'handled';
+      };
+
+      const testFn = (x: number, y: string) => {
+        throw new Error('test');
+      };
+
+      const wrappedFn = catcher(catchFn, testFn);
+      wrappedFn(42, 'hello');
+
+      expect(capturedFn).toBe(testFn);
+      expect(capturedArgs).toEqual([42, 'hello']);
+    });
   });
 });

package/ts/catcher.ts

@@ -0,0 +1,35 @@
+// curried overload
+export function catcher<F extends (...args: any[]) => any, R>(
+  catchFn: (error: unknown, fn: F, ...args: Parameters<F>) => R,
+): (fn: F) => (...args: Parameters<F>) => ReturnType<F> | R;
+
+// direct overload
+export function catcher<F extends (...args: any[]) => any, R>(
+  catchFn: (error: unknown, fn: F, ...args: Parameters<F>) => R,
+  fn: F,
+): (...args: Parameters<F>) => ReturnType<F> | R;
+
+/**
+ * A utility function to wrap another function with a try-catch block.
+ * If an error occurs during the execution of the function, the provided
+ * catchFn is called with the error, the original function, and its arguments.
+ *
+ * This function supports both direct invocation and curried usage.
+ *
+ * @param catchFn - The function to call when an error occurs.
+ * @param fn - The function to wrap (optional for curried usage).
+ * @returns A new function that wraps the original function with error handling.
+ */
+export function catcher<F extends (...args: any[]) => any, R>(
+  catchFn: (error: unknown, fn: F, ...args: Parameters<F>) => 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, fn, ...args);
+    }
+  };
+}

package/ts/cli.ts

@@ -1,14 +1,34 @@
 #!/usr/bin/env node
 import DIE from 'phpdie';
-import cliYes, { parseCliArgs } from './';
+import cliYesConfig from '../cli-yes.config';
 
-// if (!globalThis.Bun) // run with same arguments in Bun
+// if node-pty is not installed, re-run with bun
+// const hasNodePty = !!await import('node-pty').catch(() => null);
+if (!globalThis.Bun) {
+  // run with same arguments in Bun if not already
+  console.log('Re-running with Bun...', process.argv);
+  (await import('child_process')).spawnSync(
+    'node_modules/.bin/bun',
+    [process.argv[1]!, '--', ...process.argv.slice(2)],
+    { stdio: 'inherit' },
+  );
+  process.exit(0);
+}
+// check and fix bun-pty on some systems
+if (globalThis.Bun) console.log('Bun detected, using bun-pty');
+//   await import("./fix-pty.js")
+
+// console.log('Running', process.argv);
+
+// Import the CLI module
+const { default: cliYes, parseCliArgs } = await import('./');
 
 // Parse CLI arguments
 const config = parseCliArgs(process.argv);
 
 // Validate CLI name
-if (!config.cli) DIE('missing cli def');
+if (!config.cli)
+  DIE`missing cli def, available clis: ${Object.keys((await cliYesConfig).clis).join(', ')}`;
 
 if (config.verbose) {
   process.env.VERBOSE = 'true'; // enable verbose logging in yesLog.ts

package/ts/index.ts

@@ -1,3 +1,4 @@
+import { execaCommand, execaCommandSync, parseCommandString } from 'execa';
 import { fromReadable, fromWritable } from 'from-node-stream';
 import { mkdir, writeFile } from 'fs/promises';
 import path from 'path';
@@ -5,6 +6,7 @@ import DIE from 'phpdie';
 import sflow from 'sflow';
 import { TerminalTextRender } from 'terminal-render';
 import rawConfig from '../cli-yes.config.js';
+import { catcher } from './catcher.js';
 import {
   extractSessionId,
   getSessionForCwd,
@@ -19,7 +21,6 @@ import {
   shouldUseLock,
   updateCurrentTaskStatus,
 } from './runningLock';
-import { catcher } from './tryCatch';
 import { yesLog } from './yesLog';
 
 export { parseCliArgs } from './parseCliArgs';
@@ -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,12 +165,12 @@ export default async function cliYes({
   // const pty = await import('node-pty');
 
   // its recommened to use bun-pty in windows
-  const pty = await (globalThis.Bun ? import('bun-pty') : import('node-pty'))
-    // .catch(async () => await import('node-pty'))
-    .catch(async () =>
-      DIE('Please install node-pty or bun-pty, run this: bun install bun-pty'),
-    );
-  console.log(globalThis.Bun);
+  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;
@@ -223,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);

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)
@@ -105,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/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);
-    }
-  };
-}