agent-yes 1.72.3 → 1.73.0

package/ts/tray.ts

@@ -5,7 +5,6 @@ import path from "path";
 import { getRunningAgentCount, type Task } from "./runningLock.ts";
 
 const POLL_INTERVAL = 2000;
-const IDLE_EXIT_POLLS = 15; // Exit after 15 polls (~30s) with 0 agents
 
 const getTrayDir = () => path.join(process.env.CLAUDE_YES_HOME || homedir(), ".claude-yes");
 const getTrayPidFile = () => path.join(getTrayDir(), "tray.pid");
@@ -177,21 +176,10 @@ export async function startTray(): Promise<void> {
 
   // Poll and update, auto-exit after ~30s idle (0 agents)
   let lastCount = count;
-  let idlePolls = count === 0 ? 1 : 0;
   intervalId = setInterval(async () => {
     try {
       const { count: newCount, tasks: newTasks } = await getRunningAgentCount();
 
-      if (newCount === 0) {
-        idlePolls++;
-        if (idlePolls >= IDLE_EXIT_POLLS) {
-          cleanup();
-          return;
-        }
-      } else {
-        idlePolls = 0;
-      }
-
       if (newCount !== lastCount) {
         lastCount = newCount;
 

package/ts/versionChecker.spec.ts

@@ -4,6 +4,8 @@ import {
   compareVersions,
   fetchLatestVersion,
   displayVersion,
+  detectInstallMethod,
+  versionString,
 } from "./versionChecker";
 
 vi.mock("execa", () => ({ execaCommand: vi.fn().mockResolvedValue({}) }));
@@ -12,6 +14,24 @@ vi.mock("fs/promises", () => ({
   readFile: vi.fn(),
   writeFile: vi.fn().mockResolvedValue(undefined),
 }));
+vi.mock("fs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("fs")>();
+  return {
+    ...actual,
+    // Return false for .git checks so the dev-checkout guard doesn't skip auto-update in tests
+    existsSync: vi.fn(() => false),
+    lstatSync: actual.lstatSync,
+    readlinkSync: actual.readlinkSync,
+  };
+});
+vi.mock("child_process", () => ({
+  execFileSync: vi.fn(() => {
+    // Simulate successful re-exec by throwing an exit-like error
+    const err = new Error("re-exec") as any;
+    err.status = 0;
+    throw err;
+  }),
+}));
 
 describe("versionChecker", () => {
   describe("compareVersions", () => {
@@ -81,7 +101,10 @@ describe("versionChecker", () => {
       vi.clearAllMocks();
       vi.stubGlobal("fetch", vi.fn());
       vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+      // Use a mock for process.exit to prevent actual exit in tests
+      vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
       delete process.env.AGENT_YES_NO_UPDATE;
+      delete process.env.AGENT_YES_UPDATED;
       delete process.env.BUN_INSTALL;
     });
 
@@ -95,6 +118,21 @@ describe("versionChecker", () => {
       expect(fetch).not.toHaveBeenCalled();
     });
 
+    it("should skip when running from a git dev checkout", async () => {
+      const fs = await import("fs");
+      // Make the .git check return true so the dev-checkout guard triggers
+      vi.mocked(fs.existsSync).mockReturnValueOnce(true);
+      await checkAndAutoUpdate();
+      expect(fetch).not.toHaveBeenCalled();
+    });
+
+    it("should skip when AGENT_YES_UPDATED matches current version", async () => {
+      const pkg = await import("../package.json");
+      process.env.AGENT_YES_UPDATED = pkg.default.version;
+      await checkAndAutoUpdate();
+      expect(fetch).not.toHaveBeenCalled();
+    });
+
     it("should use cached result within TTL and not install when up-to-date", async () => {
       const { readFile } = await import("fs/promises");
       vi.mocked(readFile).mockResolvedValueOnce(
@@ -105,19 +143,23 @@ describe("versionChecker", () => {
       expect(process.stderr.write).not.toHaveBeenCalled();
     });
 
-    it("should install from cache when cached version is newer and within TTL", async () => {
+    it("should install and re-exec from cache when cached version is newer and within TTL", async () => {
       const { readFile } = await import("fs/promises");
       const { execaCommand } = await import("execa");
+      const { execFileSync } = await import("child_process");
       vi.mocked(readFile).mockResolvedValueOnce(
         JSON.stringify({ checkedAt: Date.now(), latestVersion: "999.0.0" }) as any,
       );
       await checkAndAutoUpdate();
       expect(execaCommand).toHaveBeenCalled();
+      expect(execFileSync).toHaveBeenCalled();
+      expect(process.exit).toHaveBeenCalled();
     });
 
-    it("should fetch and write cache when stale, install if behind", async () => {
+    it("should fetch and write cache when stale, install and re-exec if behind", async () => {
       const { readFile, writeFile } = await import("fs/promises");
       const { execaCommand } = await import("execa");
+      const { execFileSync } = await import("child_process");
       vi.mocked(readFile).mockRejectedValueOnce(new Error("no cache"));
       vi.mocked(fetch).mockResolvedValue({
         ok: true,
@@ -126,6 +168,7 @@ describe("versionChecker", () => {
       await checkAndAutoUpdate();
       expect(writeFile).toHaveBeenCalled();
       expect(execaCommand).toHaveBeenCalled();
+      expect(execFileSync).toHaveBeenCalled();
     });
 
     it("should fetch and write cache but not install if up-to-date", async () => {
@@ -229,4 +272,32 @@ describe("versionChecker", () => {
       expect(console.log).toHaveBeenCalledWith(expect.stringContaining("unable to check"));
     });
   });
+
+  describe("detectInstallMethod", () => {
+    it("should return a string", () => {
+      const method = detectInstallMethod();
+      expect(typeof method).toBe("string");
+      expect(method.length).toBeGreaterThan(0);
+    });
+
+    it("should return 'git' when .git exists in parent of script dir", async () => {
+      const fs = await import("fs");
+      vi.mocked(fs.existsSync).mockReturnValueOnce(true);
+      expect(detectInstallMethod()).toBe("git");
+    });
+
+    it("should return 'source' when not in node_modules and no .git", async () => {
+      const fs = await import("fs");
+      vi.mocked(fs.existsSync).mockReturnValueOnce(false);
+      expect(detectInstallMethod()).toBe("source");
+    });
+  });
+
+  describe("versionString", () => {
+    it("should include version and install method", () => {
+      const str = versionString();
+      expect(str).toContain("agent-yes v");
+      expect(str).toMatch(/agent-yes v\d+\.\d+\.\d+ \(.+\)/);
+    });
+  });
 });

package/ts/versionChecker.ts

@@ -1,4 +1,6 @@
+import { execFileSync } from "child_process";
 import { execaCommand } from "execa";
+import { existsSync, lstatSync, readlinkSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
@@ -25,59 +27,99 @@ async function writeUpdateCache(data: UpdateCache): Promise<void> {
 }
 
 function detectPackageManager(): string {
-  if (process.env.BUN_INSTALL || process.env.npm_execpath?.includes("bun")) return "bun";
+  if (
+    process.env.BUN_INSTALL ||
+    process.execPath?.includes("bun") ||
+    process.env.npm_execpath?.includes("bun")
+  )
+    return "bun";
   return "npm";
 }
 
 /**
- * Check for updates and auto-install if a newer version is available.
+ * Check for updates, auto-install if newer version is available, and re-exec
+ * so the current invocation always runs the latest code.
+ *
  * Uses a 1-hour TTL cache to avoid hitting the registry on every run.
  * All errors are swallowed — network issues must never break the tool.
  * Set AGENT_YES_NO_UPDATE=1 to opt out.
+ *
+ * The AGENT_YES_UPDATED env var prevents infinite re-exec loops:
+ * after updating we re-exec with AGENT_YES_UPDATED=<version> so the
+ * new process skips the update check.
  */
 export async function checkAndAutoUpdate(): Promise<void> {
   if (process.env.AGENT_YES_NO_UPDATE) return;
 
+  // Prevent infinite re-exec: if we just updated, skip
+  if (process.env.AGENT_YES_UPDATED) return;
+
+  // Skip auto-update when running from a linked local dev checkout (git repo)
+  if (import.meta.url.startsWith("file://") && !import.meta.url.includes("node_modules")) {
+    const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+    const repoRoot = path.resolve(scriptDir, "..");
+    if (existsSync(path.join(repoRoot, ".git"))) return;
+  }
+
   try {
+    let latestVersion: string | undefined;
+
     // Check cache TTL
     const cache = await readUpdateCache();
     if (cache && Date.now() - cache.checkedAt < TTL_MS) {
-      // Use cached result
-      if (compareVersions(pkg.version, cache.latestVersion) < 0) {
-        await runInstall(cache.latestVersion);
-      }
-      return;
+      latestVersion = cache.latestVersion;
+    } else {
+      // Fetch latest from registry
+      const fetched = await fetchLatestVersion();
+      if (!fetched) return;
+      latestVersion = fetched;
+      await writeUpdateCache({ checkedAt: Date.now(), latestVersion });
     }
 
-    // Fetch latest from registry
-    const latestVersion = await fetchLatestVersion();
-    if (!latestVersion) return;
-
-    await writeUpdateCache({ checkedAt: Date.now(), latestVersion });
-
     if (compareVersions(pkg.version, latestVersion) < 0) {
-      await runInstall(latestVersion);
+      const installed = await runInstall(latestVersion);
+      if (installed) {
+        reExec(latestVersion);
+      }
     }
   } catch {
     // Silently ignore all errors
   }
 }
 
-async function runInstall(latestVersion: string): Promise<void> {
+async function runInstall(latestVersion: string): Promise<boolean> {
   const pm = detectPackageManager();
-  const installArgs =
+  const installCmd =
     pm === "bun"
       ? `bun add -g agent-yes@${latestVersion}`
       : `npm install -g agent-yes@${latestVersion}`;
 
   process.stderr.write(`\x1b[33m[agent-yes] Updating ${pkg.version} → ${latestVersion}…\x1b[0m\n`);
   try {
-    await execaCommand(installArgs, { stdio: "inherit" });
-    // Clear cache so next run re-checks
-    await writeUpdateCache({ checkedAt: 0, latestVersion });
+    await execaCommand(installCmd, { stdio: "inherit" });
     process.stderr.write(`\x1b[32m[agent-yes] Updated to ${latestVersion}\x1b[0m\n`);
+    return true;
   } catch {
-    process.stderr.write(`\x1b[31m[agent-yes] Auto-update failed. Run: ${installArgs}\x1b[0m\n`);
+    process.stderr.write(`\x1b[31m[agent-yes] Auto-update failed. Run: ${installCmd}\x1b[0m\n`);
+    return false;
+  }
+}
+
+/**
+ * Re-exec the current process so the newly installed version runs.
+ * Sets AGENT_YES_UPDATED=<version> to prevent an infinite loop.
+ */
+function reExec(version: string): never {
+  const [bin, ...args] = process.argv;
+  process.stderr.write(`\x1b[36m[agent-yes] Restarting with v${version}…\x1b[0m\n`);
+  try {
+    execFileSync(bin, args, {
+      stdio: "inherit",
+      env: { ...process.env, AGENT_YES_UPDATED: version },
+    });
+    process.exit(0);
+  } catch (err: any) {
+    process.exit(err.status ?? 1);
   }
 }
 
@@ -121,31 +163,80 @@ export function compareVersions(v1: string, v2: string): number {
   return 0;
 }
 
+/**
+ * Detect how agent-yes was installed.
+ * Returns a short label: "git", "bun link", "bun", "npm", "npx", or "unknown"
+ */
+export function detectInstallMethod(): string {
+  try {
+    // Check if running from a file path outside node_modules (git clone / bun link dev)
+    const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+
+    if (!scriptDir.includes("node_modules")) {
+      // Running directly from source — is this a git repo?
+      const repoRoot = path.resolve(scriptDir, "..");
+      if (existsSync(path.join(repoRoot, ".git"))) {
+        return "git";
+      }
+      return "source";
+    }
+
+    // Check if the node_modules entry is a symlink (bun link)
+    const nodeModulesEntry = scriptDir.replace(/\/dist$/, "");
+    try {
+      const stat = lstatSync(nodeModulesEntry);
+      if (stat.isSymbolicLink()) {
+        const target = readlinkSync(nodeModulesEntry);
+        // bun link creates a symlink to the local repo
+        const resolvedTarget = path.resolve(path.dirname(nodeModulesEntry), target);
+        if (existsSync(path.join(resolvedTarget, ".git"))) {
+          return "bun link (git)";
+        }
+        return "bun link";
+      }
+    } catch {
+      // not a symlink, continue
+    }
+
+    // Detect package manager from path or env
+    if (scriptDir.includes(".bun/")) return "bun";
+    if (scriptDir.includes(".npm/")) return "npx";
+    if (process.env.npm_execpath?.includes("bun")) return "bun";
+    if (process.env.npm_config_user_agent?.startsWith("bun")) return "bun";
+    if (process.env.npm_config_user_agent?.startsWith("npm")) return "npm";
+
+    return "npm";
+  } catch {
+    return "unknown";
+  }
+}
+
+/**
+ * Format version string with install method
+ */
+export function versionString(): string {
+  return `agent-yes v${pkg.version} (${detectInstallMethod()})`;
+}
+
 /**
  * Display version information with async latest version check
  */
 export async function displayVersion(): Promise<void> {
-  // Display current version immediately
-  console.log(pkg.version);
+  console.log(versionString());
 
-  // Check latest version asynchronously
   const latestVersion = await fetchLatestVersion();
 
   if (latestVersion) {
     const comparison = compareVersions(pkg.version, latestVersion);
 
     if (comparison < 0) {
-      // Current version is older
       console.log(`\x1b[33m${latestVersion} (update available)\x1b[0m`);
     } else if (comparison > 0) {
-      // Current version is newer (pre-release or local dev)
       console.log(`${latestVersion} (latest published)`);
     } else {
-      // Versions are equal
       console.log(`${latestVersion} (latest)`);
     }
   } else {
-    // Failed to fetch latest version
     console.log("(unable to check for updates)");
   }
 }

package/ts/xterm-proxy.ts

@@ -0,0 +1,130 @@
+import xterm from "@xterm/headless";
+const { Terminal } = xterm;
+import { logger } from "./logger.ts";
+
+/**
+ * XtermProxy wraps @xterm/headless to act as a full xterm terminal emulator
+ * between a PTY process and downstream consumers.
+ *
+ * It automatically responds to ALL terminal queries (DSR, DA, OSC, etc.)
+ * by piping xterm's onData responses back to the PTY — so the spawned
+ * process never blocks waiting for a terminal reply, even in non-TTY
+ * environments or when the real terminal is backgrounded.
+ */
+export class XtermProxy {
+  private term: Terminal;
+  private writeToPty: (data: string) => void;
+  private readableController: ReadableStreamDefaultController<string> | null = null;
+
+  /** Downstream readable — passthrough of PTY output for sflow pipeline */
+  readonly readable: ReadableStream<string>;
+
+  constructor(opts: { cols?: number; rows?: number; writeToPty: (data: string) => void }) {
+    const cols = opts.cols ?? 80;
+    const rows = opts.rows ?? 24;
+    this.writeToPty = opts.writeToPty;
+
+    this.term = new Terminal({
+      cols,
+      rows,
+      allowProposedApi: true,
+      scrollback: 10000,
+    });
+
+    // xterm internally generates responses to terminal queries (DSR, DA, etc.)
+    // and fires them via onData. Pipe those back to the PTY stdin.
+    this.term.onData((data) => {
+      logger.debug("xterm-proxy|onData response", data);
+      this.writeToPty(data);
+    });
+
+    // Create a ReadableStream for downstream consumption (sflow pipeline)
+    this.readable = new ReadableStream<string>({
+      start: (controller) => {
+        this.readableController = controller;
+      },
+    });
+  }
+
+  /**
+   * Feed PTY output into the xterm emulator.
+   * - xterm processes escape sequences and updates internal state
+   * - Terminal queries (ESC[6n, ESC[c, etc.) trigger onData → writeToPty
+   * - Raw data is pushed to readable for downstream consumption
+   */
+  write(data: string): void {
+    // Feed to xterm for state tracking and query auto-response first.
+    // xterm.write() is buffered/async, so only emit to downstream once the
+    // terminal state has been updated for this chunk.
+    this.term.write(data, () => {
+      try {
+        this.readableController?.enqueue(data);
+      } catch {
+        // Stream already closed/canceled — ignore
+      }
+    });
+  }
+
+  /** Get cursor position from xterm's buffer state */
+  getCursorPosition(): { row: number; col: number } {
+    const buf = this.term.buffer.active;
+    // xterm uses 0-based; terminal-render used 0-based too
+    return { row: buf.cursorY, col: buf.cursorX };
+  }
+
+  /**
+   * Get the last N lines of rendered terminal content (plain text, no ANSI).
+   * Equivalent to terminal-render's tail(n).
+   */
+  tail(n: number): string {
+    const buf = this.term.buffer.active;
+    const totalLines = buf.length;
+    const startLine = Math.max(0, totalLines - n);
+    const lines: string[] = [];
+    for (let i = startLine; i < totalLines; i++) {
+      const line = buf.getLine(i);
+      lines.push(line ? line.translateToString(true) : "");
+    }
+    // Trim trailing empty lines
+    while (lines.length > 1 && lines[lines.length - 1] === "") {
+      lines.pop();
+    }
+    return lines.join("\n");
+  }
+
+  /**
+   * Render the full terminal buffer as plain text.
+   * Equivalent to terminal-render's render().
+   */
+  render(): string {
+    const buf = this.term.buffer.active;
+    const lines: string[] = [];
+    for (let i = 0; i < buf.length; i++) {
+      const line = buf.getLine(i);
+      lines.push(line ? line.translateToString(true) : "");
+    }
+    // Trim trailing empty lines
+    while (lines.length > 1 && lines[lines.length - 1] === "") {
+      lines.pop();
+    }
+    return lines.join("\n");
+  }
+
+  /** Resize the virtual terminal */
+  resize(cols: number, rows: number): void {
+    this.term.resize(cols, rows);
+  }
+
+  /** Clean up resources */
+  dispose(): void {
+    if (this.readableController) {
+      try {
+        this.readableController.close();
+      } catch {
+        // Already closed
+      }
+      this.readableController = null;
+    }
+    this.term.dispose();
+  }
+}