agent-sh 0.8.0 → 0.10.0

package/examples/extensions/ash-acp-bridge/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}

package/examples/extensions/ash-mcp-bridge/README.md

@@ -0,0 +1,72 @@
+# ash-mcp-bridge
+
+Connects any MCP (Model Context Protocol) server to ash. Spawns servers as child processes over stdio, discovers their tools, and registers each as a native ash tool.
+
+## Setup
+
+```bash
+cp -r examples/extensions/ash-mcp-bridge ~/.agent-sh/extensions/
+cd ~/.agent-sh/extensions/ash-mcp-bridge && npm install
+```
+
+## Configuration
+
+Add server definitions to `~/.agent-sh/settings.json`:
+
+```json
+{
+  "mcp-bridge": {
+    "servers": {
+      "vision": {
+        "command": "npx",
+        "args": ["-y", "@z_ai/mcp-server"],
+        "env": {
+          "Z_AI_API_KEY": "your-key",
+          "Z_AI_MODE": "ZAI"
+        }
+      }
+    }
+  }
+}
+```
+
+Each server entry:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `command` | `string` | Executable to spawn (e.g. `npx`, `node`) |
+| `args` | `string[]` | Command arguments |
+| `env` | `Record<string, string>` | Extra environment variables (merged with `process.env`) |
+
+## How it works
+
+On activation, the extension:
+
+1. Reads `mcp-bridge.servers` from settings
+2. Spawns each server as a child process with stdio transport
+3. Connects via the MCP SDK client
+4. Calls `listTools()` to discover available tools
+5. Registers each tool as `mcp_{server}_{tool}` (e.g. `mcp_vision_image_analysis`)
+
+Tools are then available to the agent like any built-in tool.
+
+## Example: Z.AI Vision
+
+```json
+{
+  "mcp-bridge": {
+    "servers": {
+      "vision": {
+        "command": "npx",
+        "args": ["-y", "@z_ai/mcp-server"],
+        "env": {
+          "Z_AI_API_KEY": "your-key",
+          "Z_AI_MODE": "ZAI"
+        }
+      }
+    }
+  }
+}
+```
+
+This gives the agent access to tools like `mcp_vision_image_analysis`, `mcp_vision_ui_to_artifact`, `mcp_vision_extract_text_from_screenshot`, etc.

package/examples/extensions/ash-mcp-bridge/index.ts

