agent-yes 1.31.41

package/dist/qwen-yes.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+await import('./cli.js')

package/package.json

@@ -0,0 +1,145 @@
+{
+  "name": "agent-yes",
+  "version": "1.31.41",
+  "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
+  "keywords": [
+    "ai",
+    "anthropic",
+    "assistant",
+    "auto-response",
+    "automation",
+    "claude",
+    "cli",
+    "codex",
+    "copilot",
+    "cursor",
+    "gemini",
+    "grok",
+    "qwen",
+    "wrapper"
+  ],
+  "homepage": "https://github.com/snomiao/agent-yes#readme",
+  "bugs": {
+    "url": "https://github.com/snomiao/agent-yes/issues"
+  },
+  "license": "MIT",
+  "author": "snomiao <snomiao@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/snomiao/agent-yes.git"
+  },
+  "directories": {
+    "doc": "docs"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "ts/*.ts"
+  ],
+  "type": "module",
+  "module": "ts/index.ts",
+  "types": "./ts/index.ts",
+  "exports": {
+    "types": "./ts/index.ts",
+    "import": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "bun build ./ts/cli.ts ./ts/index.ts --outdir=dist --target=node --sourcemap --external=@snomiao/bun-pty --external=bun-pty --external=node-pty --external=from-node-stream --external=bun",
+    "postbuild": "bun ./ts/postbuild.ts",
+    "demo": "bun run build && bun link && claude-yes -- demo",
+    "dev": "bun ts/index.ts",
+    "fmt": "oxlint --fix --fix-suggestions && oxfmt",
+    "_prepack": "bun run build",
+    "prepare": "husky",
+    "release": "standard-version && npm publish",
+    "release:beta": "standard-version && npm publish --tag beta",
+    "test": "bun test --coverage"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.71.2",
+    "@snomiao/bun-pty": "^0.3.4",
+    "bun-pty": "^0.4.8",
+    "cpu-wait": "^0.0.10",
+    "execa": "^9.6.0",
+    "from-node-stream": "^0.1.2",
+    "ink": "^6.6.0",
+    "ms": "^2.1.3",
+    "openai": "^6.16.0",
+    "p-map": "^7.0.3",
+    "phpdie": "^1.7.0",
+    "rambda": "^10.3.2",
+    "sflow": "^1.20.2",
+    "strip-ansi-control-characters": "^2.0.0",
+    "terminal-render": "^1.2.2",
+    "tsa-composer": "^3.0.3",
+    "winston": "^3.19.0",
+    "yargs": "^18.0.0"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/exec": "^7.1.0",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/release-notes-generator": "^14.1.0",
+    "@types/bun": "^1.2.18",
+    "@types/jest": "^30.0.0",
+    "@types/ms": "^2.1.0",
+    "@types/node": "^25.0.3",
+    "@types/yargs": "^17.0.33",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.1.4",
+    "node-pty": "^1.1.0",
+    "oxfmt": "^0.23.0",
+    "oxlint": "^1.38.0",
+    "semantic-release": "^24.2.9",
+    "standard-version": "^9.5.0",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "node-pty": "latest",
+    "typescript": "^5.8.3"
+  },
+  "peerDependenciesMeta": {
+    "node-pty": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "_release": {
+    "branches": [
+      "main"
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      [
+        "@semantic-release/exec",
+        {
+          "publishCmd": "npm pkg set name=claude-yes"
+        }
+      ],
+      "@semantic-release/npm",
+      "@semantic-release/git",
+      "@semantic-release/github"
+    ]
+  },
+  "bin": {
+    "qwen-yes": "./dist/qwen-yes.js",
+    "grok-yes": "./dist/grok-yes.js",
+    "claude-yes": "./dist/claude-yes.js",
+    "gemini-yes": "./dist/gemini-yes.js",
+    "codex-yes": "./dist/codex-yes.js",
+    "copilot-yes": "./dist/copilot-yes.js",
+    "cursor-yes": "./dist/cursor-yes.js",
+    "auggie-yes": "./dist/auggie-yes.js",
+    "agent-yes": "./dist/agent-yes.js",
+    "amp-yes": "./dist/amp-yes.js"
+  }
+}

