agent-sh 0.1.0 → 0.3.0

package/dist/event-bus.d.ts

@@ -18,6 +18,8 @@ export interface ShellEvents {
     "shell:foreground-busy": {
         busy: boolean;
     };
+    "shell:agent-exec-start": Record<string, never>;
+    "shell:agent-exec-done": Record<string, never>;
     "agent:submit": {
         query: string;
     };
@@ -52,10 +54,17 @@ export interface ShellEvents {
     "agent:tool-started": {
         title: string;
         toolCallId?: string;
+        kind?: string;
+        locations?: {
+            path: string;
+            line?: number | null;
+        }[];
+        rawInput?: unknown;
     };
     "agent:tool-completed": {
         toolCallId?: string;
         exitCode: number | null;
+        rawOutput?: unknown;
     };
     "agent:tool-output-chunk": {
         chunk: string;
@@ -89,6 +98,26 @@ export interface ShellEvents {
         cwd: string;
         handled: boolean;
     };
+    "shell:exec-request": {
+        command: string;
+        output: string;
+        cwd: string;
+        done: boolean;
+    };
+    "session:configure": {
+        cwd: string;
+        mcpServers: {
+            name: string;
+            command: string;
+            args: string[];
+            env: {
+                name: string;
+                value: string;
+            }[];
+        }[];
+    };
+    "config:changed": Record<string, never>;
+    "config:cycle": Record<string, never>;
     "autocomplete:request": {
         buffer: string;
         items: {

package/dist/extension-loader.js

@@ -1,9 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import * as os from "node:os";
-const CONFIG_DIR = path.join(os.homedir(), ".agent-sh");
+import { CONFIG_DIR, getSettings } from "./settings.js";
 const EXT_DIR = path.join(CONFIG_DIR, "extensions");
-const SETTINGS_PATH = path.join(CONFIG_DIR, "settings.json");
 const TS_EXTS = [".ts", ".tsx", ".mts"];
 const SCRIPT_EXTS = [".js", ".mjs", ".ts", ".tsx", ".mts"];
 let tsRegistered = false;
@@ -19,15 +17,6 @@ async function ensureTsSupport() {
         // tsx not available — TS extensions will fail with a clear error
     }
 }
-async function loadSettings() {
-    try {
-        const raw = await fs.readFile(SETTINGS_PATH, "utf-8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return {};
-    }
-}
 /**
  * Load extensions from three sources (merged, deduplicated):
  *
@@ -49,8 +38,8 @@ export async function loadExtensions(ctx, cliExtensions) {
         specifiers.push(...cliExtensions);
     }
     // 2. settings.json
-    const settings = await loadSettings();
-    if (settings.extensions) {
+    const settings = getSettings();
+    if (settings.extensions.length > 0) {
         specifiers.push(...settings.extensions);
     }
     // 3. ~/.agent-sh/extensions/ directory

package/dist/extensions/shell-exec.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shell exec extension.
+ *
+ * Runs a Unix domain socket server speaking JSON-RPC 2.0 that external
+ * tools (MCP server, pi extensions, etc.) connect to for interacting
+ * with the user's live PTY shell.
+ *
+ * Also registers the MCP server via the `session:configure` pipe so
+ * ACP agents discover the `user_shell` tool automatically.
+ *
+ * This extension has no direct PTY or Shell knowledge — it communicates
+ * exclusively through the bus, following the headless-core philosophy.
+ *
+ * ## Socket protocol (JSON-RPC 2.0, newline-delimited)
+ *
+ *   shell/exec    { command: string }  → { output, cwd }
+ *   shell/cwd     {}                   → { cwd }
+ *   shell/info    {}                   → { busy, shell }
+ *   shell/recall  { operation, ... }   → { result }
+ */
+import type { ExtensionContext } from "../types.js";
+export default function activate({ bus, contextManager }: ExtensionContext, opts: {
+    socketPath: string;
+}): void;

package/dist/extensions/shell-exec.js

@@ -0,0 +1,188 @@
+/**
+ * Shell exec extension.
+ *
+ * Runs a Unix domain socket server speaking JSON-RPC 2.0 that external
+ * tools (MCP server, pi extensions, etc.) connect to for interacting
+ * with the user's live PTY shell.
+ *
+ * Also registers the MCP server via the `session:configure` pipe so
+ * ACP agents discover the `user_shell` tool automatically.
+ *
+ * This extension has no direct PTY or Shell knowledge — it communicates
+ * exclusively through the bus, following the headless-core philosophy.
+ *
+ * ## Socket protocol (JSON-RPC 2.0, newline-delimited)
+ *
+ *   shell/exec    { command: string }  → { output, cwd }
+ *   shell/cwd     {}                   → { cwd }
+ *   shell/info    {}                   → { busy, shell }
+ *   shell/recall  { operation, ... }   → { result }
+ */
+import * as net from "node:net";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { getSettings } from "../settings.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export default function activate({ bus, contextManager }, opts) {
+    const { socketPath } = opts;
+    // Register MCP server so ACP agents discover the bridge tools.
+    // Agents that don't support MCP (e.g. pi-acp) simply ignore it.
+    // Can be disabled via settings.json if not needed.
+    if (getSettings().enableMcp) {
+        bus.onPipe("session:configure", (payload) => {
+            return {
+                ...payload,
+                mcpServers: [
+                    ...payload.mcpServers,
+                    {
+                        name: "agent-sh",
+                        command: process.execPath,
+                        args: [path.join(__dirname, "..", "mcp-server.js")],
+                        env: [{ name: "AGENT_SH_SOCKET", value: socketPath }],
+                    },
+                ],
+            };
+        });
+    }
+    // Set AGENT_SH_SOCKET for agent extensions that connect directly
+    process.env.AGENT_SH_SOCKET = socketPath;
+    // Serialize shell/exec requests — only one PTY command at a time
+    let execPending = Promise.resolve();
+    // ── JSON-RPC handler ────────────────────────────────────────────
+    async function handleRequest(method, params) {
+        switch (method) {
+            case "shell/exec": {
+                const command = params?.command;
+                if (typeof command !== "string" || !command) {
+                    throw rpcError(-32602, "Missing required parameter: command");
+                }
+                // Serialize — one PTY command at a time
+                return new Promise((resolve, reject) => {
+                    execPending = execPending.then(async () => {
+                        try {
+                            bus.emit("shell:agent-exec-start", {});
+                            const result = await bus.emitPipeAsync("shell:exec-request", {
+                                command,
+                                output: "",
+                                cwd: "",
+                                done: false,
+                            });
+                            bus.emit("shell:agent-exec-done", {});
+                            resolve({ output: result.output, cwd: result.cwd });
+                        }
+                        catch (err) {
+                            bus.emit("shell:agent-exec-done", {});
+                            const message = err instanceof Error ? err.message : String(err);
+                            reject(rpcError(-32000, message));
+                        }
+                    });
+                });
+            }
+            case "shell/cwd":
+                return { cwd: contextManager.getCwd() };
+            case "shell/info":
+                return {
+                    shell: process.env.SHELL || "unknown",
+                    agentSh: true,
+                };
+            case "shell/recall": {
+                const operation = params?.operation || "browse";
+                switch (operation) {
+                    case "search": {
+                        const query = params?.query;
+                        if (typeof query !== "string" || !query) {
+                            throw rpcError(-32602, "Missing required parameter: query");
+                        }
+                        return { result: contextManager.search(query) };
+                    }
+                    case "expand": {
+                        const ids = params?.ids;
+                        if (!Array.isArray(ids) || ids.length === 0) {
+                            throw rpcError(-32602, "Missing required parameter: ids (array of numbers)");
+                        }
+                        const start = typeof params?.start === "number" ? params.start : undefined;
+                        const end = typeof params?.end === "number" ? params.end : undefined;
+                        return { result: contextManager.expand(ids.map(Number), start, end) };
+                    }
+                    case "browse":
+                        return { result: contextManager.getRecentSummary() };
+                    default:
+                        throw rpcError(-32602, `Unknown recall operation: ${operation}`);
+                }
+            }
+            default:
+                throw rpcError(-32601, `Method not found: ${method}`);
+        }
+    }
+    // ── Socket server ───────────────────────────────────────────────
+    const server = net.createServer((conn) => {
+        let buffer = "";
+        conn.on("data", (chunk) => {
+            buffer += chunk.toString();
+            // Process complete lines (newline-delimited JSON-RPC)
+            let newlineIdx;
+            while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.slice(0, newlineIdx).trim();
+                buffer = buffer.slice(newlineIdx + 1);
+                if (!line)
+                    continue;
+                processMessage(conn, line);
+            }
+        });
+    });
+    function processMessage(conn, line) {
+        let id = null;
+        try {
+            const msg = JSON.parse(line);
+            id = msg.id ?? null;
+            const method = msg.method;
+            if (!method) {
+                sendError(conn, id, -32600, "Invalid request: missing method");
+                return;
+            }
+            handleRequest(method, msg.params)
+                .then((result) => sendResult(conn, id, result))
+                .catch((err) => {
+                if (err && typeof err === "object" && "rpcCode" in err) {
+                    sendError(conn, id, err.rpcCode, err.message);
+                }
+                else {
+                    sendError(conn, id, -32603, String(err));
+                }
+            });
+        }
+        catch {
+            sendError(conn, id, -32700, "Parse error");
+        }
+    }
+    // Clean up stale socket file
+    try {
+        fs.unlinkSync(socketPath);
+    }
+    catch {
+        // Doesn't exist — fine
+    }
+    server.listen(socketPath);
+    // Cleanup on exit
+    const cleanup = () => {
+        server.close();
+        try {
+            fs.unlinkSync(socketPath);
+        }
+        catch { }
+    };
+    process.on("exit", cleanup);
+}
+// ── JSON-RPC helpers ──────────────────────────────────────────────
+function sendResult(conn, id, result) {
+    conn.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
+}
+function sendError(conn, id, code, message) {
+    conn.write(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } }) + "\n");
+}
+function rpcError(code, message) {
+    const err = new Error(message);
+    err.rpcCode = code;
+    return err;
+}

