agent-sh 0.1.0 → 0.2.0

package/dist/acp-client.js

@@ -32,10 +32,12 @@ export class AcpClient {
     }
     async start() {
         this.log(`Starting agent: ${this.config.agentCommand} ${this.config.agentArgs.join(" ")}`);
-        // Spawn the agent subprocess
-        // Spawn the agent — wait briefly to catch ENOENT and other spawn errors
+        // Spawn the agent subprocess with the user's full shell environment
+        // (includes vars from .zshrc/.bashrc that process.env may not have)
+        const agentEnv = this.config.shellEnv ?? process.env;
         this.agentProcess = spawn(this.config.agentCommand, this.config.agentArgs, {
             stdio: ["pipe", "pipe", process.env.DEBUG ? "inherit" : "ignore"],
+            env: agentEnv,
         });
         // Catch spawn errors (ENOENT, EACCES, etc.) before proceeding
         await new Promise((resolve, reject) => {
@@ -87,13 +89,17 @@ export class AcpClient {
             };
             this.log(`Agent info: ${this.agentInfo.name} v${this.agentInfo.version}`);
         }
-        // Create a session
+        // Create a session — let extensions add MCP servers via pipe
         const cwd = this.contextManager.getCwd();
         this.log(`Creating new session with cwd: ${cwd}`);
-        const sessionResponse = await this.connection.newSession({
+        const sessionConfig = this.bus.emitPipe("session:configure", {
             cwd,
             mcpServers: [],
         });
+        const sessionResponse = await this.connection.newSession({
+            cwd: sessionConfig.cwd,
+            mcpServers: sessionConfig.mcpServers,
+        });
         this.sessionId = sessionResponse.sessionId;
         this.log(`Session created: ${this.sessionId}`);
     }
@@ -185,10 +191,14 @@ export class AcpClient {
     async resetSession() {
         if (!this.connection)
             return;
-        const sessionResponse = await this.connection.newSession({
+        const sessionConfig = this.bus.emitPipe("session:configure", {
             cwd: this.contextManager.getCwd(),
             mcpServers: [],
         });
+        const sessionResponse = await this.connection.newSession({
+            cwd: sessionConfig.cwd,
+            mcpServers: sessionConfig.mcpServers,
+        });
         this.sessionId = sessionResponse.sessionId;
         this.lastResponseText = "";
         this.currentResponseText = "";
@@ -282,23 +292,39 @@ export class AcpClient {
                 break;
             }
             case "tool_call": {
-                // Use toolCallId if available, otherwise generate a simple ID
                 const toolId = update.toolCallId || `tool-${this.pendingToolCounter++}`;
                 this.pendingToolCalls.set(toolId, true);
-                this.bus.emit("agent:tool-started", { title: update.title, toolCallId: toolId });
+                this.bus.emit("agent:tool-started", {
+                    title: update.title,
+                    toolCallId: toolId,
+                    kind: update.kind ?? undefined,
+                    locations: update.locations?.map((l) => ({ path: l.path, line: l.line })),
+                    rawInput: update.rawInput,
+                });
                 break;
             }
             case "tool_call_update": {
-                // Only show result when the tool completes, don't show tool call again
+                // Stream tool output content (text from pi's internal tool results)
+                if (update.content && Array.isArray(update.content)) {
+                    for (const block of update.content) {
+                        if (block.type === "content" && block.content?.type === "text" && block.content.text) {
+                            this.bus.emit("agent:tool-output-chunk", { chunk: block.content.text });
+                        }
+                    }
+                }
                 if (update.status === "completed" || update.status === "failed") {
                     const toolId = update.toolCallId;
                     const exitCode = update.status === "completed" ? 0 : 1;
                     if (toolId && this.pendingToolCalls.has(toolId)) {
                         this.pendingToolCalls.delete(toolId);
-                        this.bus.emit("agent:tool-completed", { toolCallId: toolId, exitCode });
+                        this.bus.emit("agent:tool-completed", {
+                            toolCallId: toolId,
+                            exitCode,
+                            rawOutput: update.rawOutput,
+                        });
                     }
                     else if (!toolId) {
-                        this.bus.emit("agent:tool-completed", { exitCode });
+                        this.bus.emit("agent:tool-completed", { exitCode, rawOutput: update.rawOutput });
                     }
                 }
                 break;
@@ -363,6 +389,7 @@ export class AcpClient {
         const { session, done } = executeCommand({
             command: fullCommand,
             cwd,
+            env: this.config.shellEnv,
             timeout: 60_000,
             maxOutputBytes: 256 * 1024,
             onOutput: (chunk) => {

package/dist/context-manager.d.ts

@@ -25,7 +25,7 @@ export declare class ContextManager {
      */
     getRecentSummary(n?: number): string;
     /**
-     * Parse and handle __shell_recall commands.
+     * Parse and handle shell_recall commands.
      */
     handleRecallCommand(command: string): string;
     /**

package/dist/context-manager.js

@@ -165,21 +165,21 @@ export class ContextManager {
         return recent.map((ex) => this.exchangeOneLiner(ex)).join("\n");
     }
     /**
-     * Parse and handle __shell_recall commands.
+     * Parse and handle shell_recall commands.
      */
     handleRecallCommand(command) {
-        const args = command.replace(/^__shell_recall\s*/, "").trim();
+        const args = command.replace(/^_*shell_recall\s*/, "").trim();
         if (!args || args === "--help") {
             return [
                 "Usage:",
-                "  __shell_recall                    Browse recent exchanges",
-                "  __shell_recall --search <query>   Search all exchanges",
-                "  __shell_recall --expand <id,...>   Show full content of exchanges",
+                "  shell_recall                    Browse recent exchanges",
+                "  shell_recall --search <query>   Search all exchanges",
+                "  shell_recall --expand <id,...>   Show full content of exchanges",
                 "",
                 "Examples:",
-                '  __shell_recall --search "test fail"',
-                "  __shell_recall --expand 41",
-                "  __shell_recall --expand 41,42,43",
+                '  shell_recall --search "test fail"',
+                "  shell_recall --expand 41",
+                "  shell_recall --expand 41,42,43",
             ].join("\n");
         }
         const searchMatch = args.match(/^--search\s+(?:"([^"]+)"|(\S+))/);
@@ -232,13 +232,13 @@ export class ContextManager {
             const ex = result[i];
             const before = this.exchangeSize(ex);
             if (ex.type === "shell_command") {
-                ex.output = `[output omitted, use __shell_recall --expand ${ex.id}]`;
+                ex.output = `[output omitted, use shell_recall tool to expand id ${ex.id}]`;
             }
             else if (ex.type === "tool_execution") {
-                ex.output = `[output omitted, use __shell_recall --expand ${ex.id}]`;
+                ex.output = `[output omitted, use shell_recall tool to expand id ${ex.id}]`;
             }
             else if (ex.type === "agent_response") {
-                ex.response = `[response omitted, use __shell_recall --expand ${ex.id}]`;
+                ex.response = `[response omitted, use shell_recall tool to expand id ${ex.id}]`;
             }
             totalSize -= before - this.exchangeSize(ex);
         }
@@ -250,7 +250,7 @@ export class ContextManager {
         let out = "<shell_context>\n";
         out += `cwd: ${this.currentCwd}\n`;
         out += `session: ${totalCount} exchanges, ${elapsed}m elapsed\n`;
-        out += `[hint: run \`__shell_recall --search "query"\` or \`__shell_recall --expand ID\` to retrieve truncated content]\n`;
+        out += `[hint: use the shell_recall tool to retrieve truncated content — search(query) or expand(ids)]\n`;
         for (const ex of exchanges) {
             out += "\n" + this.formatExchangeTruncated(ex);
         }
@@ -381,7 +381,7 @@ function truncateOutput(text, threshold, headLines, tailLines, id) {
     const omitted = lines.length - headLines - tailLines;
     return [
         ...lines.slice(0, headLines),
-        `[... ${omitted} lines truncated, use __shell_recall --expand ${id} to see full output ...]`,
+        `[... ${omitted} lines truncated, use shell_recall tool with expand and id ${id} to see full output ...]`,
         ...lines.slice(-tailLines),
     ].join("\n");
 }
@@ -391,7 +391,7 @@ function truncateHead(text, threshold, headLines, id) {
         return text;
     return [
         ...lines.slice(0, headLines),
-        `[... truncated, use __shell_recall --expand ${id} for full response ...]`,
+        `[... truncated, use shell_recall tool with expand and id ${id} for full response ...]`,
     ].join("\n");
 }
 function indent(text, prefix) {

package/dist/event-bus.d.ts

@@ -52,10 +52,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 +96,24 @@ 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;
+            }[];
+        }[];
+    };
     "autocomplete:request": {
         buffer: string;
         items: {

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,183 @@
+/**
+ * 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";
+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 user_shell tool
+    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 }],
+                },
+            ],
+        };
+    });
+    // Also set AGENT_SH_SOCKET for pi 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 {
+                            const result = await bus.emitPipeAsync("shell:exec-request", {
+                                command,
+                                output: "",
+                                cwd: "",
+                                done: false,
+                            });
+                            // Show the command output in the TUI
+                            if (result.output) {
+                                bus.emit("agent:tool-output-chunk", { chunk: result.output });
+                            }
+                            resolve({ output: result.output, cwd: result.cwd });
+                        }
+                        catch (err) {
+                            const message = err instanceof Error ? err.message : String(err);
+                            bus.emit("agent:tool-output-chunk", { chunk: `Error: ${message}` });
+                            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)");
+                        }
+                        return { result: contextManager.expand(ids.map(Number)) };
+                    }
+                    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.js

@@ -62,7 +62,7 @@ export default function activate({ bus }) {
     });
     bus.on("agent:tool-started", (e) => {
         stopCurrentSpinner();
-        showToolCall(e.title, lastCommand);
+        showToolCall(e.title, lastCommand, e);
         lastCommand = "";
     });
     bus.on("agent:tool-completed", (e) => showToolComplete(e.exitCode));
@@ -169,13 +169,19 @@ export default function activate({ bus }) {
         renderer.push(text);
         flushOutput();
     }
-    function showToolCall(title, command) {
+    function showToolCall(title, command, extra) {
         stopCurrentSpinner();
         if (!renderer)
             startAgentResponse();
         renderer.flush();
         const termW = process.stdout.columns || 80;
-        const lines = renderToolCall({ title, command: command || undefined }, termW);
+        const lines = renderToolCall({
+            title,
+            command: command || undefined,
+            kind: extra?.kind,
+            locations: extra?.locations,
+            rawInput: extra?.rawInput,
+        }, termW);
         for (const line of lines) {
             renderer.writeLine(line);
         }

package/dist/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { execFileSync } from "node:child_process";
 import { Shell } from "./shell.js";
 import { createCore } from "./core.js";
 import { palette as p } from "./utils/palette.js";
@@ -6,7 +7,39 @@ import tuiRenderer from "./extensions/tui-renderer.js";
 import slashCommands from "./extensions/slash-commands.js";
 import fileAutocomplete from "./extensions/file-autocomplete.js";
 import shellRecall from "./extensions/shell-recall.js";
+import shellExec from "./extensions/shell-exec.js";
 import { loadExtensions } from "./extension-loader.js";
+/**
+ * Capture the user's full shell environment by running a quick interactive
+ * subshell. This picks up env vars exported in .zshrc/.bashrc that the
+ * Node.js process (which was spawned before the PTY sources rc files)
+ * doesn't have.
+ */
+function captureShellEnv(shell) {
+    try {
+        const output = execFileSync(shell, ["-i", "-c", "env -0"], {
+            encoding: "utf-8",
+            timeout: 5000,
+            stdio: ["pipe", "pipe", "pipe"], // suppress interactive noise on stderr
+        });
+        const env = {};
+        for (const entry of output.split("\0")) {
+            const eq = entry.indexOf("=");
+            if (eq > 0)
+                env[entry.slice(0, eq)] = entry.slice(eq + 1);
+        }
+        return env;
+    }
+    catch {
+        // Fallback: use Node's own environment
+        const env = {};
+        for (const [k, v] of Object.entries(process.env)) {
+            if (v !== undefined)
+                env[k] = v;
+        }
+        return env;
+    }
+}
 function parseArgs(argv) {
     // Priority: CLI args > Environment variables > Config file > Defaults
     const defaultAgent = process.env.AGENT_SH_AGENT || "pi-acp";
@@ -92,6 +125,9 @@ function formatAgentInfo(agentInfo, model) {
 }
 async function main() {
     const config = parseArgs(process.argv.slice(2));
+    // Capture the user's shell environment (picks up vars from .zshrc/.bashrc
+    // that the Node process doesn't have)
+    config.shellEnv = captureShellEnv(config.shell || process.env.SHELL || "/bin/bash");
     // ── Core (frontend-agnostic) ──────────────────────────────────
     const core = createCore(config);
     const { bus, client } = core;
@@ -130,6 +166,12 @@ async function main() {
     slashCommands(extCtx);
     fileAutocomplete(extCtx);
     shellRecall(extCtx);
+    // Shell-exec: start the Unix socket bridge so the MCP server can
+    // route user_shell tool calls to the PTY via the EventBus.
+    const tmpDir = shell.getTmpDir();
+    if (tmpDir) {
+        shellExec(extCtx, { socketPath: `${tmpDir}/shell.sock` });
+    }
     await loadExtensions(extCtx, config.extensions);
     // ── Agent connection (async — don't block shell startup) ──────
     core.start().catch((err) => {

package/dist/input-handler.d.ts

@@ -17,7 +17,7 @@ export declare class InputHandler {
     private ctx;
     private lineBuffer;
     private agentInputMode;
-    private agentInputBuffer;
+    private editor;
     private autocompleteActive;
     private autocompleteIndex;
     private autocompleteItems;
@@ -32,7 +32,7 @@ export declare class InputHandler {
             model?: string;
         };
     });
-    /** Write the agent prompt line (clear + info prefix + ❯ + buffer text). */
+    /** Write the agent prompt line with cursor at the correct position. */
     private writeAgentPromptLine;
     handleInput(data: string): void;
     private enterAgentInputMode;
@@ -41,8 +41,8 @@ export declare class InputHandler {
     private renderAgentInput;
     private updateAutocomplete;
     private renderAutocomplete;
-    private clearAutocompleteLines;
     private applyAutocomplete;
     private dismissAutocomplete;
+    private clearAutocompleteLines;
     private handleAgentInput;
 }