agent-yes 1.72.4 → 1.73.0

package/ts/versionChecker.ts

@@ -1,5 +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";
@@ -50,8 +51,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;
@@ -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();
+  }
+}