package/dist/extensions/tui-renderer.d.ts

@@ -1,2 +1,2 @@
 import type { ExtensionContext } from "../types.js";
-export default function activate({ bus }: ExtensionContext): void;
+export default function activate({ bus, getAcpClient }: ExtensionContext): void;

package/dist/extensions/tui-renderer.js

@@ -12,22 +12,27 @@
  */
 import { MarkdownRenderer } from "../utils/markdown.js";
 import { palette as p } from "../utils/palette.js";
-import { renderToolCall, renderToolResult, startSpinner, stopSpinner as stopToolSpinner, } from "../utils/tool-display.js";
+import { renderToolCall, startSpinner, stopSpinner as stopToolSpinner, } from "../utils/tool-display.js";
 import { renderDiff } from "../utils/diff-renderer.js";
 import { renderBoxFrame } from "../utils/box-frame.js";
-const MAX_COMMAND_OUTPUT_LINES = 30;
-export default function activate({ bus }) {
+import { getSettings } from "../settings.js";
+export default function activate({ bus, getAcpClient }) {
     let spinner = null;
     let renderer = null;
     let commandOutputBuffer = "";
     let commandOutputLineCount = 0;
     let commandOutputOverflow = 0;
     let lastCommand = "";
+    let toolLineOpen = false; // true when tool header was written without \n
+    let hadToolCalls = false; // true after any tool call in current response
+    let currentToolKind; // kind of the currently executing tool
     let isThinking = false;
     let showThinkingText = false;
+    let spinnerStartTime = 0; // preserved across spinner restarts
     let lastTruncatedDiff = null;
     // ── Event subscriptions ─────────────────────────────────────
     bus.on("agent:query", (e) => {
+        spinnerStartTime = 0;
         showUserQuery(e.query);
         startAgentResponse();
         startThinkingSpinner();
@@ -35,14 +40,15 @@ export default function activate({ bus }) {
     bus.on("agent:thinking-chunk", (e) => {
         if (!isThinking) {
             isThinking = true;
-            stopCurrentSpinner();
             if (showThinkingText) {
+                stopCurrentSpinner();
                 if (!renderer)
                     startAgentResponse();
-                renderer.writeLine(`${p.dim}${p.bold}💭 Thinking${p.reset}`);
+                renderer.writeLine(`${p.dim}Thinking (ctrl+t to collapse)${p.reset}`);
             }
             else {
-                startThinkingSpinner("Thinking");
+                // Restart spinner with ctrl+t hint now that we know thinking is available
+                startThinkingSpinner();
             }
         }
         if (showThinkingText && e.text) {
@@ -62,10 +68,28 @@ export default function activate({ bus }) {
     });
     bus.on("agent:tool-started", (e) => {
         stopCurrentSpinner();
-        showToolCall(e.title, lastCommand);
+        currentToolKind = e.kind;
+        if (e.title === "user_shell") {
+            // Minimal annotation — PTY echo will show the output
+            closeToolLine();
+            if (!renderer)
+                startAgentResponse();
+            renderer.flush();
+            const cmd = e.rawInput?.command || "";
+            renderer.writeLine(`${p.dim}▶ user_shell: ${cmd}${p.reset}`);
+            hadToolCalls = true;
+        }
+        else {
+            showToolCall(e.title, lastCommand, e);
+        }
         lastCommand = "";
     });
-    bus.on("agent:tool-completed", (e) => showToolComplete(e.exitCode));
+    bus.on("agent:tool-completed", (e) => {
+        showToolComplete(e.exitCode);
+        currentToolKind = undefined;
+        spinnerStartTime = 0;
+        startThinkingSpinner();
+    });
     bus.on("agent:tool-output-chunk", (e) => writeCommandOutput(e.chunk));
     bus.on("agent:tool-output", () => flushCommandOutput());
     bus.on("agent:cancelled", () => {
@@ -74,6 +98,11 @@ export default function activate({ bus }) {
         showInfo("(cancelled)");
         endAgentResponse();
     });
+    bus.on("agent:processing-done", () => {
+        isThinking = false;
+        stopCurrentSpinner();
+        endAgentResponse();
+    });
     bus.on("agent:error", (e) => showError(e.message));
     // Flush rendering state and show inline diff for file writes
     bus.on("permission:request", (e) => {
@@ -108,10 +137,11 @@ export default function activate({ bus }) {
     }
     function startAgentResponse() {
         renderer = new MarkdownRenderer();
-        process.stdout.write("\n");
+        hadToolCalls = false;
         renderer.printTopBorder();
     }
     function endAgentResponse() {
+        closeToolLine();
         if (renderer) {
             renderer.flush();
             renderer.printBottomBorder();
@@ -154,6 +184,9 @@ export default function activate({ bus }) {
         }
     }
     function writeAgentText(text) {
+        closeToolLine();
+        const needsGap = hadToolCalls;
+        hadToolCalls = false;
         if (isThinking) {
             isThinking = false;
             if (showThinkingText && renderer) {
@@ -166,19 +199,34 @@ export default function activate({ bus }) {
         stopCurrentSpinner();
         if (!renderer)
             startAgentResponse();
+        if (needsGap)
+            process.stdout.write("\n");
         renderer.push(text);
         flushOutput();
     }
-    function showToolCall(title, command) {
+    function showToolCall(title, command, extra) {
+        closeToolLine();
         stopCurrentSpinner();
         if (!renderer)
             startAgentResponse();
         renderer.flush();
         const termW = process.stdout.columns || 80;
-        const lines = renderToolCall({ title, command: command || undefined }, termW);
-        for (const line of lines) {
-            renderer.writeLine(line);
+        const lines = renderToolCall({
+            title,
+            command: command || undefined,
+            kind: extra?.kind,
+            locations: extra?.locations,
+            rawInput: extra?.rawInput,
+        }, termW);
+        // Write all lines except the last normally, write last without \n
+        for (let i = 0; i < lines.length - 1; i++) {
+            renderer.writeLine(lines[i]);
         }
+        if (lines.length > 0) {
+            process.stdout.write(`  ${lines[lines.length - 1]}`);
+            toolLineOpen = true;
+        }
+        hadToolCalls = true;
         // Reset output tracking for the new tool
         commandOutputLineCount = 0;
         commandOutputOverflow = 0;
@@ -186,15 +234,37 @@ export default function activate({ bus }) {
     function showToolComplete(exitCode) {
         if (!renderer)
             return;
-        const termW = process.stdout.columns || 80;
-        const lines = renderToolResult({ exitCode }, termW);
-        for (const line of lines) {
-            renderer.writeLine(line);
+        const mark = exitCode === null
+            ? `${p.muted}(timed out)${p.reset}`
+            : exitCode === 0
+                ? `${p.success}✓${p.reset}`
+                : `${p.error}✗ exit ${exitCode}${p.reset}`;
+        if (toolLineOpen && commandOutputLineCount === 0) {
+            // No output written — append mark on same line as tool header
+            process.stdout.write(` ${mark}\n`);
+            toolLineOpen = false;
+        }
+        else {
+            closeToolLine();
+            flushCommandOutput();
+            renderer.writeLine(`  ${mark}`);
         }
     }
-    function startThinkingSpinner(label = "Thinking") {
+    function hasThinkingMode() {
+        const mode = getAcpClient().getCurrentMode();
+        return !mode || mode.id !== "off";
+    }
+    function startThinkingSpinner() {
+        // Preserve start time if restarting (e.g. toggle), otherwise reset
+        if (!spinnerStartTime)
+            spinnerStartTime = Date.now();
         stopCurrentSpinner();
-        spinner = startSpinner(label);
+        const thinking = hasThinkingMode();
+        const label = thinking ? "Thinking" : "Working";
+        const hint = thinking
+            ? (showThinkingText ? "(ctrl+t to collapse)" : "(ctrl+t to expand)")
+            : "";
+        spinner = startSpinner(label, { hint: hint || undefined, startTime: spinnerStartTime });
     }
     function stopCurrentSpinner() {
         if (spinner) {
@@ -202,14 +272,24 @@ export default function activate({ bus }) {
             spinner = null;
         }
     }
+    function closeToolLine() {
+        if (toolLineOpen) {
+            process.stdout.write("\n");
+            toolLineOpen = false;
+        }
+    }
     function writeCommandOutput(chunk) {
         if (!renderer)
             return;
+        closeToolLine();
+        const maxLines = currentToolKind === "read"
+            ? getSettings().readOutputMaxLines
+            : getSettings().maxCommandOutputLines;
         commandOutputBuffer += chunk;
         const lines = commandOutputBuffer.split("\n");
         commandOutputBuffer = lines.pop();
         for (const line of lines) {
-            if (commandOutputLineCount < MAX_COMMAND_OUTPUT_LINES) {
+            if (commandOutputLineCount < maxLines) {
                 renderer.writeLine(`${p.dim}  ${line}${p.reset}`);
                 commandOutputLineCount++;
             }
@@ -221,8 +301,11 @@ export default function activate({ bus }) {
     function flushCommandOutput() {
         if (!renderer)
             return;
+        const maxLines = currentToolKind === "read"
+            ? getSettings().readOutputMaxLines
+            : getSettings().maxCommandOutputLines;
         if (commandOutputBuffer) {
-            if (commandOutputLineCount < MAX_COMMAND_OUTPUT_LINES) {
+            if (commandOutputLineCount < maxLines) {
                 renderer.writeLine(`${p.dim}  ${commandOutputBuffer}${p.reset}`);
                 commandOutputLineCount++;
             }
@@ -231,12 +314,11 @@ export default function activate({ bus }) {
             }
             commandOutputBuffer = "";
         }
-        if (commandOutputOverflow > 0) {
+        if (commandOutputOverflow > 0 && maxLines > 0) {
             renderer.writeLine(`${p.dim}  … ${commandOutputOverflow} more lines${p.reset}`);
-            commandOutputOverflow = 0;
         }
+        commandOutputOverflow = 0;
     }
-    const DIFF_MAX_LINES = 20;
     function diffTitle(filePath, diff) {
         const stats = diff.isNewFile
             ? `${p.success}+${diff.added}${p.reset}`
@@ -252,7 +334,7 @@ export default function activate({ bus }) {
         const diffLines = renderDiff(diff, {
             width: contentW,
             filePath,
-            maxLines: DIFF_MAX_LINES,
+            maxLines: getSettings().diffMaxLines,
             trueColor: true,
             mode: "unified",
         });
@@ -323,7 +405,7 @@ export default function activate({ bus }) {
         const diffLines = renderDiff(diff, {
             width: contentW,
             filePath,
-            maxLines: DIFF_MAX_LINES,
+            maxLines: getSettings().diffMaxLines,
             trueColor: true,
             mode: "unified",
         });
@@ -342,8 +424,31 @@ export default function activate({ bus }) {
     }
     function toggleThinkingDisplay() {
         showThinkingText = !showThinkingText;
-        const state = showThinkingText ? "on" : "off";
-        process.stdout.write(`\n${p.dim}Thinking display: ${state}${p.reset}\n`);
+        // Update spinner hint to reflect new state, even if not actively thinking
+        if (spinner) {
+            stopCurrentSpinner();
+            startThinkingSpinner();
+            return;
+        }
+        if (!isThinking)
+            return;
+        if (showThinkingText) {
+            // Switch from spinner to streaming text
+            stopCurrentSpinner();
+            if (!renderer)
+                startAgentResponse();
+            renderer.writeLine(`${p.dim}Thinking (ctrl+t to collapse)${p.reset}`);
+        }
+        else {
+            // Switch from streaming text to spinner
+            if (renderer) {
+                renderer.flush();
+                const termW = process.stdout.columns || 80;
+                const w = Math.min(80, termW);
+                renderer.writeLine(`${p.dim}${"─".repeat(w)}${p.reset}`);
+            }
+            startThinkingSpinner();
+        }
     }
     function showError(message) {
         process.stdout.write(`\n${p.error}Error: ${message}${p.reset}\n`);