@@ -0,0 +1,164 @@
+/**
+ * MCP Bridge — connects external MCP servers to agent-sh.
+ *
+ * Spawns MCP servers as child processes, discovers their tools,
+ * and registers each tool as an agent-sh ToolDefinition.
+ *
+ * Configure in ~/.agent-sh/settings.json:
+ *
+ *   {
+ *     "extensions": ["./path/to/mcp-bridge"],
+ *     "mcp-bridge": {
+ *       "servers": {
+ *         "vision": {
+ *           "command": "npx",
+ *           "args": ["-y", "@z_ai/mcp-server"],
+ *           "env": {
+ *             "Z_AI_API_KEY": "your-key",
+ *             "Z_AI_MODE": "ZAI"
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ */
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+interface McpServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+interface McpBridgeSettings {
+  servers: Record<string, McpServerConfig>;
+}
+
+interface ConnectedServer {
+  name: string;
+  client: Client;
+  transport: StdioClientTransport;
+}
+
+export default async function activate(ctx: any): Promise<void> {
+  const { bus } = ctx;
+
+  const settings = ctx.getExtensionSettings("mcp-bridge", {
+    servers: {},
+  }) as McpBridgeSettings;
+
+  const serverEntries = Object.entries(settings.servers);
+  if (serverEntries.length === 0) return;
+
+  const connected: ConnectedServer[] = [];
+
+  for (const [name, config] of serverEntries) {
+    try {
+      const server = await connectServer(name, config, ctx);
+      connected.push(server);
+    } catch (err: any) {
+      bus.emit("ui:info", {
+        message: `mcp-bridge: failed to connect "${name}": ${err.message}`,
+      });
+    }
+  }
+
+  // Contribute connected servers to the startup banner
+  bus.onPipe("banner:collect", (e) => {
+    if (connected.length > 0) {
+      e.sections.push({
+        label: "MCP Servers",
+        items: connected.map((s) => s.name),
+      });
+    }
+    return e;
+  });
+
+  // Clean up on exit
+  bus.on("app:quit", () => {
+    for (const server of connected) {
+      try {
+        server.transport.close();
+      } catch {}
+    }
+  });
+}
+
+async function connectServer(
+  name: string,
+  config: McpServerConfig,
+  ctx: any,
+): Promise<ConnectedServer> {
+  const transport = new StdioClientTransport({
+    command: config.command,
+    args: config.args,
+    env: { ...process.env, ...config.env } as Record<string, string>,
+    stderr: "pipe",
+  });
+
+  const client = new Client({ name: `ash-${name}`, version: "0.1.0" });
+  await client.connect(transport);
+
+  // Discover and register tools
+  const { tools } = await client.listTools();
+  for (const tool of tools) {
+    const toolName = `mcp_${name}_${tool.name}`;
+    ctx.registerTool({
+      name: toolName,
+      displayName: tool.name,
+      description: `[${name}] ${tool.description ?? ""}`,
+      input_schema: tool.inputSchema as Record<string, unknown>,
+
+      async execute(args: Record<string, unknown>) {
+        try {
+          const result = await client.callTool({
+            name: tool.name,
+            arguments: args,
+          });
+
+          const text = (result.content as any[])
+            .map((c: any) => {
+              if (c.type === "text") return c.text;
+              if (c.type === "image") return `[image: ${c.mimeType}]`;
+              return JSON.stringify(c);
+            })
+            .join("\n");
+
+          return {
+            content: text,
+            exitCode: result.isError ? 1 : 0,
+            isError: !!result.isError,
+          };
+        } catch (err: any) {
+          return {
+            content: `MCP error: ${err.message}`,
+            exitCode: 1,
+            isError: true,
+          };
+        }
+      },
+
+      getDisplayInfo() {
+        return { kind: "execute" as const };
+      },
+
+      formatCall(args: Record<string, unknown>) {
+        // Show a compact summary of the args
+        const keys = Object.keys(args);
+        if (keys.length === 0) return tool.name;
+        const first = args[keys[0]];
+        const preview =
+          typeof first === "string"
+            ? first.slice(0, 60) + (first.length > 60 ? "…" : "")
+            : JSON.stringify(first).slice(0, 60);
+        return `${tool.name}: ${preview}`;
+      },
+    });
+  }
+
+  // ui:info suppressed — connection is silent by default
+
+  return { name, client, transport };
+}

package/examples/extensions/ash-mcp-bridge/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "ash-mcp-bridge",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1"
+  }
+}

package/examples/extensions/claude-code-bridge/index.ts

@@ -2,11 +2,13 @@
  * Claude Code bridge — runs Claude Code Agent SDK in-process as agent-sh's backend.
  *
  * Uses the official @anthropic-ai/claude-agent-sdk to spawn a Claude Code
- * session with a custom user_shell MCP tool for PTY access. Claude Code
+ * session with custom MCP tools for PTY access. Claude Code
  * handles its own model selection, tool execution, and permissions.
  *
- * Setup:
- *   npm install @anthropic-ai/claude-agent-sdk
+ * Setup (from repo root):
+ *   npm run build && npm link                    # register local agent-sh globally
+ *   cd examples/extensions/claude-code-bridge
+ *   npm install && npm link agent-sh             # link local dev copy
  *
  * Usage:
  *   agent-sh -e examples/extensions/claude-code-bridge
@@ -20,8 +22,11 @@ import {
   type Query,
 } from "@anthropic-ai/claude-agent-sdk";
 import { z } from "zod";
