agent-sh 0.15.0 → 0.15.2

package/src/shell/strategies/zsh.ts

@@ -0,0 +1,92 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { ShellStrategy, PrepareSpawnOpts, ShellSpawnConfig } from "./types.js";
+
+const OSC7_CMD = 'printf "\\e]7;file://%s%s\\a" "$(hostname)" "$PWD"';
+const TITLE_CMD = 'printf "\\e]0;⚡ agent-sh: %s\\a" "${PWD/#$HOME/~}"';
+
+export const zshStrategy: ShellStrategy = {
+  name: "zsh",
+
+  matches(shellPath: string): boolean {
+    return path.basename(shellPath).includes("zsh");
+  },
+
+  prepareSpawn(opts: PrepareSpawnOpts): ShellSpawnConfig {
+    const { tmpDirRoot, instanceTag, showIndicator, env, userHome } = opts;
+
+    // Use ZDOTDIR to source user's real config, then append our hooks via
+    // precmd_functions (additive — doesn't clobber p10k/omz).
+    const tmpDir = fs.mkdtempSync(path.join(tmpDirRoot, "agent-sh-"));
+    const userZdotdir = env.ZDOTDIR || env.HOME || userHome;
+    const promptMarker = `printf "\\e]9999;${instanceTag};PROMPT\\a"`;
+
+    const lines = [
+      `ZDOTDIR="${userZdotdir}"`,
+      `[ -f "${userZdotdir}/.zshrc" ] && source "${userZdotdir}/.zshrc"`,
+      "",
+      "# agent-sh hooks (invisible OSC sequences for cwd + prompt detection)",
+      "__agent_sh_precmd() {",
+      `  ${OSC7_CMD}`,
+      `  ${promptMarker}`,
+      ...(showIndicator ? [`  ${TITLE_CMD}`] : []),
+      "}",
+      "precmd_functions+=(__agent_sh_precmd)",
+      "",
+      "# Preexec hook: emit actual command text so agent-sh can track",
+      "# history-recalled and tab-completed commands accurately",
+      "__agent_sh_preexec() {",
+      `  printf "\\e]9997;${instanceTag};%s\\a" "$1"`,
+      "}",
+      "preexec_functions+=(__agent_sh_preexec)",
+      "",
+      "# End-of-prompt marker via zle-line-init (fires after prompt is rendered)",
+      "# Chain onto existing widget (p10k uses zle-line-init) rather than clobbering",
+      'if (( ${+widgets[zle-line-init]} )); then',
+      "  zle -A zle-line-init __agent_sh_orig_line_init",
+      "  __agent_sh_line_init() {",
+      "    zle __agent_sh_orig_line_init",
+      `    printf "\\e]9998;${instanceTag};READY\\a"`,
+      "  }",
+      "else",
+      "  __agent_sh_line_init() {",
+      `    printf "\\e]9998;${instanceTag};READY\\a"`,
+      "  }",
+      "fi",
+      "zle -N zle-line-init __agent_sh_line_init",
+      "",
+      "# Hidden widget to trigger prompt redraw from Node.js side",
+      "# Bound to an unused escape sequence that no real key produces",
+      "__agent_sh_redraw() {",
+      "  zle reset-prompt",
+      "}",
+      "zle -N __agent_sh_redraw",
+      "bindkey '\\e[9999~' __agent_sh_redraw",
+    ];
+
+    fs.writeFileSync(path.join(tmpDir, ".zshrc"), lines.join("\n") + "\n");
+
+    return {
+      args: ["--no-globalrcs"],
+      envOverrides: { ZDOTDIR: tmpDir },
+      tmpDir,
+    };
+  },
+
+  envCaptureCommand(): string {
+    return "source ~/.zshrc 2>/dev/null; env -0";
+  },
+
+  redrawEscape(): string {
+    return "\x1b[9999~";
+  },
+
+  cleanOutput(raw: string): string {
+    return raw.replace(PROMPT_SP_RE, "");
+  },
+};
+
+/** PROMPT_SP marker (inverse-video PROMPT_EOL_MARK, default `%`) zsh prints
+ *  before a prompt when prior output didn't end at column 0. Matching the
+ *  inverse-video wrapper preserves legitimate trailing `%`. */
+const PROMPT_SP_RE = /\x1b\[7m.\x1b\[(?:0|27)m/g;

package/src/shell/terminal.ts

@@ -0,0 +1,124 @@
+/**
+ * Terminal — the user-facing I/O endpoint that a Shell talks to.
+ *
+ * Shell wraps a *pseudo*-terminal (the PTY the child shell sees). This
+ * interface is the *real* terminal (or its substitute) on the other end:
+ * bytes in, bytes out, dimensions, resize notifications. The default
+ * factory wires it to process.stdin/stdout for the CLI; headless hosts
+ * (multi-session web hubs, tests) supply their own.
+ */
+import type { RenderSurface } from "../utils/compositor.js";
+
+export interface Terminal {
+  write(data: string): void;
+  onInput(cb: (data: string) => void): () => void;
+  onResize(cb: (cols: number, rows: number) => void): () => void;
+  cols(): number;
+  rows(): number;
+  /**
+   * Called around PTY spawn to avoid TTY contention: the child PTY becomes
+   * the controlling tty for the spawned shell. No-op when the terminal
+   * isn't a real tty.
+   */
+  suspendInput?(): { resume(): void };
+}
+
+/** Default Terminal: wraps process.stdin/stdout. */
+export function processTerminal(): Terminal {
+  return {
+    write(data) {
+      if (process.stdout.writable) {
+        try { process.stdout.write(data); } catch { /* ignore */ }
+      }
+    },
+    onInput(cb) {
+      const handler = (b: Buffer) => cb(b.toString("utf-8"));
+      process.stdin.on("data", handler);
+      return () => { process.stdin.off("data", handler); };
+    },
+    onResize(cb) {
+      const handler = () => cb(process.stdout.columns || 80, process.stdout.rows || 24);
+      process.stdout.on("resize", handler);
+      return () => { process.stdout.off("resize", handler); };
+    },
+    cols() { return process.stdout.columns || 80; },
+    rows() { return process.stdout.rows || 24; },
+    suspendInput() {
+      const wasRaw = process.stdin.isTTY && (process.stdin as { isRaw?: boolean }).isRaw;
+      if (process.stdin.isTTY) {
+        try {
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+        } catch { /* ignore */ }
+      }
+      return {
+        resume() {
+          if (process.stdin.isTTY) {
+            try {
+              process.stdin.resume();
+              if (wasRaw) process.stdin.setRawMode(true);
+            } catch { /* ignore */ }
+          }
+        },
+      };
+    },
+  };
+}
+
+/**
+ * No-op terminal for non-rendering hosts (tests, agent-only embeds).
+ * Writes are discarded; input/resize never fire.
+ */
+export function headlessTerminal(cols = 100, rows = 30): Terminal {
+  return {
+    write() {},
+    onInput: () => () => {},
+    onResize: () => () => {},
+    cols: () => cols,
+    rows: () => rows,
+  };
+}
+
+/**
+ * Pipe-based terminal for embedders that own their own renderer (web hubs
+ * via xterm.js, electron windows, recording harnesses). Bytes from the
+ * Shell flow through `onWrite`; the host drives `pushInput`/`pushResize`
+ * to forward keystrokes and viewport changes back.
+ */
+export class BridgedTerminal implements Terminal {
+  private inputCbs = new Set<(d: string) => void>();
+  private resizeCbs = new Set<(c: number, r: number) => void>();
+  private _cols: number;
+  private _rows: number;
+  constructor(private readonly onWrite: (data: string) => void, cols = 100, rows = 30) {
+    this._cols = cols;
+    this._rows = rows;
+  }
+  write(data: string): void { this.onWrite(data); }
+  onInput(cb: (d: string) => void): () => void { this.inputCbs.add(cb); return () => { this.inputCbs.delete(cb); }; }
+  onResize(cb: (c: number, r: number) => void): () => void { this.resizeCbs.add(cb); return () => { this.resizeCbs.delete(cb); }; }
+  cols(): number { return this._cols; }
+  rows(): number { return this._rows; }
+  pushInput(data: string): void { for (const cb of this.inputCbs) cb(data); }
+  pushResize(cols: number, rows: number): void {
+    this._cols = cols;
+    this._rows = rows;
+    for (const cb of this.resizeCbs) cb(cols, rows);
+  }
+}
+
+/**
+ * Adapt a Terminal to a RenderSurface (the compositor's sink type). Adds
+ * the OPOST-cleared `\n` → `\r\n` translation that StdoutSurface applies,
+ * since the PTY has OPOST disabled.
+ */
+export function surfaceFromTerminal(terminal: Terminal): RenderSurface {
+  const write = (text: string) => terminal.write(text.replace(/(?<!\r)\n/g, "\r\n"));
+  return {
+    write,
+    writeLine: (line) => write(line + "\n"),
+    get columns() { return terminal.cols(); },
+    get rows() { return terminal.rows(); },
+    onResize: (cb) => terminal.onResize(cb),
+  };
+}

package/src/shell/tui-input-view.ts

@@ -0,0 +1,222 @@
+/**
+ * Terminal renderer for the input-mode prompt and autocomplete dropdown.
+ * Owns screen state (cursor row/col, autocomplete line count) and the
+ * ANSI redraw. The controller drives it via a small VM shape.
+ */
+
+import { visibleLen, truncateToWidth } from "../utils/ansi.js";
+import { palette as p } from "../utils/palette.js";
+import type { RenderSurface } from "../utils/compositor.js";
+import { StdoutSurface } from "../utils/compositor.js";
+
+export interface PromptVM {
+  showBuffer: boolean;
+  displayText: string;
+  displayCursor: number;
+  indicator: string;
+  promptIcon: string;
+  agentInfo: { info: string };
+}
+
+export interface AutocompleteVM {
+  items: { name: string; description: string }[];
+  selected: number;
+}
+
+export class TuiInputView {
+  private cursorRowsBelow = 0;
+  private cursorTermCol = 1;
+  private autocompleteLines = 0;
+  private readonly surface: RenderSurface;
+  private frameBuf: string | null = null;
+
+  constructor(surface?: RenderSurface) {
+    this.surface = surface ?? new StdoutSurface();
+  }
+
+  // Frame buffering: coalesces all emit() calls until endFrame() into one
+  // surface.write, bracketed by cursor hide/show so intermediate redraw
+  // states never flicker through.
+  beginFrame(): void {
+    if (this.frameBuf === null) this.frameBuf = "\x1b[?25l";
+  }
+
+  endFrame(): void {
+    if (this.frameBuf === null) return;
+    const out = this.frameBuf + "\x1b[?25h";
+    this.frameBuf = null;
+    this.surface.write(out);
+  }
+
+  private emit(s: string): void {
+    if (this.frameBuf !== null) this.frameBuf += s;
+    else this.surface.write(s);
+  }
+
+  private autoFrame<T>(fn: () => T): T {
+    const owned = this.frameBuf === null;
+    if (owned) this.beginFrame();
+    try { return fn(); } finally { if (owned) this.endFrame(); }
+  }
+
+  resetCursor(): void {
+    this.cursorRowsBelow = 0;
+    this.cursorTermCol = 1;
+  }
+
+  enableModeKeys(): void {
+    // Kitty progressive enhancement + bracket paste (Shift+Enter → \x1b[13;2u).
+    this.emit("\x1b[>1u\x1b[?2004h");
+  }
+
+  disableModeKeys(): void {
+    this.emit("\x1b[<u\x1b[?2004l");
+  }
+
+  clearPromptArea(): void {
+    this.autoFrame(() => {
+      if (this.cursorRowsBelow > 0) {
+        this.emit(`\x1b[${this.cursorRowsBelow}A`);
+      }
+      this.emit("\r\x1b[J");
+      this.cursorRowsBelow = 0;
+    });
+  }
+
+  drawPrompt(vm: PromptVM): void {
+    this.autoFrame(() => {
+      const termW = this.surface.columns;
+
+      if (this.cursorRowsBelow > 0) {
+        this.emit(`\x1b[${this.cursorRowsBelow}A`);
+      }
+      this.emit("\r\x1b[J");
+
+      const infoPrefix = vm.agentInfo.info
+        ? `${vm.agentInfo.info} ${p.success}${vm.indicator}${p.reset} `
+        : `${p.success}${vm.indicator}${p.reset} `;
+      const promptPrefix = infoPrefix + p.warning + p.bold + vm.promptIcon + " " + p.reset;
+      const promptVisLen = visibleLen(infoPrefix) + visibleLen(vm.promptIcon) + 1;
+
+      const display = vm.showBuffer ? vm.displayText : "";
+      const dCursor = vm.showBuffer ? vm.displayCursor : 0;
+
+      if (!vm.showBuffer) {
+        this.emit(promptPrefix);
+        const N = promptVisLen;
+        this.cursorRowsBelow = N > 0 ? Math.ceil(N / termW) - 1 : 0;
+        this.cursorTermCol = N === 0 ? 1 : (N % termW === 0 ? termW : (N % termW) + 1);
+      } else if (!display.includes("\n")) {
+        // DECSC/DECRC bracket the after-cursor text so the cursor lands mid-line.
+        const before = display.slice(0, dCursor);
+        const after = display.slice(dCursor);
+        this.emit(
+          promptPrefix + p.accent + before + p.reset +
+          "\x1b7" +
+          p.accent + after + p.reset +
+          "\x1b8"
+        );
+        const cursorVisCol = promptVisLen + visibleLen(before);
+        this.cursorRowsBelow = cursorVisCol > 0 ? Math.ceil(cursorVisCol / termW) - 1 : 0;
+        this.cursorTermCol = cursorVisCol === 0 ? 1 : (cursorVisCol % termW === 0 ? termW : (cursorVisCol % termW) + 1);
+      } else {
+        const lines = display.split("\n");
+        const indent = " ".repeat(promptVisLen);
+
+        let charsRemaining = dCursor;
+        let cursorLine = 0;
+        for (let li = 0; li < lines.length; li++) {
+          if (charsRemaining <= lines[li]!.length) {
+            cursorLine = li;
+            break;
+          }
+          charsRemaining -= lines[li]!.length + 1;
+          cursorLine = li + 1;
+        }
+
+        let output = "";
+        let cursorRowFromTop = 0;
+        let rowsSoFar = 0;
+
+        for (let li = 0; li < lines.length; li++) {
+          const prefix = li === 0 ? promptPrefix : indent;
+          const lineText = lines[li]!;
+          const lineVisLen = promptVisLen + visibleLen(lineText);
+          const lineTermRows = lineVisLen > 0 ? Math.ceil(lineVisLen / termW) : 1;
+
+          if (li === cursorLine) {
+            const before = lineText.slice(0, charsRemaining);
+            const after = lineText.slice(charsRemaining);
+            output += prefix + p.accent + before + p.reset;
+            output += "\x1b7";
+            output += p.accent + after + p.reset;
+
+            const beforeVisCol = promptVisLen + visibleLen(before);
+            cursorRowFromTop = rowsSoFar + (beforeVisCol > 0 ? Math.ceil(beforeVisCol / termW) - 1 : 0);
+            this.cursorTermCol = beforeVisCol === 0 ? 1 : (beforeVisCol % termW === 0 ? termW : (beforeVisCol % termW) + 1);
+          } else {
+            output += prefix + p.accent + lineText + p.reset;
+          }
+
+          if (li < lines.length - 1) output += "\n";
+          rowsSoFar += lineTermRows;
+        }
+
+        this.emit(output + "\x1b8");
+        this.cursorRowsBelow = cursorRowFromTop;
+      }
+    });
+  }
+
+  drawAutocomplete(vm: AutocompleteVM): void {
+    if (vm.items.length === 0) return;
+    this.autoFrame(() => {
+      // Truncate descriptions so each row fits one physical line — a wrapped
+      // row makes autocompleteLines undercount, clearAutocomplete leaves a
+      // residual row, and the next drawPrompt redraws below the original
+      // prompt (staircase).
+      const termW = this.surface.columns;
+      const lines: string[] = [];
+      for (let i = 0; i < vm.items.length; i++) {
+        const item = vm.items[i]!;
+        const nameW = Math.max(12, visibleLen(item.name));
+        const overhead = 5 + nameW;
+        const descBudget = Math.max(1, termW - overhead);
+        const desc = visibleLen(item.description) > descBudget
+          ? truncateToWidth(item.description, descBudget)
+          : item.description;
+        const selected = i === vm.selected;
+        if (selected) {
+          lines.push(
+            `  \x1b[7m ${p.accent}${item.name.padEnd(12)}${p.reset}\x1b[7m ${desc} ${p.reset}`
+          );
+        } else {
+          lines.push(
+            `   ${p.muted}${item.name.padEnd(12)} ${desc}${p.reset}`
+          );
+        }
+      }
+
+      this.emit("\n" + lines.join("\n"));
+      this.autocompleteLines = lines.length;
+
+      if (this.autocompleteLines > 0) {
+        this.emit(`\x1b[${this.autocompleteLines}A`);
+      }
+      // Absolute column set — preceding \n may have scrolled, invalidating DECSC.
+      this.emit(`\x1b[${this.cursorTermCol}G`);
+    });
+  }
+
+  clearAutocomplete(): void {
+    if (this.autocompleteLines <= 0) return;
+    this.autoFrame(() => {
+      // CSI B (cursor down, bounded) so we don't scroll on the last row.
+      for (let i = 0; i < this.autocompleteLines; i++) {
+        this.emit("\x1b[B\x1b[2K");
+      }
+      this.emit(`\x1b[${this.autocompleteLines}A\x1b[${this.cursorTermCol}G`);
+      this.autocompleteLines = 0;
+    });
+  }
+}