agent-sh 0.1.0 → 0.3.0

package/dist/mcp-server.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+/**
+ * Minimal MCP server exposing a `user_shell` tool.
+ *
+ * Spawned by the ACP agent (pi-acp, claude-agent-acp, etc.) as an MCP
+ * stdio server. When the LLM calls `user_shell`, this process connects
+ * to agent-sh's Unix socket to execute the command in the user's live
+ * PTY shell.
+ *
+ * Protocol: MCP over stdio (newline-delimited JSON-RPC 2.0).
+ * No SDK dependency — the protocol surface is tiny.
+ */
+import { createConnection } from "node:net";
+import { createInterface } from "node:readline";
+const SOCKET_PATH = process.env.AGENT_SH_SOCKET;
+// ── MCP protocol helpers ────────────────────────────────────────
+function send(msg) {
+    process.stdout.write(JSON.stringify({ jsonrpc: "2.0", ...msg }) + "\n");
+}
+function sendResult(id, result) {
+    send({ id, result });
+}
+function sendError(id, code, message) {
+    send({ id, error: { code, message } });
+}
+// ── Tool definition ─────────────────────────────────────────────
+const SHELL_CWD_TOOL = {
+    name: "shell_cwd",
+    description: "Get the user's current working directory in their live shell. " +
+        "IMPORTANT: Your internal working directory may differ from the user's actual shell cwd — " +
+        "the user may have cd'd after your session started. Call this tool to get the real cwd " +
+        "before file operations if you're unsure.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+    },
+};
+const USER_SHELL_TOOL = {
+    name: "user_shell",
+    description: "Execute a command in the user's live terminal session. " +
+        "Use this for commands that should affect the user's shell state: " +
+        "cd, export, source, pushd/popd, alias, etc. " +
+        "The command runs in the user's actual shell with their full environment " +
+        "(aliases, functions, PATH), not an isolated subprocess. " +
+        "NOTE: Your internal cwd may be stale — the user may have cd'd. " +
+        "Check the shell context for [shell cwd:...] labels or call shell_cwd " +
+        "to determine the real working directory. Use absolute paths when possible.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            command: {
+                type: "string",
+                description: "Shell command to execute in the user's live terminal",
+            },
+        },
+        required: ["command"],
+    },
+};
+const SHELL_RECALL_TOOL = {
+    name: "shell_recall",
+    description: "Retrieve past shell commands, agent responses, and tool executions from the session history. " +
+        "Use this to look up truncated output, search for previous commands or errors, " +
+        "or browse recent exchanges. Each entry shows [shell cwd:...] so you can see " +
+        "which directory commands were run in. Operations: " +
+        '"browse" lists recent exchange summaries with line counts, ' +
+        '"search" finds exchanges matching a regex query, ' +
+        '"expand" retrieves content by exchange ID (use start/end for specific line ranges).',
+    inputSchema: {
+        type: "object",
+        properties: {
+            operation: {
+                type: "string",
+                enum: ["search", "expand", "browse"],
+                description: 'Operation to perform (default: "browse")',
+            },
+            query: {
+                type: "string",
+                description: 'Search query — supports regex (required for "search" operation)',
+            },
+            ids: {
+                type: "array",
+                items: { type: "number" },
+                description: 'Exchange IDs to expand (required for "expand" operation)',
+            },
+            start: {
+                type: "number",
+                description: "Start line number, 1-indexed (optional, for expand)",
+            },
+            end: {
+                type: "number",
+                description: "End line number, inclusive (optional, for expand)",
+            },
+        },
+    },
+};
+// ── agent-sh socket client (JSON-RPC 2.0) ──────────────────────
+let rpcId = 0;
+function callSocket(method, params) {
+    return new Promise((resolve, reject) => {
+        if (!SOCKET_PATH) {
+            reject(new Error("AGENT_SH_SOCKET not set — not running inside agent-sh"));
+            return;
+        }
+        const conn = createConnection(SOCKET_PATH);
+        let buffer = "";
+        conn.on("connect", () => {
+            const msg = { jsonrpc: "2.0", id: ++rpcId, method, params: params ?? {} };
+            conn.write(JSON.stringify(msg) + "\n");
+        });
+        conn.on("data", (chunk) => {
+            buffer += chunk.toString();
+            const newlineIdx = buffer.indexOf("\n");
+            if (newlineIdx === -1)
+                return;
+            const line = buffer.slice(0, newlineIdx).trim();
+            conn.destroy();
+            try {
+                const response = JSON.parse(line);
+                if (response.error) {
+                    reject(new Error(response.error.message || "RPC error"));
+                }
+                else {
+                    resolve(response.result);
+                }
+            }
+            catch {
+                reject(new Error(`Invalid response from agent-sh: ${line}`));
+            }
+        });
+        conn.on("error", (err) => {
+            reject(new Error(`Failed to connect to agent-sh: ${err.message}`));
+        });
+        conn.setTimeout(35_000, () => {
+            conn.destroy();
+            reject(new Error("Connection to agent-sh timed out"));
+        });
+    });
+}
+// ── Request handler ─────────────────────────────────────────────
+async function handleRequest(id, method, params) {
+    switch (method) {
+        case "initialize":
+            sendResult(id, {
+                protocolVersion: params?.protocolVersion ?? "2024-11-05",
+                capabilities: { tools: {} },
+                serverInfo: { name: "agent-sh-shell", version: "0.1.0" },
+            });
+            break;
+        case "notifications/initialized":
+            // Client acknowledgement — nothing to do
+            break;
+        case "tools/list":
+            sendResult(id, { tools: [SHELL_CWD_TOOL, USER_SHELL_TOOL, SHELL_RECALL_TOOL] });
+            break;
+        case "tools/call": {
+            const toolName = params?.name;
+            const args = params?.arguments ?? {};
+            try {
+                let text;
+                if (toolName === "shell_cwd") {
+                    const result = await callSocket("shell/cwd", {});
+                    text = `User's current working directory: ${result.cwd}`;
+                }
+                else if (toolName === "user_shell") {
+                    const command = args.command;
+                    if (!command || typeof command !== "string") {
+                        sendError(id, -32602, "Missing required parameter: command");
+                        return;
+                    }
+                    const result = await callSocket("shell/exec", { command });
+                    text = result.output || "(no output)";
+                }
+                else if (toolName === "shell_recall") {
+                    const result = await callSocket("shell/recall", {
+                        operation: args.operation || "browse",
+                        query: args.query,
+                        ids: args.ids,
+                        start: args.start,
+                        end: args.end,
+                    });
+                    text = result.result || "(no results)";
+                }
+                else {
+                    sendError(id, -32602, `Unknown tool: ${toolName}`);
+                    return;
+                }
+                sendResult(id, {
+                    content: [{ type: "text", text }],
+                });
+            }
+            catch (err) {
+                sendResult(id, {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                        },
+                    ],
+                    isError: true,
+                });
+            }
+            break;
+        }
+        default:
+            // Unknown methods: return method-not-found for requests (those with id)
+            if (id !== undefined && id !== null) {
+                sendError(id, -32601, `Method not found: ${method}`);
+            }
+            break;
+    }
+}
+// ── Main loop ───────────────────────────────────────────────────
+const rl = createInterface({ input: process.stdin });
+rl.on("line", (line) => {
+    if (!line.trim())
+        return;
+    try {
+        const msg = JSON.parse(line);
+        const { id, method, params } = msg;
+        if (method) {
+            handleRequest(id, method, params).catch((err) => {
+                if (id !== undefined && id !== null) {
+                    sendError(id, -32603, String(err));
+                }
+            });
+        }
+    }
+    catch {
+        // Malformed JSON — ignore
+    }
+});
+rl.on("close", () => {
+    process.exit(0);
+});

