agent-yes 1.31.41

package/ts/logger.ts

@@ -0,0 +1,17 @@
+import winston from "winston";
+
+// Configure Winston logger
+const logFormat = winston.format.combine(
+  winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+  winston.format.printf(({ timestamp, level, message, ...meta }) => {
+    const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : "";
+    return `${timestamp} [${level}]: ${message}${metaStr}`;
+  }),
+);
+
+export const logger = winston.createLogger({
+  level: process.env.VERBOSE ? "debug" : "info",
+  format: logFormat,
+  transports: [new winston.transports.Console({ format: winston.format.combine(winston.format.colorize(), logFormat), }),],
+  silent: false,
+});

package/ts/parseCliArgs.spec.ts

@@ -0,0 +1,231 @@
+#!/usr/bin/env bun test
+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 parse prompt from only -- separator with -yes cli", () => {
+    const result = parseCliArgs(["node", "/path/to/claude-yes", "--", "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 agent-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");
+  });
+
+  it("should parse bunx agent-yes command with verbose and dash prompt", () => {
+    const result = parseCliArgs([
+      "/tmp/bunx-0-agent-yes@beta/node_modules/bun/bin/bun.exe",
+      "/tmp/bunx-0-agent-yes@beta/node_modules/agent-yes/dist/cli.js",
+      "--verbose",
+      "claude",
+      "--",
+      "lets",
+      "fix",
+      "signin",
+      "page,",
+      "setup",
+      "shadcn",
+    ]);
+
+    expect(result.cli).toBe("claude");
+    expect(result.verbose).toBe(true);
+    expect(result.cliArgs).toEqual([]);
+    expect(result.prompt).toBe("lets fix signin page, setup shadcn");
+  });
+
+  it("should parse bunx agent-yes command with verbose and dash prompt", () => {
+    const result = parseCliArgs([
+      "/tmp/bunx-0-agent-yes@beta/node_modules/bun/bin/bun.exe",
+      "/tmp/bunx-0-agent-yes@beta/node_modules/agent-yes/dist/claude-yes.js",
+      "--",
+      "lets",
+      "fix",
+      "signin",
+      "page,",
+      "setup",
+      "shadcn",
+    ]);
+
+    expect(result.cli).toBe("claude");
+    expect(result.verbose).toBe(false);
+    expect(result.cliArgs).toEqual([]);
+    expect(result.prompt).toBe("lets fix signin page, setup shadcn");
+  });
+
+  it("should pass -h flag to claude CLI args", () => {
+    const result = parseCliArgs([
+      "/root/.nvm/versions/node/v24.5.0/bin/node",
+      "/root/.bun/bin/claude-yes",
+      "-h",
+    ]);
+
+    expect(result.cli).toBe("claude");
+    expect(result.cliArgs).toEqual(["-h"]);
+  });
+
+  it("should parse --use-skills flag", () => {
+    const result = parseCliArgs([
+      "node",
+      "/path/to/cli",
+      "--use-skills",
+      "codex",
+      "--",
+      "Implement feature",
+    ]);
+
+    expect(result.useSkills).toBe(true);
+    expect(result.cli).toBe("codex");
+    expect(result.prompt).toBe("Implement feature");
+  });
+});

package/ts/parseCliArgs.ts

