agent-yes 1.72.4 → 1.73.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.72.4",
+  "version": "1.73.2",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",
@@ -49,6 +49,7 @@
   "files": [
     "agent-yes.config.schema.json",
     "bin",
+    "default.config.yaml",
     "examples",
     "scripts",
     "ts/*.ts",
@@ -81,10 +82,12 @@
     "release": "standard-version && npm publish",
     "release:beta": "standard-version && npm publish --tag beta",
     "test": "vitest run",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "test:ui": "vitest run --config tests/ui-test/vitest.config.ts"
   },
   "dependencies": {
     "@snomiao/bun-pty": "^0.3.4",
+    "@xterm/headless": "^6.0.0",
     "bun-pty": "^0.4.8",
     "execa": "^9.6.1",
     "from-node-stream": "^0.2.0",
@@ -92,12 +95,12 @@
     "phpdie": "^1.7.0",
     "proper-lockfile": "^4.1.2",
     "sflow": "^1.27.0",
-    "terminal-render": "^1.5.1",
     "winston": "^3.19.0",
     "yaml": "^2.8.2",
     "yargs": "^18.0.0"
   },
   "devDependencies": {
+    "@google/generative-ai": "^0.24.1",
     "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
     "@types/bun": "^1.3.6",
@@ -105,6 +108,7 @@
     "@types/ms": "^2.1.0",
     "@types/node": "^25.0.10",
     "@types/proper-lockfile": "^4.1.4",
+    "@types/ws": "^8.18.1",
     "@types/yargs": "^17.0.35",
     "@typescript/native-preview": "^7.0.0-dev.20260124.1",
     "@vitest/coverage-v8": "4.1.0",
@@ -114,11 +118,13 @@
     "oxfmt": "^0.26.0",
     "oxlint": "^1.41.0",
     "patch-package": "^8.0.1",
+    "playwright": "^1.58.2",
     "rambda": "^11.0.1",
     "semantic-release": "^25.0.2",
     "standard-version": "^9.5.0",
     "tsdown": "^0.20.3",
     "vitest": "4.1.0",
+    "ws": "^8.20.0",
     "zod": "^3.23.0"
   },
   "peerDependencies": {

package/ts/cli.ts

@@ -2,18 +2,27 @@
 import { argv } from "process";
 import { spawn } from "child_process";
 import { parseCliArgs } from "./parseCliArgs.ts";
-import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
 import { logger } from "./logger.ts";
-import { PidStore } from "./pidStore.ts";
-import { checkAndAutoUpdate, displayVersion } from "./versionChecker.ts";
+import { checkAndAutoUpdate, displayVersion, versionString } from "./versionChecker.ts";
 import { getRustBinary } from "./rustBinary.ts";
 import { buildRustArgs } from "./buildRustArgs.ts";
 
+// Ultra-fast path: skip heavy init for --version/-v
+{
+  const rawArgs = process.argv.slice(2);
+  if (rawArgs[0] === "-v" || rawArgs.includes("--version")) {
+    console.log(versionString());
+    process.exit(0);
+  }
+}
+
 // Check for updates before starting — installs & re-execs if a newer version exists.
 // Fast path: cached result (no network), so this adds near-zero latency most of the time.
 await checkAndAutoUpdate();
 
-// Parse CLI arguments
+logger.info(versionString());
+
+// Parse CLI arguments (no choices validation — SUPPORTED_CLIS loaded lazily below)
 const config = parseCliArgs(process.argv);
 
 // Handle --tray: show system tray icon and block
@@ -45,6 +54,7 @@ if (config.useRust) {
   }
 
   if (rustBinary) {
+    const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS.ts");
     const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 
     if (config.verbose) {
@@ -81,7 +91,7 @@ if (config.useRust) {
   }
 }
 
-// Handle --version: display version and exit
+// Handle --version: display version and exit (also reached when --version comes after other flags)
 if (config.showVersion) {
   await displayVersion();
   process.exit(0);
@@ -89,6 +99,7 @@ if (config.showVersion) {
 
 // Handle --append-prompt: write to active IPC (FIFO/Named Pipe) and exit
 if (config.appendPrompt) {
+  const { PidStore } = await import("./pidStore.ts");
   const ipcPath = await PidStore.findActiveFifo(process.cwd());
   if (!ipcPath) {
     console.error("No active agent with IPC found in current directory.");
@@ -134,12 +145,8 @@ if (config.appendPrompt) {
 
 // Validate CLI name
 if (!config.cli) {
-  // logger.error(process.argv);
   config.cli = "claude"; // default to claude, for smooth UX
   logger.warn("Warning: No CLI name provided. Using default 'claude'.");
-  // throw new Error(
-  //   `missing cli def, available clis: ${Object.keys((await cliYesConfig).clis).join(", ")}`,
-  // );
 }
 
 // console.log(`Using CLI: ${config.cli}`);

package/ts/configLoader.spec.ts

@@ -52,6 +52,25 @@ clis:
     expect(config.clis?.gemini?.defaultArgs).toEqual(["--resume"]);
   });
 
+  it("should compile regex sources from YAML config", async () => {
+    const configPath = path.join(testDir, ".agent-yes.config.yaml");
+    await writeFile(
+      configPath,
+      `
+clis:
+  codex:
+    ready:
+      - pattern: '^› '
+        flags: m
+`,
+    );
+
+    const config = await loadCascadingConfig({ projectDir: testDir, homeDir: testDir });
+    expect(config.clis?.codex?.ready?.[0]).toBeInstanceOf(RegExp);
+    expect(config.clis?.codex?.ready?.[0]?.flags).toContain("m");
+    expect(config.clis?.codex?.ready?.[0]?.test("› ")).toBe(true);
+  });
+
   it("should load YML config", async () => {
     const configPath = path.join(testDir, ".agent-yes.config.yml");
     await writeFile(

package/ts/configLoader.ts

@@ -8,6 +8,7 @@ import os from "node:os";
 import { parse as parseYaml } from "yaml";
 import { logger } from "./logger.ts";
 import type { AgentYesConfig } from "./index.ts";
+import { normalizeAgentYesConfig } from "./configShared.ts";
 import { deepMixin } from "./utils.ts";
 
 const CONFIG_FILENAME = ".agent-yes.config";
@@ -34,16 +35,21 @@ async function fileExists(filepath: string): Promise<boolean> {
 async function parseConfigFile(filepath: string): Promise<Partial<AgentYesConfig>> {
   const content = await readFile(filepath, "utf-8");
   const ext = path.extname(filepath).toLowerCase();
+  let parsed: Partial<AgentYesConfig>;
 
   switch (ext) {
     case ".json":
-      return JSON.parse(content);
+      parsed = JSON.parse(content);
+      break;
     case ".yml":
     case ".yaml":
-      return parseYaml(content) ?? {};
+      parsed = parseYaml(content) ?? {};
+      break;
     default:
       throw new Error(`Unsupported config file extension: ${ext}`);
   }
+
+  return normalizeAgentYesConfig(parsed as Partial<AgentYesConfig>);
 }
 
 /**

package/ts/configShared.spec.ts

@@ -0,0 +1,97 @@
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  compileRegexSource,
+  findSharedCliDefaultsPath,
+  isRegexSource,
+  loadSharedCliDefaults,
+  normalizeAgentYesConfig,
+  normalizeCliConfig,
+} from "./configShared.ts";
+
+describe("configShared", () => {
+  const tempRoots: string[] = [];
+
+  afterEach(async () => {
+    await Promise.all(tempRoots.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+  });
+
+  it("compiles structured regex sources with flags", () => {
+    const regex = compileRegexSource({ pattern: "^foo$", flags: "m" });
+    expect(regex).toBeInstanceOf(RegExp);
+    expect(regex.flags).toContain("m");
+  });
+
+  it("returns RegExp instances unchanged", () => {
+    const regex = /foo/;
+    expect(compileRegexSource(regex)).toBe(regex);
+  });
+
+  it("normalizes legacy exitCommand to exitCommands", () => {
+    const config = normalizeCliConfig({ exitCommand: ["/quit"] });
+    expect(config.exitCommands).toEqual(["/quit"]);
+  });
+
+  it("normalizes configDir, logsDir, and regex arrays", () => {
+    const config = normalizeAgentYesConfig({
+      configDir: "/cfg",
+      logsDir: "/logs",
+      clis: {
+        claude: {
+          ready: [{ pattern: "^ready$", flags: "m" }],
+          typingRespond: {
+            "1\n": ["^confirm$"],
+          },
+        },
+      },
+    });
+
+    expect(config.configDir).toBe("/cfg");
+    expect(config.logsDir).toBe("/logs");
+    expect(config.clis?.claude.ready?.[0]).toBeInstanceOf(RegExp);
+    expect(config.clis?.claude.typingRespond?.["1\n"]?.[0]).toBeInstanceOf(RegExp);
+  });
+
+  it("loads shared YAML defaults for codex", async () => {
+    const clis = await loadSharedCliDefaults(import.meta.url);
+    expect(clis.codex).toBeDefined();
+    expect(clis.codex.ready?.some((regex) => regex.test("› "))).toBe(true);
+    expect(clis.codex.ready?.some((regex) => regex.test("⏎ send"))).toBe(true);
+  });
+
+  it("finds the shared defaults file by walking upward", async () => {
+    const found = await findSharedCliDefaultsPath(import.meta.url);
+    expect(found.endsWith("default.config.yaml")).toBe(true);
+  });
+
+  it("throws when no shared defaults file exists in parent directories", async () => {
+    const tempDir = path.join(os.tmpdir(), `agent-yes-config-shared-${Date.now()}-missing`);
+    tempRoots.push(tempDir);
+    await mkdir(tempDir, { recursive: true });
+
+    await expect(
+      findSharedCliDefaultsPath(pathToFileURL(path.join(tempDir, "entry.js")).href),
+    ).rejects.toThrow("Unable to locate");
+  });
+
+  it("throws when the located shared defaults file is not an object", async () => {
+    const tempDir = path.join(os.tmpdir(), `agent-yes-config-shared-${Date.now()}-invalid`);
+    tempRoots.push(tempDir);
+    await mkdir(tempDir, { recursive: true });
+    await writeFile(path.join(tempDir, "default.config.yaml"), "123\n");
+
+    await expect(
+      loadSharedCliDefaults(pathToFileURL(path.join(tempDir, "entry.js")).href),
+    ).rejects.toThrow("Invalid shared CLI defaults file");
+  });
+
+  it("recognizes valid and invalid regex source shapes", () => {
+    expect(isRegexSource("^ready$")).toBe(true);
+    expect(isRegexSource({ pattern: "^ready$", flags: "m" })).toBe(true);
+    expect(isRegexSource({ pattern: 123 })).toBe(false);
+    expect(isRegexSource({ pattern: "^ready$", flags: 1 })).toBe(false);
+  });
+});

package/ts/configShared.ts

@@ -0,0 +1,158 @@
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse as parseYaml } from "yaml";
+import type { AgentCliConfig, AgentYesConfig } from "./index.ts";
+
+export type RegexSource = string | { pattern: string; flags?: string };
+
+type RawCliConfig = Omit<
+  AgentCliConfig,
+  | "ready"
+  | "fatal"
+  | "working"
+  | "enter"
+  | "enterExclude"
+  | "typingRespond"
+  | "restartWithoutContinueArg"
+  | "updateAvailable"
+  | "exitCommands"
+> & {
+  ready?: RegexSource[];
+  fatal?: RegexSource[];
+  working?: RegexSource[];
+  enter?: RegexSource[];
+  enterExclude?: RegexSource[];
+  typingRespond?: Record<string, RegexSource[]>;
+  restartWithoutContinueArg?: RegexSource[];
+  updateAvailable?: RegexSource[];
+  exitCommands?: string[];
+  exitCommand?: string[];
+};
+
+type RawAgentYesConfig = {
+  configDir?: string;
+  logsDir?: string;
+  clis?: Record<string, RawCliConfig>;
+};
+
+function isRegexSourceObject(value: unknown): value is { pattern: string; flags?: string } {
+  return (
+    !!value &&
+    typeof value === "object" &&
+    "pattern" in value &&
+    typeof (value as { pattern?: unknown }).pattern === "string" &&
+    (!("flags" in value) || typeof (value as { flags?: unknown }).flags === "string")
+  );
+}
+
+export function compileRegexSource(source: RegexSource | RegExp): RegExp {
+  if (source instanceof RegExp) return source;
+  if (typeof source === "string") return new RegExp(source);
+  return new RegExp(source.pattern, source.flags ?? "");
+}
+
+function compileRegexList(sources?: (RegexSource | RegExp)[]): RegExp[] | undefined {
+  return sources?.map((source) => compileRegexSource(source));
+}
+
+function compileTypingRespond(
+  typingRespond?: Record<string, RegexSource[]>,
+): Record<string, RegExp[]> | undefined {
+  if (!typingRespond) return undefined;
+  return Object.fromEntries(
+    Object.entries(typingRespond).map(([message, patterns]) => [
+      message,
+      patterns.map(compileRegexSource),
+    ]),
+  );
+}
+
+export function normalizeCliConfig(raw: RawCliConfig): AgentCliConfig {
+  const {
+    ready,
+    fatal,
+    working,
+    enter,
+    enterExclude,
+    typingRespond,
+    restartWithoutContinueArg,
+    updateAvailable,
+    exitCommands,
+    exitCommand,
+    ...rest
+  } = raw;
+
+  return {
+    ...rest,
+    ready: compileRegexList(ready),
+    fatal: compileRegexList(fatal),
+    working: compileRegexList(working),
+    enter: compileRegexList(enter),
+    enterExclude: compileRegexList(enterExclude),
+    typingRespond: compileTypingRespond(typingRespond),
+    restartWithoutContinueArg: compileRegexList(restartWithoutContinueArg),
+    updateAvailable: compileRegexList(updateAvailable),
+    exitCommands: exitCommands ?? exitCommand,
+  };
+}
+
+export function normalizeAgentYesConfig(raw: RawAgentYesConfig): Partial<AgentYesConfig> {
+  const normalized: Partial<AgentYesConfig> = {};
+
+  if (raw.configDir !== undefined) normalized.configDir = raw.configDir;
+  if (raw.logsDir !== undefined) normalized.logsDir = raw.logsDir;
+
+  if (raw.clis) {
+    normalized.clis = Object.fromEntries(
+      Object.entries(raw.clis).map(([name, cliConfig]) => [name, normalizeCliConfig(cliConfig)]),
+    );
+  }
+
+  return normalized;
+}
+
+async function fileExists(filepath: string) {
+  try {
+    await access(filepath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function findSharedCliDefaultsPath(
+  fromUrl: string = import.meta.url,
+): Promise<string> {
+  let currentDir = path.dirname(fileURLToPath(fromUrl));
+
+  while (true) {
+    const candidate = path.resolve(currentDir, "default.config.yaml");
+    if (await fileExists(candidate)) return candidate;
+
+    const parent = path.dirname(currentDir);
+    if (parent === currentDir) break;
+    currentDir = parent;
+  }
+
+  throw new Error("Unable to locate default.config.yaml from current package path");
+}
+
+export async function loadSharedCliDefaults(
+  fromUrl: string = import.meta.url,
+): Promise<Record<string, AgentCliConfig>> {
+  const filepath = await findSharedCliDefaultsPath(fromUrl);
+  const content = await readFile(filepath, "utf8");
+  const parsed = parseYaml(content);
+
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error(`Invalid shared CLI defaults file: ${filepath}`);
+  }
+
+  const normalized = normalizeAgentYesConfig(parsed as RawAgentYesConfig);
+  return normalized.clis ?? {};
+}
+
+export function isRegexSource(value: unknown): value is RegexSource {
+  return typeof value === "string" || isRegexSourceObject(value);
+}