package/dist/output-parser.d.ts

@@ -9,24 +9,14 @@ export declare class OutputParser {
     private currentOutputCapture;
     private lastCommand;
     private foregroundBusy;
-    private capturingPrompt;
-    private promptCaptureComplete;
-    private promptBuffer;
-    private lastPrompt;
+    private promptReady;
     constructor(bus: EventBus, initialCwd: string);
     /** Process a chunk of PTY output data. */
     processData(data: string): void;
     /** Called when user presses Enter on a non-empty line. */
     onCommandEntered(command: string, cwd: string): void;
-    /** Returns the full captured prompt bytes, or empty if incomplete. */
-    getLastPrompt(): string;
-    /**
-     * 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(): string;
-    isPromptCaptureComplete(): boolean;
+    /** Whether the shell's prompt is fully rendered and ready for input. */
+    isPromptReady(): boolean;
     isForegroundBusy(): boolean;
     getCwd(): string;
     private parseOSC7;
@@ -36,20 +26,9 @@ export declare class OutputParser {
      */
     private parsePromptMarker;
     /**
-     * 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.
      */
     private parsePromptEnd;
-    /**
-     * 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.
-     */
-    private sanitizePromptForReplay;
     private removeEchoedCommand;
 }

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/settings.d.ts

@@ -0,0 +1,33 @@
+export declare const CONFIG_DIR: string;
+export interface Settings {
+    /** Extensions to load (npm packages or file paths). */
+    extensions?: string[];
+    /** Max agent query history entries to keep. */
+    historySize?: number;
+    /** Recent exchanges included in agent context window. */
+    contextWindowSize?: number;
+    /** Context budget in bytes (~4 chars per token). */
+    contextBudget?: number;
+    /** Shell output lines before truncation kicks in. */
+    shellTruncateThreshold?: number;
+    /** Lines kept from start of truncated shell output. */
+    shellHeadLines?: number;
+    /** Lines kept from end of truncated shell output. */
+    shellTailLines?: number;
+    /** Max lines for recall expand before requiring line ranges. */
+    recallExpandMaxLines?: number;
+    /** Max command output lines shown inline in TUI. */
+    maxCommandOutputLines?: number;
+    /** Max read tool output lines shown inline in TUI (0 = hide). */
+    readOutputMaxLines?: number;
+    /** Max diff lines shown before "ctrl+o to expand". */
+    diffMaxLines?: number;
+    /** Register MCP server for bridge tools (shell_cwd, user_shell, shell_recall). Default true. */
+    enableMcp?: boolean;
+}
+declare const DEFAULTS: Required<Settings>;
+/** Load settings from disk (cached after first call). */
+export declare function getSettings(): Settings & typeof DEFAULTS;
+/** Reset cached settings (for testing or after external edit). */
+export declare function reloadSettings(): void;
+export {};

package/dist/settings.js

@@ -0,0 +1,43 @@
+/**
+ * User settings loaded from ~/.agent-sh/settings.json.
+ *
+ * Settings are loaded once at startup and available synchronously
+ * throughout the app. Unknown keys are preserved on write.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+export const CONFIG_DIR = path.join(os.homedir(), ".agent-sh");
+const SETTINGS_PATH = path.join(CONFIG_DIR, "settings.json");
+const DEFAULTS = {
+    extensions: [],
+    historySize: 500,
+    contextWindowSize: 20,
+    contextBudget: 16384,
+    shellTruncateThreshold: 10,
+    shellHeadLines: 5,
+    shellTailLines: 5,
+    recallExpandMaxLines: 100,
+    maxCommandOutputLines: 5,
+    readOutputMaxLines: 0,
+    diffMaxLines: 20,
+    enableMcp: true,
+};
+let cached = null;
+/** Load settings from disk (cached after first call). */
+export function getSettings() {
+    if (!cached) {
+        try {
+            const raw = fs.readFileSync(SETTINGS_PATH, "utf-8");
+            cached = JSON.parse(raw);
+        }
+        catch {
+            cached = {};
+        }
+    }
+    return { ...DEFAULTS, ...cached };
+}
+/** Reset cached settings (for testing or after external edit). */
+export function reloadSettings() {
+    cached = null;
+}

package/dist/shell.d.ts

@@ -6,7 +6,9 @@ export declare class Shell implements InputContext {
     private inputHandler;
     private outputParser;
     private paused;
+    private echoSkip;
     private agentActive;
+    private isZsh;
     private tmpDir?;
     constructor(opts: {
         bus: EventBus;
@@ -24,10 +26,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 +48,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;