agent-sh 0.1.0 → 0.2.0

package/dist/output-parser.js

@@ -9,10 +9,7 @@ export class OutputParser {
     currentOutputCapture = "";
     lastCommand = "";
     foregroundBusy = false;
-    capturingPrompt = false;
-    promptCaptureComplete = false;
-    promptBuffer = "";
-    lastPrompt = "";
+    promptReady = false;
     constructor(bus, initialCwd) {
         this.bus = bus;
         this.cwd = initialCwd;
@@ -20,19 +17,7 @@ export class OutputParser {
     /** Process a chunk of PTY output data. */
     processData(data) {
         this.parseOSC7(data);
-        // Bracketed prompt capture: accumulate bytes between OSC 9999 and 9998.
-        // parsePromptMarker may start capture (setting promptBuffer to the tail
-        // of the current chunk), so we only append subsequent chunks here.
-        const wasCapturing = this.capturingPrompt;
         this.parsePromptMarker(data);
-        // If we were already capturing before this chunk (and still are), append
-        // the full chunk. If capture just started in parsePromptMarker above, the
-        // tail after the start marker is already in promptBuffer — don't double-add.
-        if (wasCapturing && this.capturingPrompt) {
-            this.promptBuffer += data;
-        }
-        // Check for end marker. Must run after the append above so that
-        // multi-chunk captures include this chunk's data before we finalize.
         this.parsePromptEnd(data);
     }
     /** Called when user presses Enter on a non-empty line. */
@@ -45,28 +30,9 @@ export class OutputParser {
             this.bus.emit("shell:foreground-busy", { busy: true });
         }
     }
-    /** Returns the full captured prompt bytes, or empty if incomplete. */
-    getLastPrompt() {
-        if (!this.promptCaptureComplete)
-            return "";
-        return this.lastPrompt;
-    }
-    /**
-     * Returns just the last line of the captured prompt (e.g. p10k's "❯ " line).
-     * This is safe to replay with \r because it's linear text (colors + chars),
-     * not relative cursor positioning. Returns empty if no complete capture.
-     */
-    getLastPromptLine() {
-        if (!this.promptCaptureComplete)
-            return "";
-        // Find the last \r\n or \n — everything after it is the final prompt line
-        const lastNewline = this.lastPrompt.lastIndexOf("\n");
-        if (lastNewline < 0)
-            return this.lastPrompt;
-        return this.lastPrompt.slice(lastNewline + 1);
-    }
-    isPromptCaptureComplete() {
-        return this.promptCaptureComplete;
+    /** Whether the shell's prompt is fully rendered and ready for input. */
+    isPromptReady() {
+        return this.promptReady;
     }
     isForegroundBusy() {
         return this.foregroundBusy;
@@ -90,7 +56,14 @@ export class OutputParser {
      * Each time a prompt appears, we finalize the previous command's output.
      */
     parsePromptMarker(data) {
-        if (data.includes("\x1b]9999;PROMPT\x07")) {
+        const marker = "\x1b]9999;PROMPT\x07";
+        const markerIdx = data.indexOf(marker);
+        if (markerIdx !== -1) {
+            // Capture any output that arrived in the same chunk before the marker
+            if (markerIdx > 0) {
+                this.currentOutputCapture += data.slice(0, markerIdx);
+            }
+            this.promptReady = false;
             if (this.foregroundBusy) {
                 this.foregroundBusy = false;
                 this.bus.emit("shell:foreground-busy", { busy: false });
@@ -107,54 +80,19 @@ export class OutputParser {
             }
             this.lastCommand = "";
             this.currentOutputCapture = "";
-            // Start bracketed prompt capture: accumulate bytes until OSC 9998
-            this.capturingPrompt = true;
-            this.promptCaptureComplete = false;
-            this.promptBuffer = "";
-            const markerEnd = data.indexOf("\x1b]9999;PROMPT\x07") + "\x1b]9999;PROMPT\x07".length;
-            if (markerEnd < data.length) {
-                this.promptBuffer = data.slice(markerEnd);
-            }
         }
         else {
             this.currentOutputCapture += data;
         }
     }
     /**
-     * Detect end-of-prompt marker (OSC 9998). Finalizes the bracketed capture.
-     *
-     * By the time this runs, the current chunk has already been appended to
-     * promptBuffer (either by parsePromptMarker for the first chunk, or by
-     * the wasCapturing guard in processData for subsequent chunks). So we
-     * just need to trim everything from the end marker onward.
+     * Detect end-of-prompt marker (OSC 9998). The prompt is fully rendered
+     * and the shell is ready for input.
      */
     parsePromptEnd(data) {
-        if (!this.capturingPrompt)
-            return;
-        if (!data.includes("\x1b]9998;READY\x07"))
-            return;
-        // promptBuffer already contains this chunk's data. Find the end marker
-        // within the buffer and trim everything from it onward.
-        const endMarker = "\x1b]9998;READY\x07";
-        const bufEndIdx = this.promptBuffer.indexOf(endMarker);
-        if (bufEndIdx >= 0) {
-            this.promptBuffer = this.promptBuffer.slice(0, bufEndIdx);
+        if (data.includes("\x1b]9998;READY\x07")) {
+            this.promptReady = true;
         }
-        this.capturingPrompt = false;
-        this.promptCaptureComplete = true;
-        this.lastPrompt = this.sanitizePromptForReplay(this.promptBuffer);
-    }
-    /**
-     * Strip internal OSC markers from captured prompt so replay is clean.
-     * We intentionally strip all OSC 7 sequences — they're used for cwd
-     * reporting and have no visual effect, so replaying them would just
-     * cause duplicate cwd-change events.
-     */
-    sanitizePromptForReplay(raw) {
-        return raw
-            .replace(/\x1b\]7;[^\x07]*\x07/g, "") // OSC 7 (cwd reporting)
-            .replace(/\x1b\]9999;PROMPT\x07/g, "") // start marker
-            .replace(/\x1b\]9998;READY\x07/g, ""); // end marker
     }
     removeEchoedCommand(output, command) {
         const lines = output.split("\n");

package/dist/shell.d.ts

@@ -7,6 +7,7 @@ export declare class Shell implements InputContext {
     private outputParser;
     private paused;
     private agentActive;
+    private isZsh;
     private tmpDir?;
     constructor(opts: {
         bus: EventBus;
@@ -24,10 +25,11 @@ export declare class Shell implements InputContext {
     isAgentActive(): boolean;
     writeToPty(data: string): void;
     /**
-     * Lightweight redraw: replay just the last line of the shell's prompt
-     * (e.g. p10k's "❯ "). This works because agent input mode only overwrites
-     * the final prompt line — the path bar above is still intact. The last
-     * line is linear text (colors + chars + clear-to-end), no cursor positioning.
+     * Lightweight redraw: ask the shell to redraw its own prompt via a hidden
+     * ZLE widget (zsh) bound to \e[9999~. The shell knows how to draw its
+     * prompt correctly — we don't try to replay captured bytes.
+     *
+     * For bash, falls back to sending \n for a fresh prompt cycle.
      */
     redrawPrompt(): void;
     /**
@@ -45,6 +47,8 @@ export declare class Shell implements InputContext {
      * zero frontend knowledge; any frontend can subscribe to the same events.
      */
     private setupAgentLifecycle;
+    /** Temp directory used for shell config and sockets. */
+    getTmpDir(): string | undefined;
     resize(cols: number, rows: number): void;
     onExit(callback: (e: {
         exitCode: number;

package/dist/shell.js

@@ -11,6 +11,7 @@ export class Shell {
     outputParser;
     paused = false;
     agentActive = false;
+    isZsh = false;
     tmpDir;
     constructor(opts) {
         // Build environment — filter out undefined values (node-pty's native
@@ -38,6 +39,7 @@ export class Shell {
         let shellArgs;
         const osc7Cmd = 'printf "\\e]7;file://%s%s\\a" "$(hostname)" "$PWD"';
         const promptMarker = 'printf "\\e]9999;PROMPT\\a"';
+        this.isZsh = isZsh;
         if (isZsh) {
             // For zsh: use ZDOTDIR to source user's real config, then append
             // our hooks via precmd_functions (additive — doesn't clobber p10k/omz).
@@ -68,6 +70,14 @@ export class Shell {
                 "  }",
                 "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",
             ].join("\n") + "\n");
             env.ZDOTDIR = this.tmpDir;
             shellArgs = ["--no-globalrcs"];
@@ -131,10 +141,11 @@ export class Shell {
         this.ptyProcess.write(data);
     }
     /**
-     * Lightweight redraw: replay just the last line of the shell's prompt
-     * (e.g. p10k's "❯ "). This works because agent input mode only overwrites
-     * the final prompt line — the path bar above is still intact. The last
-     * line is linear text (colors + chars + clear-to-end), no cursor positioning.
+     * Lightweight redraw: ask the shell to redraw its own prompt via a hidden
+     * ZLE widget (zsh) bound to \e[9999~. The shell knows how to draw its
+     * prompt correctly — we don't try to replay captured bytes.
+     *
+     * For bash, falls back to sending \n for a fresh prompt cycle.
      */
     redrawPrompt() {
         const result = this.bus.emitPipe("shell:redraw-prompt", {
@@ -142,12 +153,12 @@ export class Shell {
             handled: false,
         });
         if (!result.handled) {
-            const lastLine = this.outputParser.getLastPromptLine();
-            if (lastLine) {
-                process.stdout.write("\r" + lastLine);
+            if (this.isZsh) {
+                // Trigger the hidden ZLE widget — zle reset-prompt redraws cleanly
+                this.ptyProcess.write("\x1b[9999~");
             }
             else {
-                // Fallback: send \n for a fresh prompt cycle
+                // Bash: no zle reset-prompt equivalent, use fresh prompt cycle
                 this.ptyProcess.write("\n");
             }
         }
@@ -202,8 +213,35 @@ export class Shell {
             this.paused = true;
             return payload;
         });
+        // Shell exec: write a command to the live PTY and capture its output.
+        // stdout is paused during agent processing, so PTY output flows through
+        // OutputParser (for OSC detection) but never reaches the terminal.
+        this.bus.onPipeAsync("shell:exec-request", async (payload) => {
+            const output = await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    this.bus.off("shell:command-done", handler);
+                    // Kill any hung command
+                    this.ptyProcess.write("\x03");
+                    reject(new Error("Shell exec timed out after 30s"));
+                }, 30_000);
+                const handler = (e) => {
+                    clearTimeout(timeout);
+                    this.bus.off("shell:command-done", handler);
+                    resolve({ output: e.output, cwd: e.cwd });
+                };
+                this.bus.on("shell:command-done", handler);
+                // Start capture and write to PTY
+                this.outputParser.onCommandEntered(payload.command, this.outputParser.getCwd());
+                this.ptyProcess.write(payload.command + "\r");
+            });
+            return { ...payload, output: output.output, cwd: output.cwd, done: true };
+        });
     }
     // ── Public API (used by index.ts) ──
+    /** Temp directory used for shell config and sockets. */
+    getTmpDir() {
+        return this.tmpDir;
+    }
     resize(cols, rows) {
         this.ptyProcess.resize(cols, rows);
     }

package/dist/types.d.ts

@@ -8,6 +8,8 @@ export interface AgentShellConfig {
     shell?: string;
     model?: string;
     extensions?: string[];
+    /** Full shell environment (from user's rc files) for agent subprocess. */
+    shellEnv?: Record<string, string>;
 }
 /**
  * Context passed to user/third-party extensions.

package/dist/utils/line-editor.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Minimal line editor with readline-style keybindings.
+ *
+ * Pure logic — no I/O, no rendering, no event bus. Consumers feed raw
+ * terminal input bytes and receive high-level actions back. Buffer and
+ * cursor state are public for rendering.
+ */
+export type LineEditAction = {
+    action: "changed";
+} | {
+    action: "submit";
+    buffer: string;
+} | {
+    action: "cancel";
+} | {
+    action: "delete-empty";
+} | {
+    action: "tab";
+} | {
+    action: "arrow-up";
+} | {
+    action: "arrow-down";
+};
+export declare class LineEditor {
+    buffer: string;
+    cursor: number;
+    /** Process raw terminal input, return actions for the consumer. */
+    feed(data: string): LineEditAction[];
+    clear(): void;
+    /**
+     * Parse and handle a CSI sequence (\x1b[...) starting at `start`.
+     * Returns the number of bytes consumed.
+     */
+    private handleCSI;
+    private wordBackward;
+    private wordForward;
+    private deleteWordBackward;
+    private deleteWordForward;
+}

package/dist/utils/line-editor.js

@@ -0,0 +1,287 @@
+/**
+ * Minimal line editor with readline-style keybindings.
+ *
+ * Pure logic — no I/O, no rendering, no event bus. Consumers feed raw
+ * terminal input bytes and receive high-level actions back. Buffer and
+ * cursor state are public for rendering.
+ */
+// ── Line editor ─────────────────────────────────────────────────
+export class LineEditor {
+    buffer = "";
+    cursor = 0;
+    /** Process raw terminal input, return actions for the consumer. */
+    feed(data) {
+        const actions = [];
+        let i = 0;
+        while (i < data.length) {
+            const ch = data[i];
+            // ── Escape sequences ────────────────────────────────
+            if (ch === "\x1b") {
+                const next = data[i + 1];
+                // Bare Escape (nothing follows in this chunk)
+                if (next == null) {
+                    actions.push({ action: "cancel" });
+                    i++;
+                    continue;
+                }
+                // CSI sequence: \x1b[...
+                if (next === "[") {
+                    const { consumed } = this.handleCSI(data, i, actions);
+                    i += consumed;
+                    continue;
+                }
+                // Alt/Option + key: \x1b followed by char
+                i += 2; // consume \x1b + next byte
+                if (next === "\x7f") {
+                    // Option+Backspace: delete word backward
+                    if (this.deleteWordBackward())
+                        actions.push({ action: "changed" });
+                }
+                else if (next === "b") {
+                    // Alt+B: word backward
+                    if (this.wordBackward())
+                        actions.push({ action: "changed" });
+                }
+                else if (next === "f") {
+                    // Alt+F: word forward
+                    if (this.wordForward())
+                        actions.push({ action: "changed" });
+                }
+                else if (next === "d") {
+                    // Alt+D: delete word forward
+                    if (this.deleteWordForward())
+                        actions.push({ action: "changed" });
+                }
+                // Other Alt+key — ignore
+                continue;
+            }
+            // ── Control characters ──────────────────────────────
+            if (ch === "\r") {
+                actions.push({ action: "submit", buffer: this.buffer });
+                i++;
+                continue;
+            }
+            if (ch === "\x03") {
+                actions.push({ action: "cancel" });
+                i++;
+                continue;
+            }
+            if (ch === "\t") {
+                actions.push({ action: "tab" });
+                i++;
+                continue;
+            }
+            if (ch === "\x7f" || ch === "\b") {
+                // Backspace
+                if (this.buffer.length === 0) {
+                    actions.push({ action: "delete-empty" });
+                }
+                else if (this.cursor > 0) {
+                    this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
+                    this.cursor--;
+                    actions.push({ action: "changed" });
+                }
+                i++;
+                continue;
+            }
+            // Ctrl-A: home
+            if (ch === "\x01") {
+                if (this.cursor > 0) {
+                    this.cursor = 0;
+                    actions.push({ action: "changed" });
+                }
+                i++;
+                continue;
+            }
+            // Ctrl-E: end
+            if (ch === "\x05") {
+                if (this.cursor < this.buffer.length) {
+                    this.cursor = this.buffer.length;
+                    actions.push({ action: "changed" });
+                }
+                i++;
+                continue;
+            }
+            // Ctrl-B: back one char
+            if (ch === "\x02") {
+                if (this.cursor > 0) {
+                    this.cursor--;
+                    actions.push({ action: "changed" });
+                }
+                i++;
+                continue;
+            }
+            // Ctrl-F: forward one char
+            if (ch === "\x06") {
+                if (this.cursor < this.buffer.length) {
+                    this.cursor++;
+                    actions.push({ action: "changed" });
+                }
+                i++;
+                continue;
+            }
+            // Ctrl-U: delete to start of line
+            if (ch === "\x15") {
+                if (this.cursor > 0) {
+                    this.buffer = this.buffer.slice(this.cursor);
+                    this.cursor = 0;
+                    actions.push({ action: "changed" });
+                }
+                i++;
+                continue;
+            }
+            // Ctrl-K: delete to end of line
+            if (ch === "\x0b") {
+                if (this.cursor < this.buffer.length) {
+                    this.buffer = this.buffer.slice(0, this.cursor);
+                    actions.push({ action: "changed" });
+                }
+                i++;
+                continue;
+            }
+            // Ctrl-W: delete word backward
+            if (ch === "\x17") {
+                if (this.deleteWordBackward())
+                    actions.push({ action: "changed" });
+                i++;
+                continue;
+            }
+            // Other control chars — ignore
+            if (ch.charCodeAt(0) < 0x20) {
+                i++;
+                continue;
+            }
+            // ── Printable character ─────────────────────────────
+            this.buffer = this.buffer.slice(0, this.cursor) + ch + this.buffer.slice(this.cursor);
+            this.cursor++;
+            actions.push({ action: "changed" });
+            i++;
+        }
+        return actions;
+    }
+    clear() {
+        this.buffer = "";
+        this.cursor = 0;
+    }
+    // ── CSI sequence handling ───────────────────────────────────
+    /**
+     * Parse and handle a CSI sequence (\x1b[...) starting at `start`.
+     * Returns the number of bytes consumed.
+     */
+    handleCSI(data, start, actions) {
+        // Skip \x1b[
+        let j = start + 2;
+        // Accumulate parameter bytes (0x20-0x3F: digits, semicolons, etc.)
+        let params = "";
+        while (j < data.length && data.charCodeAt(j) >= 0x20 && data.charCodeAt(j) < 0x40) {
+            params += data[j];
+            j++;
+        }
+        const final = j < data.length ? data[j] : "";
+        const consumed = j - start + (final ? 1 : 0);
+        // Dispatch on final byte
+        switch (final) {
+            case "A": // Up arrow
+                actions.push({ action: "arrow-up" });
+                break;
+            case "B": // Down arrow
+                actions.push({ action: "arrow-down" });
+                break;
+            case "C": // Right (or modified right: 1;3C, 1;5C = word right)
+                if (params.includes(";")) {
+                    if (this.wordForward())
+                        actions.push({ action: "changed" });
+                }
+                else {
+                    if (this.cursor < this.buffer.length) {
+                        this.cursor++;
+                        actions.push({ action: "changed" });
+                    }
+                }
+                break;
+            case "D": // Left (or modified left: 1;3D, 1;5D = word left)
+                if (params.includes(";")) {
+                    if (this.wordBackward())
+                        actions.push({ action: "changed" });
+                }
+                else {
+                    if (this.cursor > 0) {
+                        this.cursor--;
+                        actions.push({ action: "changed" });
+                    }
+                }
+                break;
+            case "H": // Home
+                if (this.cursor > 0) {
+                    this.cursor = 0;
+                    actions.push({ action: "changed" });
+                }
+                break;
+            case "F": // End
+                if (this.cursor < this.buffer.length) {
+                    this.cursor = this.buffer.length;
+                    actions.push({ action: "changed" });
+                }
+                break;
+            case "~": // Extended keys: Delete (3~), etc.
+                if (params === "3") {
+                    // Delete key: delete char under cursor
+                    if (this.cursor < this.buffer.length) {
+                        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+                        actions.push({ action: "changed" });
+                    }
+                }
+                break;
+            // All other CSI sequences — silently ignored
+        }
+        return { consumed };
+    }
+    // ── Word movement / deletion helpers ────────────────────────
+    wordBackward() {
+        if (this.cursor === 0)
+            return false;
+        let pos = this.cursor;
+        // Skip spaces
+        while (pos > 0 && this.buffer[pos - 1] === " ")
+            pos--;
+        // Skip word chars
+        while (pos > 0 && this.buffer[pos - 1] !== " ")
+            pos--;
+        if (pos === this.cursor)
+            return false;
+        this.cursor = pos;
+        return true;
+    }
+    wordForward() {
+        if (this.cursor >= this.buffer.length)
+            return false;
+        let pos = this.cursor;
+        // Skip word chars
+        while (pos < this.buffer.length && this.buffer[pos] !== " ")
+            pos++;
+        // Skip spaces
+        while (pos < this.buffer.length && this.buffer[pos] === " ")
+            pos++;
+        if (pos === this.cursor)
+            return false;
+        this.cursor = pos;
+        return true;
+    }
+    deleteWordBackward() {
+        if (this.cursor === 0)
+            return false;
+        const start = this.cursor;
+        this.wordBackward();
+        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(start);
+        return true;
+    }
+    deleteWordForward() {
+        if (this.cursor >= this.buffer.length)
+            return false;
+        const start = this.cursor;
+        this.wordForward();
+        this.buffer = this.buffer.slice(0, start) + this.buffer.slice(this.cursor);
+        this.cursor = start;
+        return true;
+    }
+}

package/dist/utils/tool-display.d.ts

@@ -4,6 +4,15 @@ export interface ToolCallRender {
     title: string;
     /** Optional command string for bash-like tools. */
     command?: string;
+    /** Tool kind from ACP (read, edit, execute, search, etc.). */
+    kind?: string;
+    /** File locations affected by the tool call. */
+    locations?: {
+        path: string;
+        line?: number | null;
+    }[];
+    /** Raw input parameters sent to the tool. */
+    rawInput?: unknown;
 }
 export interface ToolResultRender {
     exitCode: number | null;