agent-sh 0.3.1 → 0.5.0

package/dist/acp-client.js

@@ -1,656 +0,0 @@
-import { spawn } from "node:child_process";
-import { Readable, Writable } from "node:stream";
-import * as fs from "node:fs/promises";
-import * as acp from "@agentclientprotocol/sdk";
-import { executeCommand, killSession } from "./executor.js";
-import { computeDiff } from "./utils/diff.js";
-import { FileWatcher } from "./utils/file-watcher.js";
-import * as path from "node:path";
-import { stripAnsi } from "./utils/ansi.js";
-export class AcpClient {
-    agentProcess = null;
-    connection = null;
-    sessionId = null;
-    bus;
-    contextManager;
-    config;
-    promptInProgress = false;
-    currentResponseText = "";
-    lastResponseText = "";
-    terminalSessions = new Map();
-    terminalDonePromises = new Map();
-    terminalCounter = 0;
-    fileWatcher;
-    pendingToolCalls = new Map();
-    autoCancelled = false;
-    pendingToolCounter = 0;
-    agentInfo = null;
-    modes = [];
-    currentModeId = null;
-    constructor(opts) {
-        this.bus = opts.bus;
-        this.contextManager = opts.contextManager;
-        this.config = opts.config;
-        this.fileWatcher = new FileWatcher(process.cwd());
-    }
-    async start() {
-        this.log(`Starting agent: ${this.config.agentCommand} ${this.config.agentArgs.join(" ")}`);
-        // Spawn the agent subprocess with the user's full shell environment
-        // (includes vars from .zshrc/.bashrc that process.env may not have).
-        // Merge in any runtime env vars set by extensions (e.g. AGENT_SH_SOCKET)
-        // that weren't present when shellEnv was captured at startup.
-        const baseEnv = this.config.shellEnv ?? process.env;
-        const agentEnv = { ...baseEnv };
-        for (const [k, v] of Object.entries(process.env)) {
-            if (v !== undefined && !(k in agentEnv)) {
-                agentEnv[k] = v;
-            }
-        }
-        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) => {
-            const onError = (err) => {
-                reject(new Error(`Failed to start agent "${this.config.agentCommand}": ${err.message}`));
-            };
-            this.agentProcess.on("error", onError);
-            // spawn errors fire on next tick — wait for that, then detach the listener
-            setTimeout(() => {
-                this.agentProcess.removeListener("error", onError);
-                resolve();
-            }, 100);
-        });
-        this.log("Agent process spawned");
-        this.agentProcess.on("exit", (code) => {
-            this.bus.emit("agent:error", { message: `Agent process exited with code ${code}` });
-            this.connection = null;
-            this.sessionId = null;
-        });
-        if (!this.agentProcess.stdin || !this.agentProcess.stdout) {
-            throw new Error("Failed to get agent process stdio");
-        }
-        // Create ACP stream from the agent's stdio
-        const output = Writable.toWeb(this.agentProcess.stdin);
-        const input = Readable.toWeb(this.agentProcess.stdout);
-        const stream = acp.ndJsonStream(output, input);
-        this.log("Creating ACP connection");
-        // Create the client-side connection, providing our Client handler
-        this.connection = new acp.ClientSideConnection((_agent) => this.createClientHandler(), stream);
-        // Initialize the connection with timeout
-        this.log("Sending initialize request");
-        const initTimeoutMs = 30000; // 30 seconds
-        const initResponse = await Promise.race([
-            this.connection.initialize({
-                protocolVersion: acp.PROTOCOL_VERSION,
-                clientInfo: { name: "agent-sh", version: "0.1.0" },
-                clientCapabilities: {
-                    terminal: true,
-                    fs: {
-                        readTextFile: true,
-                        writeTextFile: true,
-                    },
-                },
-            }),
-            new Promise((_, reject) => setTimeout(() => reject(new Error(`Initialize timeout after ${initTimeoutMs}ms`)), initTimeoutMs)),
-        ]);
-        this.log("Initialize successful");
-        // Store agent info for display
-        if (initResponse.agentInfo) {
-            this.agentInfo = {
-                name: initResponse.agentInfo.name || this.config.agentCommand,
-                version: initResponse.agentInfo.version || "unknown"
-            };
-            this.log(`Agent info: ${this.agentInfo.name} v${this.agentInfo.version}`);
-        }
-        // Create a session — let extensions add MCP servers via pipe
-        const cwd = this.contextManager.getCwd();
-        this.log(`Creating new session with cwd: ${cwd}`);
-        const sessionConfig = this.bus.emitPipe("session:configure", {
-            cwd,
-            mcpServers: [],
-        });
-        const sessionTimeoutMs = 30000; // 30 seconds
-        const sessionResponse = await Promise.race([
-            this.connection.newSession({
-                cwd: sessionConfig.cwd,
-                mcpServers: sessionConfig.mcpServers,
-            }),
-            new Promise((_, reject) => setTimeout(() => reject(new Error(`newSession timeout after ${sessionTimeoutMs}ms`)), sessionTimeoutMs)),
-        ]);
-        this.sessionId = sessionResponse.sessionId;
-        this.log(`Session created: ${this.sessionId}`);
-        // Parse session modes (thinking level, etc.)
-        this.updateModes(sessionResponse);
-        // Listen for mode cycle requests from input handler
-        this.bus.on("config:cycle", () => this.cycleMode());
-    }
-    /**
-     * Send a user query to the agent.
-     */
-    async sendPrompt(query) {
-        if (!this.connection || !this.sessionId) {
-            this.bus.emit("agent:error", { message: "Not connected to agent" });
-            return;
-        }
-        this.promptInProgress = true;
-        this.bus.emit("agent:processing-start", {});
-        await this.fileWatcher.snapshot();
-        this.currentResponseText = "";
-        this.autoCancelled = false;
-        let cancelled = false;
-        // Emit agent query event (TUI renders echo+spinner, ContextManager records it)
-        this.bus.emit("agent:query", { query });
-        // Build structured context from ContextManager
-        const contextBlock = this.contextManager.getContext();
-        try {
-            this.log("sending prompt...");
-            const response = await this.connection.prompt({
-                sessionId: this.sessionId,
-                prompt: [
-                    {
-                        type: "text",
-                        text: contextBlock + "\n" + query,
-                    },
-                ],
-            });
-            this.log(`prompt resolved: stopReason=${response.stopReason}`);
-            if (response.stopReason === "cancelled") {
-                cancelled = true;
-                if (!this.autoCancelled) {
-                    this.bus.emit("agent:cancelled", {});
-                }
-            }
-        }
-        catch (err) {
-            this.log(`prompt error: ${err}`);
-            this.bus.emit("agent:error", {
-                message: err instanceof Error ? err.message : String(err),
-            });
-        }
-        finally {
-            this.log("restoring shell mode");
-            if (!cancelled) {
-                this.bus.emitTransform("agent:response-done", {
-                    response: this.currentResponseText,
-                });
-            }
-            this.lastResponseText = this.currentResponseText;
-            // Show diff previews for files the agent modified via its own tools
-            // (modifications via fs/writeTextFile are already handled inline)
-            if (this.promptInProgress) {
-                await this.showPendingFileChanges();
-            }
-            this.bus.emit("agent:processing-done", {});
-            this.promptInProgress = false;
-        }
-    }
-    /**
-     * Silently cancel the prompt after a shell tool completes.
-     * Unlike user-initiated cancel(), this doesn't show "(cancelled)" —
-     * the tool already ran, we just skip the unnecessary LLM follow-up.
-     */
-    autoCancel() {
-        if (!this.connection || !this.sessionId || !this.promptInProgress)
-            return;
-        this.log("auto-cancel: shell tool completed, skipping LLM follow-up");
-        this.autoCancelled = true;
-        this.connection.cancel({ sessionId: this.sessionId }).catch(() => { });
-    }
-    /**
-     * Cancel the current prompt and force-recover shell mode.
-     */
-    async cancel() {
-        this.log("cancel requested");
-        // Kill all running terminal sessions
-        for (const session of this.terminalSessions.values()) {
-            if (!session.done)
-                killSession(session);
-        }
-        if (this.connection && this.sessionId && this.promptInProgress) {
-            try {
-                await this.connection.cancel({ sessionId: this.sessionId });
-            }
-            catch {
-                // Cancellation is best-effort
-            }
-        }
-        // Force-recover shell regardless of prompt state
-        if (this.promptInProgress) {
-            this.bus.emit("agent:cancelled", {});
-        }
-        this.bus.emit("agent:processing-done", {});
-        this.promptInProgress = false;
-    }
-    /**
-     * Start a new ACP session, clearing agent-side conversation history.
-     */
-    async resetSession() {
-        if (!this.connection)
-            return;
-        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 = "";
-        this.updateModes(sessionResponse);
-    }
-    /**
-     * Get the text of the last agent response (for /copy).
-     */
-    getLastResponseText() {
-        return this.lastResponseText;
-    }
-    /**
-     * Get agent information for display.
-     */
-    getAgentInfo() {
-        return this.agentInfo;
-    }
-    getModel() {
-        return this.config.model;
-    }
-    /**
-     * Get the current mode (e.g. thinking level).
-     */
-    getCurrentMode() {
-        if (!this.currentModeId)
-            return null;
-        return this.modes.find((m) => m.id === this.currentModeId) ?? null;
-    }
-    /**
-     * Check if agent is connected.
-     */
-    isConnected() {
-        // Consider connected if we have a connection and agent info
-        // Session ID may not be set yet if we're still initializing
-        return this.connection !== null && this.agentInfo !== null;
-    }
-    /**
-     * Parse modes from a session response and notify listeners.
-     */
-    updateModes(response) {
-        const modes = response.modes;
-        if (!modes)
-            return;
-        if (modes.availableModes) {
-            this.modes = modes.availableModes.map((m) => ({
-                id: m.id,
-                name: m.name || m.id,
-            }));
-        }
-        if (modes.currentModeId) {
-            this.currentModeId = modes.currentModeId;
-        }
-        this.bus.emit("config:changed", {});
-    }
-    /**
-     * Cycle to the next session mode.
-     */
-    async cycleMode() {
-        if (!this.connection || !this.sessionId || this.modes.length === 0)
-            return;
-        const currentIdx = this.modes.findIndex((m) => m.id === this.currentModeId);
-        const nextIdx = (currentIdx + 1) % this.modes.length;
-        const nextMode = this.modes[nextIdx];
-        try {
-            await this.connection.setSessionMode({
-                sessionId: this.sessionId,
-                modeId: nextMode.id,
-            });
-            this.currentModeId = nextMode.id;
-            this.bus.emit("config:changed", {});
-        }
-        catch (err) {
-            this.log(`Failed to set mode: ${err}`);
-        }
-    }
-    log(msg) {
-        if (process.env.DEBUG) {
-            process.stderr.write(`[agent-sh] ${msg}\n`);
-        }
-    }
-    /**
-     * Create the Client handler that responds to agent requests.
-     */
-    createClientHandler() {
-        return {
-            // Required: handle session update notifications (streaming)
-            // Errors must not propagate — the ACP SDK returns them as error
-            // responses to the agent, which can stall the stream.
-            sessionUpdate: async (params) => {
-                try {
-                    this.handleSessionUpdate(params);
-                }
-                catch (err) {
-                    this.log(`Error in sessionUpdate handler: ${err instanceof Error ? err.stack : err}`);
-                }
-            },
-            // Required: handle permission requests
-            requestPermission: async (params) => {
-                return this.handleRequestPermission(params);
-            },
-            // Optional: terminal operations
-            createTerminal: async (params) => {
-                return this.handleCreateTerminal(params);
-            },
-            terminalOutput: async (params) => {
-                return this.handleTerminalOutput(params);
-            },
-            waitForTerminalExit: async (params) => {
-                return this.handleWaitForTerminalExit(params);
-            },
-            killTerminal: async (params) => {
-                return this.handleKillTerminal(params);
-            },
-            releaseTerminal: async (params) => {
-                return this.handleReleaseTerminal(params);
-            },
-            // Optional: filesystem operations
-            readTextFile: async (params) => {
-                return this.handleReadTextFile(params);
-            },
-            writeTextFile: async (params) => {
-                return this.handleWriteTextFile(params);
-            },
-        };
-    }
-    // ── Session update handler ─────────────────────────────────────
-    handleSessionUpdate(params) {
-        // Suppress rendering during initialization / between prompts
-        if (!this.promptInProgress)
-            return;
-        const update = params.update;
-        switch (update.sessionUpdate) {
-            case "agent_message_chunk": {
-                const content = update.content;
-                if (content.type === "text") {
-                    this.currentResponseText += content.text;
-                    this.bus.emitTransform("agent:response-chunk", { text: content.text });
-                }
-                break;
-            }
-            case "agent_thought_chunk": {
-                const thought = update.content;
-                if (thought.type === "text" && thought.text) {
-                    this.bus.emitTransform("agent:thinking-chunk", { text: thought.text });
-                }
-                break;
-            }
-            case "tool_call": {
-                const toolId = update.toolCallId || `tool-${this.pendingToolCounter++}`;
-                const payload = {
-                    title: update.title,
-                    toolCallId: toolId,
-                    kind: update.kind ?? undefined,
-                    locations: update.locations?.map((l) => ({ path: l.path, line: l.line })),
-                    rawInput: update.rawInput,
-                };
-                const defer = this.pendingToolCalls.size > 0;
-                this.pendingToolCalls.set(toolId, {
-                    title: update.title ?? "",
-                    deferredPayload: defer ? payload : undefined,
-                });
-                if (!defer) {
-                    this.bus.emit("agent:tool-started", payload);
-                }
-                break;
-            }
-            case "tool_call_update": {
-                const toolId = update.toolCallId;
-                const toolInfo = toolId ? this.pendingToolCalls.get(toolId) : undefined;
-                const toolTitle = toolInfo?.title;
-                if (update.status === "completed" || update.status === "failed") {
-                    // Emit deferred tool-started before output (parallel tools)
-                    if (toolInfo?.deferredPayload) {
-                        this.bus.emit("agent:tool-started", toolInfo.deferredPayload);
-                        toolInfo.deferredPayload = undefined;
-                    }
-                    // Show content only on final status. Skip tools whose output the
-                    // user already sees (user_shell → PTY) or is agent-only (shell_recall).
-                    const skipOutput = toolTitle === "user_shell" || toolTitle === "shell_recall";
-                    if (!skipOutput && 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.emitTransform("agent:tool-output-chunk", { chunk: block.content.text });
-                            }
-                        }
-                    }
-                    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,
-                            rawOutput: update.rawOutput,
-                        });
-                    }
-                    else if (!toolId) {
-                        this.bus.emit("agent:tool-completed", { exitCode, rawOutput: update.rawOutput });
-                    }
-                    // Auto-cancel after shell tools complete — the command already
-                    // ran in the user's PTY, no need for a second LLM round trip.
-                    // The result is captured in shell context / shell_recall.
-                    if (toolTitle === "user_shell" && update.status === "completed") {
-                        this.autoCancel();
-                    }
-                }
-                break;
-            }
-            case "current_mode_update": {
-                const modeId = update.currentModeId;
-                if (modeId) {
-                    this.currentModeId = modeId;
-                    this.bus.emit("config:changed", {});
-                }
-                break;
-            }
-            default:
-                break;
-        }
-    }
-    // ── Permission handler ─────────────────────────────────────────
-    async handleRequestPermission(params) {
-        const title = params.toolCall.title ?? "Unknown action";
-        const result = await this.bus.emitPipeAsync("permission:request", {
-            kind: "tool-call",
-            title,
-            metadata: {
-                options: params.options.map((o) => ({
-                    optionId: o.optionId,
-                    kind: o.kind,
-                })),
-            },
-            decision: {
-                outcome: "selected",
-                optionId: (params.options.find((o) => o.kind === "allow_once") ?? params.options[0])?.optionId,
-            },
-        });
-        return { outcome: result.decision };
-    }
-    // ── Terminal handlers (isolated execution via child_process) ────
-    async handleCreateTerminal(params) {
-        const fullCommand = params.args?.length
-            ? `${params.command} ${params.args.join(" ")}`
-            : params.command;
-        const cwd = params.cwd ?? this.contextManager.getCwd();
-        // Let extensions intercept before spawning a real process
-        const intercept = this.bus.emitPipe("agent:terminal-intercept", {
-            command: fullCommand,
-            cwd,
-            intercepted: false,
-            output: "",
-        });
-        if (intercept.intercepted) {
-            const id = `t${++this.terminalCounter}`;
-            const session = {
-                id,
-                command: fullCommand,
-                output: intercept.output,
-                exitCode: 0,
-                done: true,
-                truncated: false,
-                process: null,
-            };
-            this.terminalSessions.set(id, session);
-            this.terminalDonePromises.set(id, Promise.resolve());
-            return { terminalId: id };
-        }
-        this.bus.emit("agent:tool-call", {
-            tool: fullCommand,
-            args: { command: params.command, args: params.args, cwd },
-        });
-        const id = `t${++this.terminalCounter}`;
-        const { session, done } = executeCommand({
-            command: fullCommand,
-            cwd,
-            env: this.config.shellEnv,
-            timeout: 60_000,
-            maxOutputBytes: 256 * 1024,
-            onOutput: (chunk) => {
-                // Stream output into the box in real-time (strip ANSI for display)
-                this.bus.emit("agent:tool-output-chunk", { chunk: stripAnsi(chunk) });
-            },
-        });
-        session.id = id;
-        this.terminalSessions.set(id, session);
-        this.terminalDonePromises.set(id, done);
-        return { terminalId: id };
-    }
-    async handleTerminalOutput(params) {
-        const session = this.terminalSessions.get(params.terminalId);
-        if (!session) {
-            return { output: "", truncated: false };
-        }
-        return {
-            output: session.output,
-            truncated: session.truncated,
-            ...(session.done && {
-                exitStatus: { exitCode: session.exitCode },
-            }),
-        };
-    }
-    async handleWaitForTerminalExit(params) {
-        const session = this.terminalSessions.get(params.terminalId);
-        if (!session) {
-            return { exitCode: -1 };
-        }
-        if (!session.done) {
-            const done = this.terminalDonePromises.get(params.terminalId);
-            if (done)
-                await done;
-        }
-        this.bus.emit("agent:tool-output", {
-            tool: session.command ?? "",
-            output: session.output,
-            exitCode: session.exitCode,
-        });
-        return { exitCode: session.exitCode ?? -1 };
-    }
-    async handleKillTerminal(params) {
-        const session = this.terminalSessions.get(params.terminalId);
-        if (session && !session.done) {
-            killSession(session);
-        }
-        return {};
-    }
-    async handleReleaseTerminal(params) {
-        this.terminalSessions.delete(params.terminalId);
-        this.terminalDonePromises.delete(params.terminalId);
-        return {};
-    }
-    // ── Filesystem handlers ────────────────────────────────────────
-    async handleReadTextFile(params) {
-        try {
-            let content = await fs.readFile(params.path, "utf-8");
-            if (params.line != null || params.limit != null) {
-                const lines = content.split("\n");
-                const start = (params.line ?? 1) - 1;
-                const end = params.limit != null ? start + params.limit : lines.length;
-                content = lines.slice(start, end).join("\n");
-            }
-            return { content };
-        }
-        catch (err) {
-            throw new Error(`Failed to read ${params.path}: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    async handleWriteTextFile(params) {
-        // Read original content for diff preview
-        let original = null;
-        try {
-            original = await fs.readFile(params.path, "utf-8");
-        }
-        catch {
-            // File doesn't exist yet — will show as "new file"
-        }
-        const diff = computeDiff(original, params.content);
-        // Identical content — nothing to do
-        if (diff.isIdentical)
-            return {};
-        // Extensions can gate this — default is auto-approve (yolo mode)
-        const result = await this.bus.emitPipeAsync("permission:request", {
-            kind: "file-write",
-            title: params.path,
-            metadata: { path: params.path, diff, content: params.content },
-            decision: { approved: true },
-        });
-        if (!result.decision.approved) {
-            throw new Error(`User rejected modification: ${params.path}`);
-        }
-        // Write the file
-        try {
-            await fs.writeFile(params.path, params.content, "utf-8");
-            this.fileWatcher.approve(path.resolve(params.path), params.content);
-            return {};
-        }
-        catch (err) {
-            throw new Error(`Failed to write ${params.path}: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    // ── Diff preview for non-ACP file changes ────────────────────
-    /**
-     * After the agent finishes, check all tracked files for changes
-     * made via the agent's own tools (not through fs/writeTextFile)
-     * and show interactive diff previews.
-     */
-    async showPendingFileChanges() {
-        const changes = await this.fileWatcher.detectChanges();
-        if (changes.length === 0)
-            return;
-        for (const change of changes) {
-            const diff = computeDiff(change.before, change.after);
-            if (diff.isIdentical)
-                continue;
-            const result = await this.bus.emitPipeAsync("permission:request", {
-                kind: "file-write",
-                title: change.relPath,
-                metadata: { path: change.relPath, diff, content: change.after },
-                decision: { approved: true },
-            });
-            if (result.decision.approved) {
-                this.fileWatcher.approve(change.path, change.after);
-            }
-            else {
-                await this.fileWatcher.revert(change.path);
-            }
-        }
-    }
-    // ── Cleanup ────────────────────────────────────────────────────
-    kill() {
-        for (const session of this.terminalSessions.values()) {
-            if (!session.done)
-                killSession(session);
-        }
-        if (this.agentProcess && !this.agentProcess.killed) {
-            this.agentProcess.kill("SIGTERM");
-        }
-    }
-}

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

@@ -1,24 +0,0 @@
-/**
- * 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;