@runfusion/fusion 0.48.0 → 0.50.0

package/dist/pi-claude-cli/index.ts

@@ -21,13 +21,14 @@ import {
   writeMcpConfig,
   buildAcpMcpServers,
   type McpToolDef,
+  type UserMcpServerSpec,
 } from "./src/mcp-config.js";
 
 /**
- * Route A kill-switch (U11). When `FUSION_CLAUDE_ACP=1` AND a bridge binary path
- * is available (`FUSION_CLAUDE_ACP_BRIDGE`, injected by the engine seam per
- * KTD10), the provider drives Claude through the ACP bridge instead of
- * `claude -p`. OFF by default: the live `-p` path is untouched until soak.
+ * FNXC:pi-claude-cli 2026-06-27-06:39:
+ * Route A drives Claude through the ACP bridge only when `FUSION_CLAUDE_ACP=1`
+ * AND a bridge binary path is injected via `FUSION_CLAUDE_ACP_BRIDGE`.
+ * OFF by default: the live `claude -p` path stays untouched until soak.
  */
 function resolveAcpBridgePath(): string | undefined {
   if (process.env.FUSION_CLAUDE_ACP !== "1") return undefined;
@@ -51,14 +52,12 @@ process.on("exit", killAllProcesses);
 const PROVIDER_ID = "pi-claude-cli";
 
 /**
- * Run CLI presence + auth probes at most once per process, asynchronously.
- *
- * The factory below is invoked on every `createFnAgent` call (the dashboard
- * does this per chat message). Doing the probes synchronously with execSync
- * froze the entire Node event loop for a few seconds while `claude` cold-
- * started. Memoizing as a Promise + spawning the probes async means the
- * factory returns immediately and other requests keep flowing; the result
- * is logged once on first run and reused thereafter.
+ * FNXC:pi-claude-cli 2026-06-27-06:39:
+ * The factory runs per `createFnAgent` call, which the dashboard does for each
+ * chat message. Synchronous `execSync` presence + auth probes froze the Node
+ * event loop while `claude` cold-started, so memoize the probes as an async
+ * Promise: the factory returns immediately, the result logs once, and later
+ * calls reuse it.
  */
 let cliValidationPromise: Promise<void> | undefined;
 
@@ -83,6 +82,11 @@ function debugMcp(message: string): void {
   console.error(`[pi-claude-cli] ${message}`);
 }
 
+function getUserMcpServers(options: unknown): UserMcpServerSpec[] {
+  const servers = (options as { mcpServers?: unknown } | undefined)?.mcpServers;
+  return Array.isArray(servers) ? servers.filter((server): server is UserMcpServerSpec => Boolean(server && typeof server === "object" && "name" in server)) : [];
+}
+
 /**
  * Resolve the MCP config path for the current request, regenerating it when
  * the set of custom tools changes.
@@ -113,6 +117,7 @@ function ensureMcpConfig(
     description: string;
     parameters: Record<string, unknown>;
   }>,
+  userMcpServers: UserMcpServerSpec[] = [],
 ): string | undefined {
   try {
     let toolDefs: McpToolDef[] = toolsFromContext(contextTools);
@@ -132,13 +137,13 @@ function ensureMcpConfig(
       toolDefs = getCustomToolDefs(pi);
     }
 
-    if (toolDefs.length === 0) {
+    if (toolDefs.length === 0 && userMcpServers.length === 0) {
       cachedMcpConfig = undefined;
       return undefined;
     }
 
     const hash = createHash("sha1")
-      .update(JSON.stringify(toolDefs))
+      .update(JSON.stringify({ toolDefs, userMcpServerNames: userMcpServers.map((server) => server.name) }))
       .digest("hex")
       .slice(0, 12);
 
@@ -147,7 +152,7 @@ function ensureMcpConfig(
       return cachedMcpConfig.configPath;
     }
 
-    const configPath = writeMcpConfig(toolDefs, hash);
+    const configPath = writeMcpConfig(toolDefs, hash, userMcpServers);
     cachedMcpConfig = { hash, configPath };
     const toolNames = toolDefs.map((t) => t.name).join(", ");
     debugMcp(
@@ -250,23 +255,22 @@ export default function (pi: ExtensionAPI) {
           parameters: Record<string, unknown>;
         }> }).tools;
 
-        // Route A (U11): drive Claude through the ACP bridge when the kill-switch
-        // is on AND a bridge path is injected. OFF by default → `-p` path below.
+        // FNXC:pi-claude-cli 2026-06-27-06:39: Route A drives Claude through the ACP bridge only when the kill-switch is on AND a bridge path is injected. OFF by default → `-p` path below.
         const bridgePath = resolveAcpBridgePath();
         if (bridgePath) {
           const toolDefs = resolveToolDefs(pi, contextTools);
-          const hash = createHash("sha1").update(JSON.stringify(toolDefs)).digest("hex").slice(0, 12);
+          const userMcpServers = getUserMcpServers(options);
+          const hash = createHash("sha1").update(JSON.stringify({ toolDefs, userMcpServerNames: userMcpServers.map((server) => server.name) })).digest("hex").slice(0, 12);
           return streamViaAcp(model, context, {
             ...options,
             bridgePath,
-            mcpServers: buildAcpMcpServers(toolDefs, hash),
-            // Forward only HOME/PATH so the bridged `claude` authenticates from the
-            // login/keychain session (R17); never inherited process.env or API keys.
+            mcpServers: buildAcpMcpServers(toolDefs, hash, userMcpServers),
+            // FNXC:pi-claude-cli 2026-06-27-06:39: Forward only HOME/PATH so the bridged `claude` authenticates from the login/keychain session (R17); never inherited process.env or API keys.
             bridgeEnv: { HOME: process.env.HOME, PATH: process.env.PATH },
           });
         }
 
-        const configPath = ensureMcpConfig(pi, contextTools);
+        const configPath = ensureMcpConfig(pi, contextTools, getUserMcpServers(options));
         return streamViaCli(model, context, {
           ...options,
           mcpConfigPath: configPath,

package/dist/pi-claude-cli/package.json

@@ -1,38 +1,24 @@
 {
   "name": "@fusion/pi-claude-cli",
-  "version": "0.48.0",
-  "description": "Fusion vendored fork: pi coding-agent extension that routes LLM calls through the Claude Code CLI. Forked from rchern/pi-claude-cli (MIT). See UPSTREAM.md.",
-  "license": "MIT",
-  "private": true,
+  "version": "0.50.0",
   "type": "module",
+  "private": true,
   "main": "index.ts",
-  "keywords": [
-    "pi-package"
-  ],
   "pi": {
     "extensions": [
       "index.ts"
     ]
   },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Runfusion/Fusion",
-    "directory": "packages/pi-claude-cli"
-  },
   "dependencies": {
     "@agentclientprotocol/sdk": "0.24.0"
   },
-  "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*"
-  },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "typescript": "^5.7.0",
     "vitest": "^4.1.0"
   },
-  "scripts": {
-    "test": "vitest run --reporter=dot",
-    "typecheck": "tsc --noEmit"
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
   }
-}
+}

package/dist/pi-claude-cli/src/mcp-config.ts

@@ -92,6 +92,39 @@ export function toolsFromContext(
     }));
 }
 
+export interface UserMcpServerSpec {
+  name: string;
+  enabled?: boolean;
+  transport?: "stdio" | "sse" | "streamable-http";
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  url?: string;
+  headers?: Record<string, string>;
+}
+
+function userServerToConfig(server: UserMcpServerSpec): Record<string, unknown> | undefined {
+  if (server.enabled === false) return undefined;
+  if (server.transport === "sse" || server.transport === "streamable-http") {
+    if (!server.url) return undefined;
+    return {
+      transport: server.transport,
+      url: server.url,
+      ...(server.headers ? { headers: server.headers } : {}),
+    };
+  }
+  if (!server.command) return undefined;
+  return {
+    command: server.command,
+    ...(server.args ? { args: server.args } : {}),
+    ...(server.env ? { env: server.env } : {}),
+  };
+}
+
+/**
+ * FNXC:McpConfig 2026-06-25-22:12:
+ * The Claude CLI MCP config combines Fusion's schema-only custom-tools server with operator-enabled user MCP servers. User env/header values are already secret-materialized by the engine, so this module must write them only to the transient MCP config and never log server contents.
+ */
 /**
  * Write MCP config and tool schemas to temp files.
  *
@@ -108,6 +141,7 @@ export function toolsFromContext(
 export function writeMcpConfig(
   toolDefs: McpToolDef[],
   cacheKey?: string,
+  userMcpServers: UserMcpServerSpec[] = [],
 ): string {
   const suffix = cacheKey ? `${process.pid}-${cacheKey}` : `${process.pid}`;
 
@@ -124,14 +158,17 @@ export function writeMcpConfig(
   const serverPath = join(__dirname, "mcp-schema-server.cjs");
 
   // Build MCP config
-  const config = {
-    mcpServers: {
-      "custom-tools": {
-        command: "node",
-        args: [serverPath, schemaFilePath],
-      },
+  const mcpServers: Record<string, unknown> = {
+    "custom-tools": {
+      command: "node",
+      args: [serverPath, schemaFilePath],
     },
   };
+  for (const server of userMcpServers) {
+    const config = userServerToConfig(server);
+    if (config) mcpServers[server.name] = config;
+  }
+  const config = { mcpServers };
 
   // Write config to temp file
   const configFilePath = join(
@@ -151,6 +188,16 @@ export interface AcpMcpServerSpec {
   env: { name: string; value: string }[];
 }
 
+function userServerToAcp(server: UserMcpServerSpec): AcpMcpServerSpec | undefined {
+  if (server.enabled === false || (server.transport && server.transport !== "stdio") || !server.command) return undefined;
+  return {
+    name: server.name,
+    command: server.command,
+    args: server.args ?? [],
+    env: Object.entries(server.env ?? {}).map(([name, value]) => ({ name, value })),
+  };
+}
+
 /**
  * Build the ACP `mcpServers` spec for the same schema-only `custom-tools` server
  * `writeMcpConfig` produces for `--mcp-config` — but as the inline ACP shape
@@ -161,13 +208,17 @@ export interface AcpMcpServerSpec {
 export function buildAcpMcpServers(
   toolDefs: McpToolDef[],
   cacheKey?: string,
+  userMcpServers: UserMcpServerSpec[] = [],
 ): AcpMcpServerSpec[] {
-  if (toolDefs.length === 0) return [];
+  if (toolDefs.length === 0) {
+    return userMcpServers.map(userServerToAcp).filter((server): server is AcpMcpServerSpec => Boolean(server));
+  }
   const suffix = cacheKey ? `${process.pid}-${cacheKey}` : `${process.pid}`;
   const schemaFilePath = join(tmpdir(), `pi-claude-mcp-schemas-${suffix}.json`);
   writeFileSync(schemaFilePath, JSON.stringify(toolDefs));
   const serverPath = join(dirname(fileURLToPath(import.meta.url)), "mcp-schema-server.cjs");
   return [
     { name: "custom-tools", command: "node", args: [serverPath, schemaFilePath], env: [] },
+    ...userMcpServers.map(userServerToAcp).filter((server): server is AcpMcpServerSpec => Boolean(server)),
   ];
 }