-import type { ExtensionContext } from "../../src/types.js";
-import type { EventBus } from "../../src/event-bus.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import type { ExtensionContext } from "agent-sh/types";
+import type { EventBus } from "agent-sh/event-bus";
+import { computeDiff, type DiffResult } from "agent-sh/utils/diff";
 
 // ── Helpers ──────────────────────────────────────────────────────
 function interpretEscapes(str: string): string {
@@ -40,39 +45,6 @@ function settle(ms = 100): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// ── user_shell MCP tool ───────────────────────────────────────────
-function createUserShellTool(bus: EventBus) {
-  let liveCwd = process.cwd();
-  bus.on("shell:cwd-change", ({ cwd }) => { liveCwd = cwd; });
-
-  return tool(
-    "user_shell",
-    "Run a command with lasting effects in the user's live shell (cd, export, " +
-    "install packages, start servers) or show output the user wants to see. " +
-    "Set return_output=true only if you need to inspect the result.",
-    {
-      command: z.string().describe("Command to execute in user's shell"),
-      return_output: z.boolean().optional().describe(
-        "Whether to return the command output. Default false.",
-      ),
-    },
-    async (args) => {
-      const result = await bus.emitPipeAsync("shell:exec-request", {
-        command: args.command,
-        output: "",
-        cwd: liveCwd,
-        done: false,
-      });
-
-      const text = args.return_output
-        ? result.output || "(no output)"
-        : "Command executed.";
-
-      return { content: [{ type: "text" as const, text }] };
-    },
-  );
-}
-
 // ── terminal_read MCP tool ────────────────────────────────────────
 function createTerminalReadTool(ctx: ExtensionContext) {
   return tool(
@@ -132,18 +104,56 @@ function createTerminalKeysTool(bus: EventBus, ctx: ExtensionContext) {
 export default function activate(ctx: ExtensionContext): void {
   const { bus } = ctx;
 
-  const shellTool = createUserShellTool(bus);
   const termReadTool = createTerminalReadTool(ctx);
   const termKeysTool = createTerminalKeysTool(bus, ctx);
   const shellServer = createSdkMcpServer({
     name: "agent-sh",
     version: "1.0.0",
-    tools: [shellTool, termReadTool, termKeysTool],
+    tools: [termReadTool, termKeysTool],
   });
 
   let activeQuery: Query | null = null;
   const listeners: Array<{ event: string; fn: Function }> = [];
 
+  // ── Tool display helpers ────────────────────────────────────────
+
+  /** Map Claude Code tool names to agent-sh display kinds. */
+  function toolKind(name: string): string {
+    if (name === "Read" || name.includes("terminal_read")) return "read";
+    if (name === "Edit") return "edit";
+    if (name === "Write") return "write";
+    if (name === "Glob" || name === "Grep") return "search";
+    if (name === "Bash" || name.includes("terminal_keys")) return "execute";
+    return "execute";
+  }
+
+  /** Map Claude Code tool names to agent-sh display icons. */
+  function toolIcon(name: string): string | undefined {
+    if (name === "Read") return "◆";
+    if (name === "Edit") return "✎";
+    if (name === "Write") return "✎";
+    if (name === "Glob" || name === "Grep") return "⌕";
+    return undefined;
+  }
+
+  /** Extract file locations from tool input args. */
+  function toolLocations(input: Record<string, unknown>): { path: string; line?: number | null }[] | undefined {
+    const raw = input.file_path ?? input.path;
+    if (typeof raw !== "string") return undefined;
+    const line = (input.line_number ?? input.line ?? input.offset) as number | undefined;
+    return [{ path: raw, line: line ?? null }];
+  }
+
+  /** Format a compact display string for a tool call. */
+  function formatToolCall(name: string, input: Record<string, unknown>): string {
+    const str = (v: unknown) => typeof v === "string" ? v : "";
+    if (name === "Bash") return `$ ${str(input.command)}`;
+    if (name === "Read" || name === "Edit" || name === "Write") return str(input.file_path ?? input.path);
+    if (name === "Grep" || name === "Glob") return `${str(input.pattern)} ${str(input.path)}`.trim();
+    if (name.includes("terminal_keys")) return str(input.keys);
+    return name;
+  }
+
   const wireListeners = () => {
     const onSubmit = async ({ query: userQuery }: any) => {
       bus.emit("agent:query", { query: userQuery });
@@ -151,6 +161,14 @@ export default function activate(ctx: ExtensionContext): void {
 
       let fullResponseText = "";
       let streamed = false;
+      /** Track in-flight tool calls so we can emit tool-completed when results arrive. */
+      const pendingTools = new Map<string, { name: string; kind: string; input?: Record<string, unknown> }>();
+      /** Tool input JSON being streamed via input_json_delta events. */
+      const inputBuffers = new Map<number, string>();
+      /** Tool metadata per content block index (for correlating deltas). */
+      const blockMeta = new Map<number, { name: string; id: string }>();
+      /** Pre-edit file snapshots for diff display (Edit/Write tools). */
+      const fileSnapshots = new Map<string, string | null>();
 
       try {
         activeQuery = query({
@@ -163,12 +181,10 @@ export default function activate(ctx: ExtensionContext): void {
               append:
                 "You are running inside agent-sh, a terminal wrapper.\n" +
                 "Use your standard tools (Read, Edit, Write, Bash, Glob, Grep) for investigation.\n" +
-                "Use mcp__agent-sh__user_shell to run commands in the user's live shell when they ask to see output or need lasting effects (cd, install, start servers).\n" +
-                "Default to standard tools. Use user_shell when the user is the intended audience for the output or the command has real effects.",
+                "Use mcp__agent-sh__terminal_read and mcp__agent-sh__terminal_keys to observe and interact with the user's live terminal.",
             },
             mcpServers: { "agent-sh": shellServer },
             allowedTools: [
-              "mcp__agent-sh__user_shell",
               "mcp__agent-sh__terminal_read",
               "mcp__agent-sh__terminal_keys",
               "Read", "Edit", "Write", "Bash", "Glob", "Grep",
@@ -183,16 +199,56 @@ export default function activate(ctx: ExtensionContext): void {
             case "stream_event": {
               streamed = true;
               const event = message.event;
-              if (event.type === "content_block_delta") {
-                const delta = event.delta as any;
-                if (delta.type === "text_delta" && delta.text) {
+              if (event.type === "content_block_start") {
+                const cb = (event as any).content_block;
+                if (cb?.type === "tool_use") {
+                  blockMeta.set(event.index, { name: cb.name, id: cb.id });
+                  inputBuffers.set(event.index, "");
+                }
+              } else if (event.type === "content_block_delta") {
+                const delta = (event as any).delta;
+                if (delta?.type === "text_delta" && delta.text) {
                   bus.emitTransform("agent:response-chunk", {
                     blocks: [{ type: "text" as const, text: delta.text }],
                   });
                   fullResponseText += delta.text;
-                } else if (delta.type === "thinking_delta" && delta.thinking) {
+                } else if (delta?.type === "thinking_delta" && delta.thinking) {
                   bus.emit("agent:thinking-chunk", { text: delta.thinking });
+                } else if (delta?.type === "input_json_delta" && delta.partial_json != null) {
+                  // Accumulate tool input JSON as it streams in
+                  const buf = inputBuffers.get(event.index) ?? "";
+                  inputBuffers.set(event.index, buf + delta.partial_json);
                 }
+              } else if (event.type === "content_block_stop") {
+                const meta = blockMeta.get(event.index);
+                const inputJson = inputBuffers.get(event.index);
+                if (meta && inputJson != null) {
+                  blockMeta.delete(event.index);
+                  inputBuffers.delete(event.index);
+
+                  let input: Record<string, unknown> = {};
+                  try { input = JSON.parse(inputJson || "{}"); } catch {}
+
+                  const kind = toolKind(meta.name);
+                  bus.emit("agent:tool-started", {
+                    title: meta.name,
+                    toolCallId: meta.id,
+                    kind,
+                    icon: toolIcon(meta.name),
+                    locations: toolLocations(input),
+                    rawInput: input,
+                    displayDetail: formatToolCall(meta.name, input),
+                  });
+                  pendingTools.set(meta.id, { name: meta.name, kind, input });
+
+                  // Snapshot file content before Edit/Write modifies it
+                  if ((meta.name === "Edit" || meta.name === "Write") && typeof (input as any).file_path === "string") {
+                    const absPath = resolve(process.cwd(), (input as any).file_path);
+                    readFile(absPath, "utf-8")
+                      .then(content => fileSnapshots.set(meta.id, content))
+                      .catch(() => fileSnapshots.set(meta.id, null)); // file doesn't exist yet
+                  }
+              }
               }
               break;
             }
@@ -206,24 +262,115 @@ export default function activate(ctx: ExtensionContext): void {
                     blocks: [{ type: "text" as const, text: b.text }],
                   });
                   fullResponseText += b.text;
-                } else if (b.type === "tool_use") {
+                } else if (b.type === "tool_use" && !streamed) {
+                  // Non-streamed fallback: emit tool-started from full message
+                  const input = (b.input ?? {}) as Record<string, unknown>;
+                  const kind = toolKind(b.name);
                   bus.emit("agent:tool-started", {
                     title: b.name,
                     toolCallId: b.id,
-                    kind: b.name.includes("shell") || b.name === "Bash"
-                      ? "execute"
-                      : "read",
+                    kind,
+                    icon: toolIcon(b.name),
+                    locations: toolLocations(input),
+                    rawInput: input,
+                    displayDetail: formatToolCall(b.name, input),
                   });
+                  pendingTools.set(b.id, { name: b.name, kind, input });
+
+                  // Snapshot file content before Edit/Write modifies it
+                  if ((b.name === "Edit" || b.name === "Write") && typeof (input as any).file_path === "string") {
+                    const absPath = resolve(process.cwd(), (input as any).file_path);
+                    readFile(absPath, "utf-8")
+                      .then(content => fileSnapshots.set(b.id, content))
+                      .catch(() => fileSnapshots.set(b.id, null));
+                  }
                 }
               }
               break;
             }
 
+            case "user": {
+              // Tool results come back as user messages with tool_result content blocks
+              const msg = message.message as any;
+              if (msg?.content && Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                  if (block.type === "tool_result") {
+                    const toolUseId = block.tool_use_id as string;
+                    const pending = pendingTools.get(toolUseId);
+                    if (!pending) continue;
+                    pendingTools.delete(toolUseId);
+
+                    const isError = !!block.is_error;
+                    const content = typeof block.content === "string"
+                      ? block.content
+                      : Array.isArray(block.content)
+                        ? block.content.map((c: any) => c.text ?? JSON.stringify(c)).join("\n")
+                        : "";
+
+                    // Compute diff for Edit/Write tools
+                    let resultDisplay: { summary?: string; body?: { kind: "diff"; diff: DiffResult; filePath: string } } | undefined;
+                    if (!isError && (pending.name === "Edit" || pending.name === "Write")) {
+                      const oldContent = fileSnapshots.get(toolUseId);
+                      fileSnapshots.delete(toolUseId);
+                      const filePath = (pending.input as any)?.file_path as string | undefined;
+                      if (filePath) {
+                        const absPath = resolve(process.cwd(), filePath);
+                        try {
+                          const newContent = await readFile(absPath, "utf-8");
+                          const diff = computeDiff(oldContent, newContent);
+                          if (!diff.isIdentical) {
+                            const summary = diff.isNewFile
+                              ? `+${diff.added}`
+                              : `+${diff.added} -${diff.removed}`;
+                            resultDisplay = {
+                              summary,
+                              body: { kind: "diff", diff, filePath: absPath },
+                            };
+                          }
+                        } catch { /* file may not exist after failed edit */ }
+                      }
+                    } else {
+                      fileSnapshots.delete(toolUseId);
+                    }
+
+                    const exitCode = isError ? 1 : 0;
+                    bus.emitTransform("agent:tool-completed", {
+                      toolCallId: toolUseId,
+                      exitCode,
+                      rawOutput: content,
+                      kind: pending.kind,
+                      resultDisplay,
+                    });
+                    bus.emit("agent:tool-output", {
+                      tool: pending.name,
+                      output: content,
+                      exitCode,
+                    });
+                  }
+                }
+              }
+              break;
+            }
+
+            case "tool_progress":
+              // Tool still running — nothing to do, TUI spinner already active
+              break;
+
             case "result":
               break;
           }
         }
 
+        // Emit completion for any tools still pending (edge case: interrupted query)
+        for (const [id, pending] of pendingTools) {
+          bus.emitTransform("agent:tool-completed", {
+            toolCallId: id,
+            exitCode: 0,
+            rawOutput: "",
+            kind: pending.kind,
+          });
+        }
+
         bus.emitTransform("agent:response-done", {
           response: fullResponseText,
         });

package/examples/extensions/claude-code-bridge/package.json

@@ -6,6 +6,7 @@
   "main": "index.ts",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.0",
+    "agent-sh": "^0.9.0",
     "zod": "^4.0.0"
   }
 }