package/ts/ReadyManager.spec.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import { ReadyManager } from "./ReadyManager";
+
+describe("ReadyManager", () => {
+  it("should start in not ready state", () => {
+    const manager = new ReadyManager();
+    expect(manager.wait()).toBeInstanceOf(Promise);
+  });
+
+  it("should resolve wait when ready is called", async () => {
+    const manager = new ReadyManager();
+    const waitPromise = manager.wait();
+
+    manager.ready();
+
+    await expect(waitPromise).resolves.toBeUndefined();
+  });
+
+  it("should resolve immediately if already ready", async () => {
+    const manager = new ReadyManager();
+    manager.ready();
+
+    const result = manager.wait();
+    expect(result).toBeUndefined();
+  });
+
+  it("should handle multiple waiters", async () => {
+    const manager = new ReadyManager();
+    const wait1 = manager.wait();
+    const wait2 = manager.wait();
+    const wait3 = manager.wait();
+
+    manager.ready();
+
+    await Promise.all([
+      expect(wait1).resolves.toBeUndefined(),
+      expect(wait2).resolves.toBeUndefined(),
+      expect(wait3).resolves.toBeUndefined(),
+    ]);
+  });
+
+  it("should reset to not ready when unready is called", async () => {
+    const manager = new ReadyManager();
+    manager.ready();
+    manager.unready();
+
+    expect(manager.wait()).toBeInstanceOf(Promise);
+  });
+
+  it("should handle ready with no waiting queue", () => {
+    const manager = new ReadyManager();
+    manager.ready(); // Should not throw even if no one is waiting
+    expect(manager.wait()).toBeUndefined(); // Should be ready now
+  });
+
+  it("should handle multiple ready/unready cycles", async () => {
+    const manager = new ReadyManager();
+
+    // First cycle
+    const wait1 = manager.wait();
+    manager.ready();
+    await wait1;
+
+    // Reset
+    manager.unready();
+
+    // Second cycle
+    const wait2 = manager.wait();
+    manager.ready();
+    await expect(wait2).resolves.toBeUndefined();
+  });
+});

package/ts/ReadyManager.ts

@@ -0,0 +1,16 @@
+export class ReadyManager {
+  isReady = false;
+  private readyQueue: (() => void)[] = [];
+  wait() {
+    if (this.isReady) return;
+    return new Promise<void>((resolve) => this.readyQueue.push(resolve));
+  }
+  unready() {
+    this.isReady = false;
+  }
+  ready() {
+    this.isReady = true;
+    if (!this.readyQueue.length) return; // check len for performance
+    this.readyQueue.splice(0).map((resolve) => resolve());
+  }
+}

package/ts/SUPPORTED_CLIS.ts

@@ -0,0 +1,5 @@
+import { CLIS_CONFIG } from "./index.ts";
+
+export const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG) as SUPPORTED_CLIS[]; 
+export type SUPPORTED_CLIS = keyof typeof CLIS_CONFIG;
+

package/ts/catcher.spec.ts

