agent-yes 1.72.4 → 1.73.2

package/ts/rustBinary.ts

@@ -2,9 +2,11 @@
  * Rust binary helper - finds or downloads the appropriate prebuilt binary
  */
 
+import { execFileSync } from "child_process";
 import { existsSync, mkdirSync, unlinkSync } from "fs";
 import { chmod, copyFile } from "fs/promises";
 import path from "path";
+import pkg from "../package.json" with { type: "json" };
 
 // Platform/arch to binary name mapping
 const PLATFORM_MAP: Record<string, string> = {
@@ -192,6 +194,70 @@ export async function downloadBinary(verbose = false): Promise<string> {
   return binaryPath;
 }
 
+/**
+ * Get the version of a Rust binary by running it with --version
+ */
+function getRustBinaryVersion(binaryPath: string): string | null {
+  try {
+    const output = execFileSync(binaryPath, ["--version"], {
+      timeout: 5000,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    // Output is like "agent-yes 1.72.3" or "agent-yes v1.72.3"
+    const match = output.match(/(\d+\.\d+\.\d+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if a binary path is inside a git repo (dev build), and rebuild if outdated.
+ * Returns the same path if up-to-date or rebuilt, undefined if rebuild failed.
+ */
+function autoRebuildIfOutdated(binaryPath: string, verbose: boolean): boolean {
+  // Only auto-rebuild for local dev builds (target/release or target/debug)
+  if (!binaryPath.includes("/target/release") && !binaryPath.includes("/target/debug")) {
+    return true; // not a dev build, skip
+  }
+
+  const binaryVersion = getRustBinaryVersion(binaryPath);
+  if (verbose) {
+    console.log(`[rust] Binary version: ${binaryVersion}, package version: ${pkg.version}`);
+  }
+
+  if (binaryVersion === pkg.version) {
+    return true; // up to date
+  }
+
+  // Find the rs/ directory relative to the binary (binary is at rs/target/release/agent-yes)
+  const rsDir = binaryPath.replace(/\/target\/(release|debug)\/agent-yes.*$/, "");
+  if (!existsSync(path.join(rsDir, "Cargo.toml"))) {
+    if (verbose) console.log(`[rust] Cannot find Cargo.toml at ${rsDir}, skipping rebuild`);
+    return true; // can't rebuild, use as-is
+  }
+
+  process.stderr.write(
+    `\x1b[33m[rust] Binary outdated (${binaryVersion ?? "unknown"} → ${pkg.version}), rebuilding…\x1b[0m\n`,
+  );
+
+  try {
+    const isRelease = binaryPath.includes("/target/release");
+    const args = ["build", ...(isRelease ? ["--release"] : [])];
+    execFileSync("cargo", args, {
+      cwd: rsDir,
+      stdio: "inherit",
+      timeout: 300_000, // 5 min max
+    });
+    process.stderr.write(`\x1b[32m[rust] Rebuild complete\x1b[0m\n`);
+    return true;
+  } catch {
+    process.stderr.write(`\x1b[31m[rust] Auto-rebuild failed, using outdated binary\x1b[0m\n`);
+    return true; // still usable, just old
+  }
+}
+
 /**
  * Get or download the Rust binary
  */
@@ -210,6 +276,8 @@ export async function getRustBinary(
       if (verbose) {
         console.log(`[rust] Using existing binary: ${existing}`);
       }
+      // Auto-rebuild if it's a dev build and version is outdated
+      autoRebuildIfOutdated(existing, verbose);
       return existing;
     }
   }

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,16 @@ 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
@@ -106,6 +118,14 @@ 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;
@@ -252,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,5 +1,5 @@
 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";
@@ -50,8 +50,15 @@ function detectPackageManager(): string {
 export async function checkAndAutoUpdate(): Promise<void> {
   if (process.env.AGENT_YES_NO_UPDATE) return;
 
-  // Prevent infinite re-exec: if we just updated to this version, skip
-  if (process.env.AGENT_YES_UPDATED === pkg.version) 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;
@@ -88,6 +95,7 @@ async function runInstall(latestVersion: string): Promise<boolean> {
 
   process.stderr.write(`\x1b[33m[agent-yes] Updating ${pkg.version} → ${latestVersion}…\x1b[0m\n`);
   try {
+    const { execaCommand } = await import("execa");
     await execaCommand(installCmd, { stdio: "inherit" });
     process.stderr.write(`\x1b[32m[agent-yes] Updated to ${latestVersion}\x1b[0m\n`);
     return true;
@@ -155,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();
+  }
+}

package/dist/logger-CX77vJDA.js

@@ -1,16 +0,0 @@
-import winston from "winston";
-
-//#region ts/logger.ts
-const logFormat = winston.format.combine(winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), winston.format.printf(({ timestamp, level, message, ...meta }) => {
-	return `${timestamp} [${level}]: ${message}${Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : ""}`;
-}));
-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
-});
-
-//#endregion
-export { logger as t };
-//# sourceMappingURL=logger-CX77vJDA.js.map