agent-sh 0.15.0 → 0.15.2

package/src/shell/index.ts

@@ -0,0 +1,159 @@
+/**
+ * Frontend bootstrap. Loaded directly from src/cli/index.ts (not the
+ * built-in extensions manifest) because PTY + stdin raw mode ownership is
+ * order-critical.
+ */
+import "./events.js"; // augments BusEvents with shell-owned events
+import type { ExtensionContext, RemoteSession, RemoteSessionOptions, ShellSurface } from "./host-types.js";
+import type { EventBus } from "../core/event-bus.js";
+import { Shell } from "./shell.js";
+import { DefaultCompositor } from "../utils/compositor.js";
+import { TerminalBuffer } from "../utils/terminal-buffer.js";
+import { FloatingPanel, type FloatingPanelConfig } from "../utils/floating-panel.js";
+import { setPalette } from "../utils/palette.js";
+import * as streamTransform from "../utils/stream-transform.js";
+import activateShellContext from "./shell-context.js";
+import activateTuiRenderer from "./tui-renderer.js";
+import { type Terminal, processTerminal, surfaceFromTerminal } from "./terminal.js";
+
+const SHELL_SURFACE = `You're attached through a terminal shell. It shares the user's working directory, environment, and command history, and you can act on their live session — everything they run at the prompt is visible to you.`;
+
+export interface ShellActivateOptions {
+  cols: number;
+  rows: number;
+  /** Path to the shell binary (zsh, bash, etc.). */
+  shellPath: string;
+  cwd: string;
+  /** Optional callback used by the inline status indicator. */
+  onShowAgentInfo?: () => { info: string; model?: string };
+  /**
+   * Host-side I/O endpoint. Defaults to processTerminal() so the CLI
+   * works unchanged; headless callers (web hubs, tests) supply their own.
+   */
+  terminal?: Terminal;
+}
+
+export interface ShellHandle {
+  /** Terminate the PTY. */
+  kill(): void;
+  /** Subscribe to PTY exit. The frontend uses this to clean up + exit. */
+  onExit(callback: (e: { exitCode: number; signal?: number }) => void): void;
+  /** Forward terminal size changes to the PTY. */
+  resize(cols: number, rows: number): void;
+}
+
+/**
+ * Register shell-owned handlers extensions can `ctx.call`, and attach
+ * the shell surface to ctx. Must run before `loadExtensions` so user
+ * extensions see `ctx.shell` populated.
+ */
+export function registerShellHandlers(ctx: ExtensionContext): void {
+  const { bus } = ctx;
+  const compositor = new DefaultCompositor(bus);
+
+  ctx.advise("system-prompt:frontend", (next) => {
+    const base = (next() as string) ?? "";
+    return base ? `${base}\n\n${SHELL_SURFACE}` : SHELL_SURFACE;
+  });
+
+  const shellSurface: ShellSurface = {
+    compositor,
+    setPalette,
+    createBlockTransform: (o) => streamTransform.createBlockTransform(bus, o),
+    createFencedBlockTransform: (o) => streamTransform.createFencedBlockTransform(bus, o),
+    adviseInputMode: (id, advisor) => ctx.advise(`input-mode:${id}:submit`, advisor as Parameters<typeof ctx.advise>[1]),
+    createRemoteSession: (sessOpts: RemoteSessionOptions): RemoteSession => {
+      const { surface } = sessOpts;
+      const cleanups: (() => void)[] = [];
+      let active = true;
+
+      cleanups.push(compositor.redirect("agent", surface));
+      cleanups.push(compositor.redirect("query", surface));
+      cleanups.push(compositor.redirect("status", surface));
+
+      // on-processing-done is intentionally not advised — its scope
+      // cleanup must always run.
+      cleanups.push(ctx.advise("shell:on-processing-start", (next) => active ? undefined : next()));
+      cleanups.push(ctx.advise("shell:on-processing-redraw", (next) => active ? undefined : next()));
+
+      if (sessOpts.suppressBorders !== false) {
+        cleanups.push(ctx.advise("tui:response-border", (next, ...a) => active ? null : next(...a)));
+      }
+      if (sessOpts.suppressQueryBox) {
+        cleanups.push(ctx.advise("tui:render-user-query", (next, ...a) => active ? [] : next(...a)));
+      }
+      if (sessOpts.suppressUsage !== false) {
+        cleanups.push(ctx.advise("tui:render-usage", (next, ...a) => active ? "" : next(...a)));
+      }
+      return {
+        submit(query: string) { bus.emit("agent:submit", { query }); },
+        get surface() { return surface; },
+        get active() { return active; },
+        close() {
+          if (!active) return;
+          active = false;
+          for (const fn of cleanups.reverse()) fn();
+          cleanups.length = 0;
+        },
+      };
+    },
+  };
+  (ctx as { shell?: ShellSurface }).shell = shellSurface;
+
+  let terminalBufferSingleton: TerminalBuffer | null | undefined;
+  ctx.define("terminal-buffer", (): TerminalBuffer | null => {
+    if (terminalBufferSingleton !== undefined) return terminalBufferSingleton;
+    terminalBufferSingleton = TerminalBuffer.createWired(ctx.bus);
+    return terminalBufferSingleton;
+  });
+
+  // bus override lets callers pass their scoped bus, so the panel's
+  // listeners unwire when the extension reloads.
+  ctx.define("floating-panel:create", (config: FloatingPanelConfig, bus?: EventBus): FloatingPanel =>
+    new FloatingPanel(bus ?? ctx.bus, config),
+  );
+
+  activateShellContext(ctx);
+  activateTuiRenderer(ctx);
+}
+
+/**
+ * Construct the Shell, wire resize forwarding, and register cleanup with the
+ * provided ExtensionContext. Returns a handle the caller (typically
+ * `src/cli/index.ts`) uses to drive lifecycle from process-level events.
+ */
+export function activateShell(
+  ctx: ExtensionContext,
+  opts: ShellActivateOptions,
+): ShellHandle {
+  const terminal = opts.terminal ?? processTerminal();
+  const surface = surfaceFromTerminal(terminal);
+  ctx.shell!.compositor.setDefault("agent", surface);
+  ctx.shell!.compositor.setDefault("query", surface);
+  ctx.shell!.compositor.setDefault("status", surface);
+
+  const shell = new Shell({
+    bus: ctx.bus,
+    handlers: { define: ctx.define, call: ctx.call },
+    cols: opts.cols,
+    rows: opts.rows,
+    shell: opts.shellPath,
+    cwd: opts.cwd,
+    instanceId: ctx.instanceId,
+    onShowAgentInfo: opts.onShowAgentInfo,
+    terminal,
+  });
+
+  const offResize = terminal.onResize((cols, rows) => shell.resize(cols, rows));
+
+  ctx.onDispose(() => {
+    offResize();
+    shell.kill();
+  });
+
+  return {
+    kill: () => shell.kill(),
+    onExit: (callback) => shell.onExit(callback),
+    resize: (cols, rows) => shell.resize(cols, rows),
+  };
+}