@@ -0,0 +1,259 @@
+import { describe, expect, it } from "vitest";
+import { catcher } from "./catcher";
+
+describe("catcher", () => {
+  describe("curried overload", () => {
+    it("should return a function when called with only catchFn", () => {
+      const catchFn = () => "error";
+      const result = catcher(catchFn);
+      expect(typeof result).toBe("function");
+    });
+
+    it("should catch errors and call catchFn with error, function, and args", () => {
+      let catchedError: unknown;
+      let catchedFn: unknown;
+      let catchedArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+        catchedError = error;
+        catchedFn = fn;
+        catchedArgs = args;
+        return "caught";
+      };
+
+      let calledArgs: unknown[] = [];
+      const errorFn = (...args: unknown[]) => {
+        calledArgs = args;
+        throw new Error("test error");
+      };
+
+      const wrappedFn = catcher(catchFn)(errorFn);
+      const result = wrappedFn("arg1", "arg2");
+
+      expect(result).toBe("caught");
+      expect(catchedError).toBeInstanceOf(Error);
+      expect(catchedFn).toBe(errorFn);
+      expect(catchedArgs).toEqual(["arg1", "arg2"]);
+      expect(calledArgs).toEqual(["arg1", "arg2"]);
+    });
+
+    it("should return normal result when no error occurs", () => {
+      let catchCalled = false;
+      const catchFn = () => {
+        catchCalled = true;
+        return "error";
+      };
+
+      let calledArgs: unknown[] = [];
+      const normalFn = (...args: unknown[]) => {
+        calledArgs = args;
+        return "success";
+      };
+
+      const wrappedFn = catcher(catchFn)(normalFn);
+      const result = wrappedFn("arg1", "arg2");
+
+      expect(result).toBe("success");
+      expect(catchCalled).toBe(false);
+      expect(calledArgs).toEqual(["arg1", "arg2"]);
+    });
+  });
+
+  describe("direct overload", () => {
+    it("should catch errors and call catchFn with error, function, and args directly", () => {
+      let catchedError: unknown;
+      let catchedFn: unknown;
+      let catchedArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+        catchedError = error;
+        catchedFn = fn;
+        catchedArgs = args;
+        return "caught";
+      };
+
+      let calledArgs: unknown[] = [];
+      const errorFn = (...args: unknown[]) => {
+        calledArgs = args;
+        throw new Error("test error");
+      };
+
+      const wrappedFn = catcher(catchFn, errorFn);
+      const result = wrappedFn("arg1", "arg2");
+
+      expect(result).toBe("caught");
+      expect(catchedError).toBeInstanceOf(Error);
+      expect(catchedFn).toBe(errorFn);
+      expect(catchedArgs).toEqual(["arg1", "arg2"]);
+      expect(calledArgs).toEqual(["arg1", "arg2"]);
+    });
+
+    it("should return normal result when no error occurs directly", () => {
+      let catchCalled = false;
+      const catchFn = () => {
+        catchCalled = true;
+        return "error";
+      };
+
+      let calledArgs: unknown[] = [];
+      const normalFn = (...args: unknown[]) => {
+        calledArgs = args;
+        return "success";
+      };
+
+      const wrappedFn = catcher(catchFn, normalFn);
+      const result = wrappedFn("arg1", "arg2");
+
+      expect(result).toBe("success");
+      expect(catchCalled).toBe(false);
+      expect(calledArgs).toEqual(["arg1", "arg2"]);
+    });
+  });
+
+  describe("error handling", () => {
+    it("should handle different error types and pass function context", () => {
+      const results: unknown[] = [];
+      const functions: unknown[] = [];
+      const catchFn = (error: unknown, fn: unknown, ..._args: unknown[]) => {
+        results.push(error);
+        functions.push(fn);
+        return "handled";
+      };
+
+      // String error
+      const stringErrorFn = () => {
+        throw "string error";
+      };
+      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 = () => {
+        throw objectError;
+      };
+      const wrappedObjectFn = catcher(catchFn, objectErrorFn);
+      expect(wrappedObjectFn()).toBe("handled");
+      expect(results[1]).toBe(objectError);
+      expect(functions[1]).toBe(objectErrorFn);
+
+      // null error
+      const nullErrorFn = () => {
+        throw null;
+      };
+      const wrappedNullFn = catcher(catchFn, nullErrorFn);
+      expect(wrappedNullFn()).toBe("handled");
+      expect(results[2]).toBe(null);
+      expect(functions[2]).toBe(nullErrorFn);
+    });
+
+    it("should preserve function parameters and pass them to catchFn", () => {
+      let caughtError: unknown;
+      let caughtFn: unknown;
+      let caughtArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+        caughtError = error;
+        caughtFn = fn;
+        caughtArgs = args;
+        return "caught";
+      };
+
+      let testArgs: [number, string, boolean] | undefined;
+      const testFn = (a: number, b: string, c: boolean) => {
+        testArgs = [a, b, c];
+        if (a > 5) throw new Error("too big");
+        return `${a}-${b}-${c}`;
+      };
+
+      const wrappedFn = catcher(catchFn, testFn);
+
+      // Normal execution
+      expect(wrappedFn(3, "test", true)).toBe("3-test-true");
+      expect(testArgs).toEqual([3, "test", true]);
+
+      // Error execution
+      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;
+      let caughtFn: unknown;
+      let caughtArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+        caughtError = error;
+        caughtFn = fn;
+        caughtArgs = args;
+        return "no params caught";
+      };
+
+      let called = false;
+      const noParamsFn = () => {
+        called = true;
+        throw new Error("no params error");
+      };
+
+      const wrappedFn = catcher(catchFn, noParamsFn);
+      const result = wrappedFn();
+
+      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", () => {
+      const catchFn = () => null;
+
+      // Function returning number
+      const numberFn = catcher(catchFn, () => 42);
+      expect(numberFn()).toBe(42);
+
+      // Function returning object
+      const obj = { key: "value" };
+      const objectFn = catcher(catchFn, () => obj);
+      expect(objectFn()).toBe(obj);
+
+      // Function returning undefined
+      const undefinedFn = catcher(catchFn, () => undefined);
+      expect(undefinedFn()).toBeUndefined();
+    });
+  });
+
+  describe("type safety", () => {
+    it("should maintain function signature", () => {
+      const catchFn = (_error: unknown, _fn: unknown, ..._args: unknown[]) => "error";
+      const originalFn = (a: number, b: string): string => `${a}-${b}`;
+
+      const wrappedFn = catcher(catchFn, originalFn);
+
+      // This should be type-safe
+      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-idle.spec.ts

@@ -0,0 +1,20 @@
+import { exec } from "child_process";
+import { fromStdio } from "from-node-stream";
+import sflow from "sflow";
+import { describe, it } from "vitest";
+import { sleepms } from "./utils";
+
+describe("CLI idle tests", () => {
+  // 2025-08-11 ok
+  it.skip("CLI --exit-on-idle flag with custom timeout", async () => {
+    const p = exec(
+      `bunx tsx ./ts/cli.ts claude --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/ts/cli.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env bun
+import { argv } from "process";
+import cliYesConfig from "../agent-yes.config.ts";
+import { parseCliArgs } from "./parseCliArgs.ts";
+import { logger } from "./logger.ts";
+
+// Import the CLI module
+
+// Parse CLI arguments
+const config = parseCliArgs(process.argv);
+
+// Validate CLI name
+if (!config.cli) {
+  logger.error(process.argv)
+  logger.error("Error: No CLI name provided.");
+  throw new Error(`missing cli def, available clis: ${Object.keys((await cliYesConfig).clis).join(", ")}`);
+}
+
+// console.log(`Using CLI: ${config.cli}`);
+
+if (config.verbose) {
+  process.env.VERBOSE = "true"; // enable verbose logging in yesLog.ts
+  console.log(config);
+  console.log(argv);
+}
+
+const { default: cliYes } = await import("./index.ts");
+const { exitCode } = await cliYes(config);
+console.log("exiting process");
+process.exit(exitCode ?? 1);

package/ts/defineConfig.ts

@@ -0,0 +1,12 @@
+import type { AgentCliConfig, AgentYesConfig } from "./index.ts";
+
+type Awaitable<T> = T | Promise<T>;
+export async function defineCliYesConfig<T extends AgentYesConfig>(
+  cfg: Awaitable<T> | ((original: T) => Awaitable<T>),
+) {
+  if (typeof cfg === "function") cfg = await cfg({ clis: {} } as T);
+
+  return cfg as unknown as Omit<AgentYesConfig, "clis"> & {
+    clis: Record<string, AgentCliConfig>;
+  };
+}

package/ts/idleWaiter.spec.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { IdleWaiter } from "./idleWaiter";
+
+describe("IdleWaiter", () => {
+  it("should initialize with current time", () => {
+    const waiter = new IdleWaiter();
+    expect(waiter.lastActivityTime).toBeCloseTo(Date.now(), -2);
+  });
+
+  it("should update lastActivityTime when ping is called", () => {
+    const waiter = new IdleWaiter();
+    const initialTime = waiter.lastActivityTime;
+
+    // Wait a small amount
+    const start = Date.now();
+    while (Date.now() - start < 10) {
+      // busy wait
+    }
+
+    waiter.ping();
+    expect(waiter.lastActivityTime).toBeGreaterThan(initialTime);
+  });
+
+  it("should return this when ping is called for chaining", () => {
+    const waiter = new IdleWaiter();
+    expect(waiter.ping()).toBe(waiter);
+  });
+
+  it("should resolve wait immediately when already idle", async () => {
+    const waiter = new IdleWaiter();
+
+    // Wait enough time to be considered idle
+    const start = Date.now();
+    while (Date.now() - start < 50) {
+      // busy wait
+    }
+
+    // This should resolve quickly since enough time has passed
+    const waitPromise = waiter.wait(10);
+    await expect(waitPromise).resolves.toBeUndefined();
+  });
+
+  it("should respect custom check interval", () => {
+    const waiter = new IdleWaiter();
+    waiter.checkInterval = 200;
+
+    expect(waiter.checkInterval).toBe(200);
+  });
+
+  it("should have ping method that chains", () => {
+    const waiter = new IdleWaiter();
+    const result = waiter.ping().ping().ping();
+    expect(result).toBe(waiter);
+  });
+});

package/ts/idleWaiter.ts

@@ -0,0 +1,31 @@
+/**
+ * A utility class to wait for idle periods based on activity pings.
+ *
+ * @example
+ * const idleWaiter = new IdleWaiter();
+ *
+ * // Somewhere in your code, when activity occurs:
+ * idleWaiter.ping();
+ *
+ * // To wait for an idle period of 5 seconds:
+ * await idleWaiter.wait(5000);
+ * console.log('System has been idle for 5 seconds');
+ */
+export class IdleWaiter {
+  lastActivityTime = Date.now();
+  checkInterval = 100; // Default check interval in milliseconds
+
+  constructor() {
+    this.ping();
+  }
+
+  ping() {
+    this.lastActivityTime = Date.now();
+    return this;
+  }
+
+  async wait(ms: number) {
+    while (this.lastActivityTime >= Date.now() - ms)
+      await new Promise((resolve) => setTimeout(resolve, this.checkInterval));
+  }
+}