@@ -0,0 +1,182 @@
+import ms from "ms";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
+import pkg from "../package.json" with { type: "json" };
+
+// const pkg = await JSON.parse(await readFile(path.resolve((import.meta.dir) + "/../package.json"), 'utf8'))
+/**
+ * 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 = (argv[1]?.split(/[/\\]/).at(-1)
+    ?.replace(/(\.[jt]s)?$/, "")
+    .replace(/^(cli|agent)(-yes$)?/, "")
+    .replace(/-yes$/, "") || undefined
+  );
+
+  // Parse args with yargs (same logic as cli.ts:16-73)
+  const parsedArgv = yargs(hideBin(argv))
+    .usage("Usage: $0 [cli] [agent-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 `--`",
+    )
+    // TODO: add a --docker option, will tell cli.ts to start docker process with tty and handles all stdio forwarding
+
+    .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("use-skills", {
+      type: "boolean",
+      description:
+        "Prepend SKILL.md header from current directory to the prompt (helpful for non-Claude agents)",
+      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: 'short idle time, will perform idle action when reached, e.g., "5s" or "1m"',
+      alias: "i",
+    })
+    .option("idle-action", {
+      type: "string",
+      description: 'Idle action to perform when idle time is reached, e.g., "exit" or "TODO.md"',
+    })
+    .option("queue", {
+      type: "boolean",
+      description:
+        "Queue Agent Commands when spawning multiple agents in the same directory/repo, can be disabled with --no-queue",
+      default: false,
+    })
+    .option("install", {
+      type: "boolean",
+      description: "Automatically Install/Update the CLI if not found or outdated",
+      default: false,
+    })
+    .option("continue", {
+      type: "boolean",
+      description:
+        "Resume previous session in current cwd if any, note: will exit if no previous session found",
+      default: false,
+      alias: "c",
+    })
+    .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(pkg.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("--"));
+
+  // Reconstruct what yargs consumed vs what it didn't
+  const yargsConsumed = new Set<string>();
+
+  // Add consumed flags
+  Object.keys(parsedArgv).forEach((key) => {
+    if (key !== "_" && key !== "$0" && parsedArgv[key as keyof typeof parsedArgv] !== undefined) {
+      yargsConsumed.add(`--${key}`);
+      // Add short aliases
+      if (key === "prompt") yargsConsumed.add("-p");
+      if (key === "robust") yargsConsumed.add("-r");
+      if (key === "idle") yargsConsumed.add("-i");
+      if (key === "exitOnIdle") yargsConsumed.add("-e");
+      if (key === "continue") yargsConsumed.add("-c");
+    }
+  });
+
+  const cliArgsForSpawn = (() => {
+    if (parsedArgv._[0] && !cliName) {
+      // Explicit CLI name provided as positional arg
+      return rawArgs.slice((cliArgIndex ?? 0) + 1, dashIndex ?? undefined);
+    } else if (cliName) {
+      // CLI name from script, filter out only what yargs consumed
+      const result: string[] = [];
+      const argsToCheck = rawArgs.slice(0, dashIndex ?? undefined);
+
+      for (let i = 0; i < argsToCheck.length; i++) {
+        const arg = argsToCheck[i];
+        if (!arg) continue;
+
+        const [flag] = arg.split("=");
+
+        if (flag && yargsConsumed.has(flag)) {
+          // Skip consumed flag and its value if separate
+          if (!arg.includes("=") && i + 1 < argsToCheck.length) {
+            const nextArg = argsToCheck[i + 1];
+            if (nextArg && !nextArg.startsWith("-")) {
+              i++; // Skip value
+            }
+          }
+        } else {
+          result.push(arg);
+        }
+      }
+      return result;
+    }
+    return [];
+  })();
+  const dashPrompt: string | 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]?.toString()?.replace?.(/-yes$/, "")) as (typeof SUPPORTED_CLIS)[number],
+    cliArgs: cliArgsForSpawn,
+    prompt: [parsedArgv.prompt, dashPrompt].filter(Boolean).join(" ") || undefined,
+    install: parsedArgv.install,
+    exitOnIdle: Number(
+      (parsedArgv.idle || parsedArgv.exitOnIdle)?.replace(/.*/, (e) =>
+        String(ms(e as ms.StringValue)),
+      ) || 0,
+    ),
+    queue: parsedArgv.queue,
+    robust: parsedArgv.robust,
+    logFile: parsedArgv.logFile,
+    verbose: parsedArgv.verbose,
+    resume: parsedArgv.continue, // Note: intentional use resume here to avoid preserved keyword (continue)
+    useSkills: parsedArgv.useSkills,
+  };
+}