package/src/shell/input-handler.ts

@@ -0,0 +1,505 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { LineEditor } from "../utils/line-editor.js";
+import { CONFIG_DIR, getSettings } from "../core/settings.js";
+import type { EventBus } from "../core/event-bus.js";
+import type { InputModeConfig } from "./host-types.js";
+import { TuiInputView } from "./tui-input-view.js";
+
+const HISTORY_FILE = path.join(CONFIG_DIR, "input-history");
+
+/** Narrow contract between InputHandler and its host (Shell). */
+export interface InputContext {
+  isForegroundBusy(): boolean;
+  getCwd(): string;
+  isAgentActive(): boolean;
+  writeToPty(data: string): void;
+  onCommandEntered(command: string, cwd: string): void;
+  redrawPrompt(): void;
+  freshPrompt(): void;
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export interface InputHandlers {
+  define: (name: string, fn: (...a: any[]) => any) => void;
+  call: (name: string, ...a: any[]) => any;
+}
+
+/** Line editor + shell-passthrough buffer. Delegates rendering to TuiInputView. */
+export class InputHandler {
+  private ctx: InputContext;
+  private lineBuffer = "";
+  private activeMode: InputModeConfig | null = null;
+  private pendingReturnMode: string | null = null;
+  private modes = new Map<string, InputModeConfig>();
+  private modesById = new Map<string, InputModeConfig>();
+  private editor = new LineEditor();
+  private autocompleteActive = false;
+  private autocompleteIndex = 0;
+  private autocompleteItems: { name: string; description: string }[] = [];
+  private history: string[] = [];
+  private historyIndex = -1;
+  private savedBuffer = "";
+  private escapeTimer: ReturnType<typeof setTimeout> | null = null;
+  private bus: EventBus;
+  private handlers: InputHandlers;
+  private onShowAgentInfo: () => { info: string; model?: string };
+  private view: TuiInputView;
+
+  constructor(opts: {
+    ctx: InputContext;
+    bus: EventBus;
+    handlers: InputHandlers;
+    onShowAgentInfo: () => { info: string; model?: string };
+    view?: TuiInputView;
+  }) {
+    this.ctx = opts.ctx;
+    this.bus = opts.bus;
+    this.handlers = opts.handlers;
+    this.onShowAgentInfo = opts.onShowAgentInfo;
+    this.view = opts.view ?? new TuiInputView();
+    this.loadHistory();
+
+    this.bus.on("config:changed", () => {
+      if (this.activeMode) this.drawPrompt();
+    });
+
+    this.bus.on("input:redraw", () => {
+      if (this.activeMode) this.renderModeInput();
+    });
+
+    this.bus.on("input-mode:register", (config) => {
+      this.registerMode(config);
+    });
+  }
+
+  private registerMode(config: InputModeConfig): void {
+    if (this.modes.has(config.trigger)) {
+      this.bus.emit("ui:error", {
+        message: `Input mode "${config.id}" cannot register trigger "${config.trigger}" — already taken by "${this.modes.get(config.trigger)!.id}"`,
+      });
+      return;
+    }
+    this.modes.set(config.trigger, config);
+    this.modesById.set(config.id, config);
+    this.handlers.define(`input-mode:${config.id}:submit`, config.onSubmit.bind(config));
+  }
+
+  private loadHistory(): void {
+    try {
+      const data = fs.readFileSync(HISTORY_FILE, "utf-8");
+      this.history = data.split("\n").filter(Boolean);
+    } catch {
+    }
+  }
+
+  private saveHistory(): void {
+    try {
+      const { historySize } = getSettings();
+      fs.mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
+      const lines = this.history.slice(-historySize);
+      fs.writeFileSync(HISTORY_FILE, lines.join("\n") + "\n");
+    } catch {
+    }
+  }
+
+  private drawPrompt(showBuffer = true): void {
+    this.view.drawPrompt({
+      showBuffer,
+      displayText: this.editor.displayText,
+      displayCursor: this.editor.displayCursor,
+      indicator: this.activeMode?.indicator ?? "●",
+      promptIcon: this.activeMode?.promptIcon ?? "❯",
+      agentInfo: this.onShowAgentInfo(),
+    });
+  }
+
+  handleInput(data: string): void {
+    const intercepted = this.bus.emitPipe("input:intercept", { data, consumed: false });
+    if (intercepted.consumed) return;
+
+    if (this.ctx.isAgentActive()) {
+      if (data === "\x03") {
+        this.bus.emit("agent:cancel-request", {});
+      } else if (data.length === 1 && data.charCodeAt(0) < 32) {
+        this.bus.emit("input:keypress", { key: data });
+      }
+      return;
+    }
+
+    if (data.length === 1 && data.charCodeAt(0) < 32 && !this.activeMode) {
+      const code = data.charCodeAt(0);
+      if (code === 0x14 || code === 0x0f) { // Ctrl+T, Ctrl+O
+        this.bus.emit("input:keypress", { key: data });
+        return;
+      }
+      if (code !== 0x0d && code !== 0x03 && code !== 0x04 && code !== 0x09) {
+        this.bus.emit("input:keypress", { key: data });
+      }
+    }
+
+    if (this.activeMode) {
+      this.handleModeInput(data);
+      return;
+    }
+
+    for (let i = 0; i < data.length; i++) {
+      const ch = data[i]!;
+
+      if (ch === "\r") {
+        if (this.lineBuffer.trim()) {
+          this.ctx.onCommandEntered(this.lineBuffer.trim(), this.ctx.getCwd());
+        }
+        this.lineBuffer = "";
+        this.ctx.writeToPty(ch);
+      } else if (ch === "\x7f" || ch === "\b") {
+        this.lineBuffer = this.lineBuffer.slice(0, -1);
+        this.ctx.writeToPty(ch);
+      } else if (ch === "\x03" || ch === "\x04") {
+        this.lineBuffer = "";
+        this.ctx.writeToPty(ch);
+      } else if (ch === "\x0b" || ch === "\x15") {
+        // Ctrl-K / Ctrl-U: shell kills the line; mirror so lineBuffer stays in sync.
+        this.lineBuffer = "";
+        this.ctx.writeToPty(ch);
+      } else if (ch === "\x1b") {
+        // Forward whole escape sequence as a unit — otherwise payload bytes
+        // (e.g. OSC color-query response) can leak into lineBuffer.
+        let seq = ch;
+        if (i + 1 < data.length) {
+          const next = data[i + 1]!;
+          if (next === "[") {
+            seq += next; i++;
+            while (i + 1 < data.length && data[i + 1]!.charCodeAt(0) < 0x40) {
+              i++; seq += data[i]!;
+            }
+            if (i + 1 < data.length) { i++; seq += data[i]!; }
+          } else if (next === "O") {
+            seq += next; i++;
+            if (i + 1 < data.length) { i++; seq += data[i]!; }
+          } else if (next === "]" || next === "P" || next === "_" || next === "^") {
+            // OSC/DCS/APC/PM — terminated by BEL or ST (ESC \).
+            let j = i + 2;
+            let termEnd = -1;
+            while (j < data.length) {
+              const c = data[j]!;
+              if (c === "\x07") { termEnd = j; break; }
+              if (c === "\x1b" && j + 1 < data.length && data[j + 1] === "\\") {
+                termEnd = j + 1; break;
+              }
+              j++;
+            }
+            if (termEnd !== -1) {
+              seq = data.slice(i, termEnd + 1);
+              i = termEnd;
+            } else {
+              seq += next; i++;
+            }
+          } else {
+            seq += next; i++;
+          }
+        }
+        this.ctx.writeToPty(seq);
+      } else if (ch.charCodeAt(0) < 32 && ch !== "\t") {
+        this.ctx.writeToPty(ch);
+      } else {
+        const mode = this.modes.get(ch);
+        if (this.lineBuffer === "" && mode && !this.ctx.isForegroundBusy()) {
+          this.enterMode(mode);
+          return;
+        }
+        if (!this.ctx.isForegroundBusy()) this.lineBuffer += ch;
+        this.ctx.writeToPty(ch);
+      }
+    }
+  }
+
+  private enterMode(mode: InputModeConfig): void {
+    this.activeMode = mode;
+    this.editor.clear();
+    this.view.enableModeKeys();
+    this.drawPrompt(false);
+  }
+
+  private exitMode(): void {
+    this.dismissAutocomplete();
+    this.activeMode = null;
+    this.editor.clear();
+    this.view.disableModeKeys();
+    this.view.clearPromptArea();
+    this.view.resetCursor();
+    this.printPrompt();
+  }
+
+  printPrompt(): void {
+    this.ctx.redrawPrompt();
+  }
+
+  /** Called when agent processing completes. Returns true if the input
+   *  handler re-entered a mode (so caller should skip shell prompt). */
+  handleProcessingDone(): boolean {
+    if (this.pendingReturnMode) {
+      const mode = this.modesById.get(this.pendingReturnMode);
+      this.pendingReturnMode = null;
+      if (mode) {
+        this.enterMode(mode);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private renderModeInput(): void {
+    this.view.beginFrame();
+    try {
+      this.view.clearAutocomplete();
+      this.drawPrompt();
+      this.updateAutocomplete();
+    } finally {
+      this.view.endFrame();
+    }
+  }
+
+  private updateAutocomplete(): void {
+    const buf = this.editor.text;
+    let command: string | null = null;
+    let commandArgs: string | null = null;
+    if (buf.startsWith("/")) {
+      const spaceIdx = buf.indexOf(" ");
+      if (spaceIdx !== -1) {
+        command = buf.slice(0, spaceIdx);
+        commandArgs = buf.slice(spaceIdx + 1);
+      }
+    }
+    const { items } = this.bus.emitPipe("autocomplete:request", {
+      buffer: buf,
+      command,
+      commandArgs,
+      items: [],
+    });
+    if (items.length > 0) {
+      this.autocompleteItems = items;
+      this.autocompleteActive = true;
+      if (this.autocompleteIndex >= items.length) this.autocompleteIndex = 0;
+      this.view.drawAutocomplete({ items: this.autocompleteItems, selected: this.autocompleteIndex });
+    } else {
+      this.autocompleteActive = false;
+      this.autocompleteItems = [];
+    }
+  }
+
+  private applyAutocomplete(): void {
+    if (!this.autocompleteActive || this.autocompleteItems.length === 0) return;
+    const selected = this.autocompleteItems[this.autocompleteIndex];
+    if (!selected) return;
+
+    const atPos = this.editor.text.lastIndexOf("@");
+    const isFileAc =
+      atPos >= 0 &&
+      (atPos === 0 || this.editor.text[atPos - 1] === " ") &&
+      !this.editor.text.slice(atPos + 1).includes(" ");
+
+    if (isFileAc) {
+      this.editor.setText(
+        this.editor.text.slice(0, atPos) + "@" + selected.name);
+    } else {
+      this.editor.setText(selected.name);
+    }
+
+    this.view.beginFrame();
+    try {
+      this.view.clearAutocomplete();
+      this.autocompleteActive = false;
+      this.autocompleteItems = [];
+      this.autocompleteIndex = 0;
+
+      this.drawPrompt();
+      if (isFileAc) this.updateAutocomplete();
+    } finally {
+      this.view.endFrame();
+    }
+  }
+
+  private dismissAutocomplete(): void {
+    this.view.clearAutocomplete();
+    this.autocompleteActive = false;
+    this.autocompleteItems = [];
+    this.autocompleteIndex = 0;
+  }
+
+  private handleModeInput(data: string): void {
+    if (this.escapeTimer) {
+      clearTimeout(this.escapeTimer);
+      this.escapeTimer = null;
+    }
+
+    const actions = this.editor.feed(data);
+
+    if (this.editor.hasPendingEscape()) {
+      this.escapeTimer = setTimeout(() => {
+        this.escapeTimer = null;
+        const flushed = this.editor.flushPendingEscape();
+        if (flushed.length > 0) this.processModeActions(flushed);
+      }, 50);
+    }
+
+    this.processModeActions(actions);
+  }
+
+  private processModeActions(actions: ReturnType<typeof this.editor.feed>): void {
+    for (const act of actions) {
+      switch (act.action) {
+        case "changed": {
+          const switchMode = this.modes.get(this.editor.text);
+          if (this.editor.text.length === 1 && switchMode && switchMode !== this.activeMode) {
+            this.view.beginFrame();
+            try {
+              this.dismissAutocomplete();
+              this.view.clearPromptArea();
+              this.activeMode = switchMode;
+              this.editor.clear();
+              this.drawPrompt(false);
+            } finally {
+              this.view.endFrame();
+            }
+            break;
+          }
+          this.historyIndex = -1;
+          this.autocompleteIndex = 0;
+          this.renderModeInput();
+          break;
+        }
+
+        case "submit": {
+          if (this.autocompleteActive) {
+            this.applyAutocomplete();
+          }
+          // Use editor.text (not act.buffer) so autocomplete selections take effect.
+          const query = this.editor.text.trim();
+          if (query) {
+            if (this.history.length === 0 || this.history[this.history.length - 1] !== query) {
+              this.history.push(query);
+              this.saveHistory();
+            }
+          }
+          this.historyIndex = -1;
+          this.savedBuffer = "";
+          this.view.clearAutocomplete();
+          this.view.clearPromptArea();
+          this.view.disableModeKeys();
+          const currentMode = this.activeMode!;
+          this.activeMode = null;
+          this.editor.clear();
+          this.view.resetCursor();
+          this.dismissAutocomplete();
+          if (query && query.startsWith("/")) {
+            const spaceIdx = query.indexOf(" ");
+            const name = spaceIdx === -1 ? query : query.slice(0, spaceIdx);
+            const args = spaceIdx === -1 ? "" : query.slice(spaceIdx + 1).trim();
+            this.bus.emit("command:execute", { name, args });
+            if (currentMode.returnToSelf) {
+              this.enterMode(currentMode);
+            } else {
+              this.ctx.freshPrompt();
+            }
+          } else if (query) {
+            this.pendingReturnMode = currentMode.returnToSelf ? currentMode.id : null;
+            this.handlers.call(`input-mode:${currentMode.id}:submit`, query, this.bus);
+          } else {
+            this.exitMode();
+          }
+          return;
+        }
+
+        case "cancel":
+          if (this.autocompleteActive) {
+            this.view.beginFrame();
+            try {
+              this.dismissAutocomplete();
+              this.drawPrompt();
+            } finally {
+              this.view.endFrame();
+            }
+          } else {
+            this.exitMode();
+          }
+          return;
+
+        case "delete-empty":
+          this.dismissAutocomplete();
+          this.exitMode();
+          return;
+
+        case "tab":
+          if (this.autocompleteActive) {
+            this.applyAutocomplete();
+          }
+          break;
+
+        case "arrow-up":
+          if (this.autocompleteActive) {
+            this.autocompleteIndex =
+              this.autocompleteIndex === 0
+                ? this.autocompleteItems.length - 1
+                : this.autocompleteIndex - 1;
+            this.view.beginFrame();
+            try {
+              this.view.clearAutocomplete();
+              this.drawPrompt();
+              this.view.drawAutocomplete({ items: this.autocompleteItems, selected: this.autocompleteIndex });
+            } finally {
+              this.view.endFrame();
+            }
+          } else if (this.history.length > 0) {
+            if (this.historyIndex === -1) {
+              this.savedBuffer = this.editor.text;
+              this.historyIndex = this.history.length - 1;
+            } else if (this.historyIndex > 0) {
+              this.historyIndex--;
+            }
+            this.editor.setText(this.history[this.historyIndex]!);
+            this.view.beginFrame();
+            try {
+              this.view.clearAutocomplete();
+              this.drawPrompt();
+            } finally {
+              this.view.endFrame();
+            }
+          }
+          break;
+
+        case "arrow-down":
+          if (this.autocompleteActive) {
+            this.autocompleteIndex =
+              this.autocompleteIndex === this.autocompleteItems.length - 1
+                ? 0
+                : this.autocompleteIndex + 1;
+            this.view.beginFrame();
+            try {
+              this.view.clearAutocomplete();
+              this.drawPrompt();
+              this.view.drawAutocomplete({ items: this.autocompleteItems, selected: this.autocompleteIndex });
+            } finally {
+              this.view.endFrame();
+            }
+          } else if (this.historyIndex !== -1) {
+            if (this.historyIndex < this.history.length - 1) {
+              this.historyIndex++;
+              this.editor.setText(this.history[this.historyIndex]!);
+            } else {
+              this.historyIndex = -1;
+              this.editor.setText(this.savedBuffer);
+            }
+            this.view.beginFrame();
+            try {
+              this.view.clearAutocomplete();
+              this.drawPrompt();
+            } finally {
+              this.view.endFrame();
+            }
+          }
+          break;
+      }
+    }
+  }
+}