agent-sh 0.15.0 → 0.15.2

package/src/utils/diff.ts

@@ -0,0 +1,244 @@
+/**
+ * Line-level diff computation, powered by the `diff` npm package.
+ *
+ * Exposes a unified `DiffResult` interface consumed by the diff renderer.
+ * Three entry points cover the main use cases:
+ *
+ *   computeDiff       — full-file diff (write_file, or when edit region can't be located)
+ *   computeEditDiff   — edit_file: locates the edit region, builds the new file, full diff
+ *   computeInputDiff  — fast preview: diffs only old_text vs new_text, no file I/O
+ */
+
+import * as Diff from "diff";
+
+// ── Types ────────────────────────────────────────────────────────────
+
+export interface DiffLine {
+  type: "context" | "added" | "removed";
+  oldNo: number | null;
+  newNo: number | null;
+  text: string;
+}
+
+export interface DiffHunk {
+  lines: DiffLine[];
+}
+
+export interface DiffResult {
+  hunks: DiffHunk[];
+  added: number;
+  removed: number;
+  isIdentical: boolean;
+  isNewFile: boolean;
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+/**
+ * Convert a `diff` library Change[] into our DiffLine[], tracking real
+ * old/new line numbers.
+ */
+function changesToDiffLines(changes: Diff.Change[]): DiffLine[] {
+  const result: DiffLine[] = [];
+  let oldNo = 0;
+  let newNo = 0;
+
+  for (const change of changes) {
+    const lines = change.value.replace(/\n$/, "").split("\n");
+    for (const text of lines) {
+      if (change.added) {
+        newNo++;
+        result.push({ type: "added", oldNo: null, newNo, text });
+      } else if (change.removed) {
+        oldNo++;
+        result.push({ type: "removed", oldNo, newNo: null, text });
+      } else {
+        oldNo++;
+        newNo++;
+        result.push({ type: "context", oldNo, newNo, text });
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Group raw DiffLines into hunks with `context` lines of surrounding context.
+ */
+function groupHunks(lines: DiffLine[], ctx: number): DiffHunk[] {
+  const changeIdx: number[] = [];
+  for (let i = 0; i < lines.length; i++)
+    if (lines[i].type !== "context") changeIdx.push(i);
+
+  if (changeIdx.length === 0) return [];
+
+  const hunks: DiffHunk[] = [];
+  let start = Math.max(0, changeIdx[0]! - ctx);
+  let end = Math.min(lines.length - 1, changeIdx[0]! + ctx);
+
+  for (let k = 1; k < changeIdx.length; k++) {
+    const ns = Math.max(0, changeIdx[k]! - ctx);
+    const ne = Math.min(lines.length - 1, changeIdx[k]! + ctx);
+    if (ns <= end + 1) {
+      end = ne;
+    } else {
+      hunks.push({ lines: lines.slice(start, end + 1) });
+      start = ns;
+      end = ne;
+    }
+  }
+  hunks.push({ lines: lines.slice(start, end + 1) });
+  return hunks;
+}
+
+function countChanges(lines: DiffLine[]): { added: number; removed: number } {
+  let added = 0;
+  let removed = 0;
+  for (const l of lines) {
+    if (l.type === "added") added++;
+    else if (l.type === "removed") removed++;
+  }
+  return { added, removed };
+}
+
+// ── Public API ───────────────────────────────────────────────────────
+
+/**
+ * Compute a line-level diff between old and new file content.
+ */
+export function computeDiff(
+  oldText: string | null,
+  newText: string,
+): DiffResult {
+  // New file — everything is an addition
+  if (oldText === null) {
+    const lines = newText.split("\n");
+    return {
+      hunks: [
+        {
+          lines: lines.map((text, i) => ({
+            type: "added" as const,
+            oldNo: null,
+            newNo: i + 1,
+            text,
+          })),
+        },
+      ],
+      added: lines.length,
+      removed: 0,
+      isIdentical: false,
+      isNewFile: true,
+    };
+  }
+
+  // Identical — nothing to show
+  if (oldText === newText) {
+    return { hunks: [], added: 0, removed: 0, isIdentical: true, isNewFile: false };
+  }
+
+  const changes = Diff.diffLines(oldText, newText);
+  const raw = changesToDiffLines(changes);
+  const { added, removed } = countChanges(raw);
+
+  return {
+    hunks: groupHunks(raw, 3),
+    added,
+    removed,
+    isIdentical: false,
+    isNewFile: false,
+  };
+}
+
+/**
+ * Compute a diff for an edit operation where we know the old/new text.
+ * Locates the edit region(s) in the file, constructs the full new file,
+ * then diffs the whole thing so line numbers are file-relative.
+ */
+export function computeEditDiff(
+  oldFileText: string,
+  editOld: string,
+  editNew: string,
+  replaceAll = false,
+): DiffResult {
+  const a = oldFileText.split("\n");
+  const editOldLines = editOld.split("\n");
+  const editNewLines = editNew.split("\n");
+
+  // Find all occurrences of editOld in the file
+  const regions: { start: number; end: number }[] = [];
+  if (replaceAll) {
+    let i = 0;
+    while (i <= a.length - editOldLines.length) {
+      let match = true;
+      for (let k = 0; k < editOldLines.length; k++) {
+        if (a[i + k] !== editOldLines[k]) { match = false; break; }
+      }
+      if (match) {
+        regions.push({ start: i, end: i + editOldLines.length });
+        i += editOldLines.length;
+      } else {
+        i++;
+      }
+    }
+  } else {
+    for (let i = 0; i <= a.length - editOldLines.length; i++) {
+      let match = true;
+      for (let k = 0; k < editOldLines.length; k++) {
+        if (a[i + k] !== editOldLines[k]) { match = false; break; }
+      }
+      if (match) {
+        regions.push({ start: i, end: i + editOldLines.length });
+        break;
+      }
+    }
+  }
+
+  // Build the full new file
+  let newFile: string[];
+  if (replaceAll && regions.length > 0) {
+    const parts: string[] = [];
+    let last = 0;
+    for (const r of regions) {
+      parts.push(...a.slice(last, r.start));
+      parts.push(...editNewLines);
+      last = r.end;
+    }
+    parts.push(...a.slice(last));
+    newFile = parts;
+  } else if (regions.length === 1) {
+    const r = regions[0]!;
+    newFile = [...a.slice(0, r.start), ...editNewLines, ...a.slice(r.end)];
+  } else {
+    // Couldn't locate edit — fall back to string replace + full diff
+    const newContent = replaceAll
+      ? oldFileText.split(editOld).join(editNew)
+      : oldFileText.replace(editOld, editNew);
+    return computeDiff(oldFileText, newContent);
+  }
+
+  return computeDiff(oldFileText, newFile.join("\n"));
+}
+
+/**
+ * Diff two edit strings directly — no file read needed.
+ * Line numbers are relative to the edit region, not the file.
+ * Use for permission prompt previews where speed matters more than
+ * exact file-relative line numbers.
+ */
+export function computeInputDiff(
+  oldText: string,
+  newText: string,
+): DiffResult {
+  const changes = Diff.diffLines(oldText, newText);
+  const raw = changesToDiffLines(changes);
+  const { added, removed } = countChanges(raw);
+
+  return {
+    hunks: groupHunks(raw, 3),
+    added,
+    removed,
+    isIdentical: false,
+    isNewFile: false,
+  };
+}

package/src/utils/executor.ts

@@ -0,0 +1,305 @@
+import { spawn, spawnSync, type ChildProcess } from "node:child_process";
+import { existsSync } from "node:fs";
+import { stripAnsi } from "./ansi.js";
+
+// Node reports a missing cwd as `spawn <binary> ENOENT` — disambiguate.
+function explainSpawnError(err: NodeJS.ErrnoException, cwd: string): string {
+  if (err.code === "ENOENT" && !existsSync(cwd)) {
+    return `cwd no longer exists: ${cwd} (${err.message})`;
+  }
+  return err.message;
+}
+
+let cachedBashPath: string | null | undefined;
+
+/** Resolve a usable bash binary, or null if none is on PATH.
+ *  Unix: `/bin/bash` (canonical, present on every Linux/macOS install).
+ *  Windows: probe via `where bash` so Git Bash users keep working. */
+export function findBash(): string | null {
+  if (cachedBashPath !== undefined) return cachedBashPath;
+  if (process.platform !== "win32") {
+    cachedBashPath = "/bin/bash";
+    return cachedBashPath;
+  }
+  const r = spawnSync("where", ["bash"], { encoding: "utf-8" });
+  cachedBashPath = r.status === 0 ? r.stdout.split(/\r?\n/)[0]!.trim() || null : null;
+  return cachedBashPath;
+}
+
+const DEFAULT_TIMEOUT = 60_000;
+const DEFAULT_MAX_OUTPUT = 256 * 1024; // 256KB
+
+export interface ExecutorSession {
+  id: string;
+  command: string;
+  output: string;          // accumulated, ANSI-stripped
+  exitCode: number | null;
+  done: boolean;
+  truncated: boolean;
+  /** True when the binary couldn't be launched (ENOENT, EACCES). Lets callers
+   *  distinguish "tool missing" from "tool ran and exited with -1". */
+  spawnFailed: boolean;
+  process: ChildProcess | null;
+  resolve?: () => void;
+}
+
+
+/**
+ * Spawn a command in an isolated child process with piped I/O.
+ * Does NOT use the user's PTY — completely separate process.
+ */
+export function executeCommand(opts: {
+  command: string;
+  cwd: string;
+  env?: Record<string, string>;
+  timeout?: number;
+  maxOutputBytes?: number;
+  onOutput?: (chunk: string) => void;
+}): { session: ExecutorSession; done: Promise<void> } {
+  const timeout = opts.timeout ?? DEFAULT_TIMEOUT;
+  const maxOutput = opts.maxOutputBytes ?? DEFAULT_MAX_OUTPUT;
+
+  const session: ExecutorSession = {
+    id: "",
+    command: opts.command,
+    output: "",
+    exitCode: null,
+    done: false,
+    truncated: false,
+    spawnFailed: false,
+    process: null,
+  };
+
+  const done = new Promise<void>((resolve) => {
+    session.resolve = resolve;
+  });
+
+  // Build env — filter undefined values
+  const env: Record<string, string> = {};
+  const source = opts.env ?? process.env;
+  for (const [k, v] of Object.entries(source)) {
+    if (v !== undefined) env[k] = v;
+  }
+
+  const bashPath = findBash();
+  let child: ChildProcess;
+  try {
+    if (!bashPath) throw new Error("bash not found on PATH");
+    child = spawn(bashPath, ["-c", opts.command], {
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd: opts.cwd,
+      env,
+      detached: process.platform !== "win32",
+      windowsHide: true,
+    });
+  } catch (err) {
+    session.exitCode = -1;
+    session.spawnFailed = true;
+    const msg = err instanceof Error
+      ? explainSpawnError(err as NodeJS.ErrnoException, opts.cwd)
+      : String(err);
+    session.output = `Failed to spawn: ${msg}`;
+    session.done = true;
+    session.resolve?.();
+    return { session, done };
+  }
+
+  session.process = child;
+
+  const handleData = (data: Buffer) => {
+    const raw = data.toString("utf-8");
+    const clean = stripAnsi(raw);
+
+    // Accumulate cleaned output for the agent
+    session.output += clean;
+
+    // Enforce output cap — truncate from beginning, keep tail
+    if (session.output.length > maxOutput) {
+      session.output = session.output.slice(-maxOutput);
+      session.truncated = true;
+    }
+
+    // Real-time streaming callback
+    opts.onOutput?.(raw);
+  };
+
+  child.stdout?.on("data", handleData);
+  child.stderr?.on("data", handleData);
+
+  let cancelKill: (() => void) | undefined;
+  const timer = setTimeout(() => {
+    if (!session.done) {
+      cancelKill = killSession(session);
+    }
+  }, timeout);
+
+  child.on("exit", (code, signal) => {
+    clearTimeout(timer);
+    cancelKill?.();
+    session.exitCode = code ?? (signal ? -1 : null);
+    session.done = true;
+    session.process = null;
+    session.resolve?.();
+  });
+
+  child.on("error", (err) => {
+    clearTimeout(timer);
+    cancelKill?.();
+    if (!session.done) {
+      session.exitCode = -1;
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code === "ENOENT" || code === "EACCES") session.spawnFailed = true;
+      session.output += `\nProcess error: ${explainSpawnError(err as NodeJS.ErrnoException, opts.cwd)}`;
+      session.done = true;
+      session.process = null;
+      session.resolve?.();
+    }
+  });
+
+  return { session, done };
+}
+
+/**
+ * Spawn a binary directly (no shell). Use for invoking known tools like `rg`
+ * with structured args — avoids shell-quoting bugs and works on platforms
+ * without /bin/bash.
+ */
+export function executeArgv(opts: {
+  file: string;
+  args: string[];
+  cwd: string;
+  env?: Record<string, string>;
+  timeout?: number;
+  maxOutputBytes?: number;
+  onOutput?: (chunk: string) => void;
+}): { session: ExecutorSession; done: Promise<void> } {
+  const timeout = opts.timeout ?? DEFAULT_TIMEOUT;
+  const maxOutput = opts.maxOutputBytes ?? DEFAULT_MAX_OUTPUT;
+
+  const session: ExecutorSession = {
+    id: "",
+    command: `${opts.file} ${opts.args.join(" ")}`,
+    output: "",
+    exitCode: null,
+    done: false,
+    truncated: false,
+    spawnFailed: false,
+    process: null,
+  };
+
+  const done = new Promise<void>((resolve) => {
+    session.resolve = resolve;
+  });
+
+  const env: Record<string, string> = {};
+  const source = opts.env ?? process.env;
+  for (const [k, v] of Object.entries(source)) {
+    if (v !== undefined) env[k] = v;
+  }
+
+  let child: ChildProcess;
+  try {
+    child = spawn(opts.file, opts.args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd: opts.cwd,
+      env,
+    });
+  } catch (err) {
+    session.exitCode = -1;
+    session.spawnFailed = true;
+    const msg = err instanceof Error
+      ? explainSpawnError(err as NodeJS.ErrnoException, opts.cwd)
+      : String(err);
+    session.output = `Failed to spawn ${opts.file}: ${msg}`;
+    session.done = true;
+    session.resolve?.();
+    return { session, done };
+  }
+
+  session.process = child;
+
+  const handleData = (data: Buffer) => {
+    const raw = data.toString("utf-8");
+    const clean = stripAnsi(raw);
+    session.output += clean;
+    if (session.output.length > maxOutput) {
+      session.output = session.output.slice(-maxOutput);
+      session.truncated = true;
+    }
+    opts.onOutput?.(raw);
+  };
+
+  child.stdout?.on("data", handleData);
+  child.stderr?.on("data", handleData);
+
+  const timer = setTimeout(() => {
+    if (!session.done && session.process) {
+      try { session.process.kill("SIGTERM"); } catch {}
+      setTimeout(() => {
+        if (!session.done && session.process) {
+          try { session.process.kill("SIGKILL"); } catch {}
+        }
+      }, 5000).unref();
+    }
+  }, timeout);
+
+  child.on("exit", (code, signal) => {
+    clearTimeout(timer);
+    session.exitCode = code ?? (signal ? -1 : null);
+    session.done = true;
+    session.process = null;
+    session.resolve?.();
+  });
+
+  child.on("error", (err) => {
+    clearTimeout(timer);
+    if (!session.done) {
+      session.exitCode = -1;
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code === "ENOENT" || code === "EACCES") session.spawnFailed = true;
+      session.output += `\nProcess error: ${explainSpawnError(err as NodeJS.ErrnoException, opts.cwd)}`;
+      session.done = true;
+      session.process = null;
+      session.resolve?.();
+    }
+  });
+
+  return { session, done };
+}
+
+/**
+ * Kill a running session's process group: SIGTERM, then SIGKILL after 5s.
+ * Returns a cleanup that cancels the pending SIGKILL — callers should invoke
+ * it once the process has exited.
+ */
+export function killSession(session: ExecutorSession): () => void {
+  const proc = session.process;
+  if (!proc || !proc.pid) return () => {};
+
+  // Try process-group kill first (works for executeCommand's detached bash
+  // children on Unix); fall back to direct kill (executeArgv's non-detached
+  // spawn, and Windows where negative pids aren't supported).
+  if (process.platform !== "win32") {
+    try { process.kill(-proc.pid, "SIGTERM"); } catch {}
+  }
+  try { proc.kill("SIGTERM"); } catch {}
+
+  let settled = false;
+  const fallback = setTimeout(() => {
+    if (!settled && !session.done && proc.pid) {
+      if (process.platform !== "win32") {
+        try { process.kill(-proc.pid, "SIGKILL"); } catch {}
+      }
+      try { proc.kill("SIGKILL"); } catch {}
+    }
+  }, 5000);
+
+  fallback.unref();
+
+  return () => {
+    if (!settled) {
+      settled = true;
+      clearTimeout(fallback);
+    }
+  };
+}

package/src/utils/file-watcher.ts

@@ -0,0 +1,110 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export interface FileChange {
+  path: string;
+  relPath: string;
+  before: string;
+  after: string;
+}
+
+const SKIP_DIRS = new Set([
+  ".git", "node_modules", "dist", "build", ".next",
+  "__pycache__", ".venv", "vendor", ".cache", ".turbo",
+]);
+const MAX_FILES = 200;
+const MAX_FILE_SIZE = 100_000; // 100 KB
+
+/**
+ * Snapshots the working directory before an agent prompt so that
+ * file modifications made by **any** method (ACP writeTextFile,
+ * the agent's own edit tools, shell commands, etc.) can be detected
+ * and shown as an interactive diff preview.
+ */
+export class FileWatcher {
+  private cwd: string;
+  private baseline = new Map<string, string>();
+
+  constructor(cwd: string) {
+    this.cwd = cwd;
+  }
+
+  /**
+   * Recursively snapshot all text files in the working directory.
+   * Skips common non-source directories, binary files, and files
+   * exceeding MAX_FILE_SIZE.  Capped at MAX_FILES entries.
+   */
+  async snapshot(): Promise<void> {
+    this.baseline.clear();
+    let count = 0;
+
+    const walk = async (dir: string) => {
+      if (count >= MAX_FILES) return;
+      let entries;
+      try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (count >= MAX_FILES) return;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (!SKIP_DIRS.has(entry.name)) await walk(full);
+        } else if (entry.isFile()) {
+          try {
+            const stat = await fs.stat(full);
+            if (stat.size > MAX_FILE_SIZE || stat.size === 0) continue;
+            const content = await fs.readFile(full, "utf-8");
+            this.baseline.set(full, content);
+            count++;
+          } catch {
+            // Skip binary / unreadable files
+          }
+        }
+      }
+    };
+
+    await walk(this.cwd);
+  }
+
+  /** Update baseline after a write is approved (avoids double-reporting). */
+  approve(absPath: string, content: string): void {
+    this.baseline.set(absPath, content);
+  }
+
+  /** Detect all tracked files whose on-disk content differs from baseline. */
+  async detectChanges(): Promise<FileChange[]> {
+    const changes: FileChange[] = [];
+    for (const [absPath, baseline] of this.baseline) {
+      let after: string;
+      try {
+        after = await fs.readFile(absPath, "utf-8");
+      } catch {
+        continue;
+      }
+      if (baseline !== after) {
+        changes.push({
+          path: absPath,
+          relPath: path.relative(this.cwd, absPath),
+          before: baseline,
+          after,
+        });
+      }
+    }
+    return changes;
+  }
+
+  /** Revert a file to its baseline content. */
+  async revert(absPath: string): Promise<void> {
+    const baseline = this.baseline.get(absPath);
+    if (baseline !== undefined) {
+      await fs.writeFile(absPath, baseline, "utf-8");
+    }
+  }
+
+  /** Clear all tracking state. */
+  reset(): void {
+    this.baseline.clear();
+  }
+}