package/ts/postbuild.ts

@@ -0,0 +1,29 @@
+#! /usr/bin/env bun
+/**
+ * Postbuild script: Create Node.js wrapper files in dist/
+ * These wrappers execute dist/cli.js with the appropriate CLI name
+ */
+import { writeFile, chmod } from "fs/promises";
+import { CLIS_CONFIG } from "./index.ts";
+import sflow from "sflow";
+import pkg from "../package.json";
+
+// Create copies for each CLI variant (all use the same wrapper logic)
+await sflow([...Object.keys(CLIS_CONFIG), 'agent'])
+  .map(async (cli) => {
+    const cliName = `${cli}-yes`;
+
+    const wrapperPath = `./dist/${cliName}.js`;
+    await writeFile(wrapperPath, `
+#!/usr/bin/env bun
+await import('./cli.js')
+`.trim());
+    await chmod(wrapperPath, 0o755);
+
+    if (!(pkg.bin as Record<string, string>)?.[cliName]) {
+      await Bun.$`npm pkg set ${"bin." + cliName}=${wrapperPath}`;
+      console.log(`${wrapperPath} created`);
+    }
+  })
+
+  .run();

package/ts/pty-fix.ts

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { arch, platform } from "process";
+import { fileURLToPath } from "url";
+
+// Determine the platform-specific library name
+function getLibraryName() {
+  switch (platform) {
+    case "win32":
+      return "rust_pty.dll";
+    case "darwin":
+      return arch === "arm64" ? "librust_pty_arm64.dylib" : "librust_pty.dylib";
+    case "linux":
+      return arch === "arm64" ? "librust_pty_arm64.so" : "librust_pty.so";
+    default:
+      return "librust_pty.so";
+  }
+}
+
+// Check if we need to rebuild bun-pty
+const bunPtyPath = dirname(fileURLToPath(import.meta.resolve("@snomiao/bun-pty"))) + "/..";
+const libName = getLibraryName();
+const libPath = join(bunPtyPath, "rust-pty", "target", "release", libName);
+
+if (!existsSync(bunPtyPath)) {
+  console.log({ bunPtyPath });
+  console.log("bun-pty not found, skipping pty-fix in ");
+  process.exit(0);
+}
+
+// Platform-specific compatibility check
+if (platform === "linux") {
+  // Check if the binary exists and if it has GLIBC compatibility issues
+  try {
+    const lddOutput = execSync(`ldd "${libPath}" 2>&1`, { encoding: "utf8" });
+    if (lddOutput.includes("GLIBC") && lddOutput.includes("not found")) {
+      console.log("GLIBC compatibility issue detected, rebuilding bun-pty...");
+      rebuildBunPty();
+    } else {
+      console.log("bun-pty binary is compatible");
+    }
+  } catch {
+    // If ldd fails or file doesn't exist, try to rebuild
+    console.log("Checking bun-pty compatibility...");
+    rebuildBunPty();
+  }
+} else if (platform === "win32") {
+  // Windows: Check if DLL exists
+  if (!existsSync(libPath)) {
+    console.log("Windows DLL not found, attempting to rebuild...");
+    rebuildBunPty();
+  } else {
+    console.log("bun-pty Windows DLL found");
+  }
+} else if (platform === "darwin") {
+  // macOS: Check if dylib exists
+  if (!existsSync(libPath)) {
+    console.log("macOS dylib not found, attempting to rebuild...");
+    rebuildBunPty();
+  } else {
+    console.log("bun-pty macOS dylib found");
+  }
+} else {
+  console.log(`Platform ${platform} may require manual configuration`);
+}
+
+function rebuildBunPty() {
+  try {
+    // Check if cargo is available
+    const cargoCmd = platform === "win32" ? "cargo.exe" : "cargo";
+    try {
+      execSync(`${cargoCmd} --version`, { stdio: "ignore" });
+    } catch {
+      console.warn("Warning: Rust/Cargo not found. bun-pty native module may not work.");
+      console.warn("To fix this, install Rust: https://rustup.rs/");
+      return;
+    }
+
+    const rustPtyDir = join(bunPtyPath, "rust-pty");
+    const isWindows = platform === "win32";
+    const tempBase = isWindows ? process.env.TEMP || "C:\\Temp" : "/tmp";
+
+    // Check if source code exists
+    if (!existsSync(join(rustPtyDir, "Cargo.toml"))) {
+      // Try to clone and build from source
+      console.log("Source code not found in npm package, cloning from repository...");
+      const tmpDir = join(tempBase, `bun-pty-build-${Date.now()}`);
+
+      try {
+        execSync(`git clone https://github.com/snomiao/bun-pty.git "${tmpDir}"`, {
+          stdio: "inherit",
+        });
+
+        // Build command varies by platform
+        if (isWindows) {
+          execSync(
+            `cd /d "${tmpDir}" && cargo build --release --manifest-path rust-pty\\Cargo.toml`,
+            { stdio: "inherit" },
+          );
+        } else {
+          execSync(`cd "${tmpDir}" && cargo build --release --manifest-path rust-pty/Cargo.toml`, {
+            stdio: "inherit",
+          });
+        }
+
+        // Copy the built library
+        const builtLib = join(tmpDir, "rust-pty", "target", "release", libName);
+        if (existsSync(builtLib)) {
+          // Ensure target directory exists
+          const targetDir = join(rustPtyDir, "target", "release");
+          if (isWindows) {
+            execSync(`if not exist "${targetDir}" mkdir "${targetDir}"`, {});
+            execSync(`copy /Y "${builtLib}" "${libPath}"`, {});
+          } else {
+            execSync(`mkdir -p "${targetDir}"`, { stdio: "inherit" });
+            execSync(`cp "${builtLib}" "${libPath}"`, { stdio: "inherit" });
+          }
+          console.log("Successfully rebuilt bun-pty native module");
+        }
+
+        // Cleanup
+        if (isWindows) {
+          execSync(`rmdir /s /q "${tmpDir}"`, { stdio: "ignore" });
+        } else {
+          execSync(`rm -rf "${tmpDir}"`, { stdio: "ignore" });
+        }
+      } catch (buildError) {
+        console.error(
+          "Failed to build bun-pty:",
+          buildError instanceof Error ? buildError.message : buildError,
+        );
+        console.warn("The application may not work correctly without bun-pty");
+      }
+    } else {
+      // Build from included source
+      console.log("Building bun-pty from source...");
+      if (isWindows) {
+        execSync(`cd /d "${rustPtyDir}" && cargo build --release`, {
+          stdio: "inherit",
+        });
+      } else {
+        execSync(`cd "${rustPtyDir}" && cargo build --release`, {
+          stdio: "inherit",
+        });
+      }
+      console.log("Successfully rebuilt bun-pty native module");
+    }
+  } catch (error) {
+    console.error("Failed to rebuild bun-pty:", error instanceof Error ? error.message : error);
+    console.warn("The application may not work correctly without bun-pty");
+  }
+}

package/ts/pty.ts

@@ -0,0 +1,18 @@
+import { logger } from "./logger.ts";
+
+// its recommened to use bun-pty in windows, since node-pty is super complex to install there, requires a 10G M$ build tools
+
+async function getPty() {
+  return globalThis.Bun ? await import("bun-pty").catch((error) => {
+    logger.error("Failed to load bun-pty:", error);
+    throw error;
+  }) : await import("node-pty")
+    .catch((error) => {
+      logger.error("Failed to load node-pty:", error);
+      throw error;
+    });
+};
+
+const pty = await getPty();
+export const ptyPackage = globalThis.Bun ? "bun-pty" : "node-pty";
+export default pty;