@runfusion/fusion 0.1.2 → 0.2.0

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

@@ -0,0 +1,131 @@
+/**
+ * Pi extension entry point for pi-claude-cli.
+ *
+ * Registers a custom provider that routes LLM calls through the Claude Code CLI
+ * subprocess using stream-json NDJSON protocol.
+ */
+
+import { getModels } from "@mariozechner/pi-ai";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { streamViaCli } from "./src/provider.js";
+import {
+  validateCliPresence,
+  validateCliAuth,
+  killAllProcesses,
+} from "./src/process-manager.js";
+import { getCustomToolDefs, writeMcpConfig } from "./src/mcp-config.js";
+
+// Kill all active Claude subprocesses on process exit to prevent orphans
+process.on("exit", killAllProcesses);
+
+const PROVIDER_ID = "pi-claude-cli";
+
+let mcpConfigPath: string | undefined;
+let mcpConfigResolved = false;
+
+/**
+ * Lazily generate MCP config on first request (not at load time).
+ * pi.getAllTools() fails during extension loading; this defers it
+ * until the pi runtime is fully initialized.
+ *
+ * Only locks (sets mcpConfigResolved) when getAllTools() returns a
+ * real array — if it returns undefined/null (registry not ready),
+ * we retry on the next request. Once the registry is ready we
+ * commit to the result even if there are zero custom tools.
+ *
+ * Uses warn-don't-block: failure logs a warning but does not
+ * prevent the provider from functioning (built-ins still work).
+ */
+function ensureMcpConfig(pi: ExtensionAPI): string | undefined {
+  if (mcpConfigResolved) return mcpConfigPath;
+  try {
+    const allTools = pi.getAllTools();
+
+    // Registry not ready yet — don't lock, retry on next call
+    if (!Array.isArray(allTools)) {
+      return mcpConfigPath;
+    }
+
+    // Registry is ready — lock regardless of whether custom tools exist
+    mcpConfigResolved = true;
+
+    const toolDefs = getCustomToolDefs(pi);
+    if (toolDefs.length > 0) {
+      mcpConfigPath = writeMcpConfig(toolDefs);
+      console.error(
+        `[pi-claude-cli] MCP config generated with ${toolDefs.length} custom tool(s)`,
+      );
+    }
+  } catch (err) {
+    console.warn(
+      "[pi-claude-cli] MCP config generation failed, custom tools unavailable:",
+      err,
+    );
+  }
+  return mcpConfigPath;
+}
+
+export default function (pi: ExtensionAPI) {
+  try {
+    // Startup validation
+    validateCliPresence(); // throws if CLI not on PATH
+    validateCliAuth(); // warns if not authenticated
+
+    const catalogModels = getModels("anthropic").map((model) => ({
+      id: model.id,
+      name: model.name,
+      reasoning: model.reasoning,
+      input: model.input,
+      cost: model.cost,
+      contextWindow: model.contextWindow,
+      maxTokens: model.maxTokens,
+    }));
+
+    // Newer models released after the pinned @mariozechner/pi-ai catalog
+    // was generated. Dedupe by id so this list is harmless once the upstream
+    // catalog catches up.
+    // https://platform.claude.com/docs/en/about-claude/models/overview
+    const extraModels: typeof catalogModels = [
+      {
+        id: "claude-opus-4-7",
+        name: "Claude Opus 4.7",
+        reasoning: true,
+        input: ["text", "image"],
+        cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+        contextWindow: 1_000_000,
+        maxTokens: 128_000,
+      },
+    ];
+
+    const seen = new Set(catalogModels.map((m) => m.id));
+    const models = [
+      ...catalogModels,
+      ...extraModels.filter((m) => !seen.has(m.id)),
+    ];
+
+    // Ensure all registered tools are active so pi can execute them.
+    // Some tools (find, grep, ls) are registered but not activated by default.
+    pi.on("session_start", async () => {
+      const allTools = pi.getAllTools();
+      if (Array.isArray(allTools)) {
+        pi.setActiveTools(allTools.map((t: { name: string }) => t.name));
+      }
+    });
+
+    pi.registerProvider(PROVIDER_ID, {
+      baseUrl: "pi-claude-cli",
+      apiKey: "unused",
+      api: "pi-claude-cli",
+      models,
+      streamSimple: (model, context, options) => {
+        const configPath = ensureMcpConfig(pi);
+        return streamViaCli(model, context, {
+          ...options,
+          mcpConfigPath: configPath,
+        });
+      },
+    });
+  } catch (err) {
+    console.error(`[pi-claude-cli] Failed to register provider:`, err);
+  }
+}

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

@@ -0,0 +1,39 @@
+{
+  "name": "@fusion/pi-claude-cli",
+  "version": "0.3.1",
+  "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,
+  "type": "module",
+  "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": {
+    "cross-spawn": "^7.0.6"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "test": "vitest run --reporter=dot",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/dist/pi-claude-cli/src/__tests__/control-handler.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect, vi } from "vitest";
+import { PassThrough } from "node:stream";
+import type { ClaudeControlRequest } from "../types";
+import {
+  handleControlRequest,
+  TOOL_EXECUTION_DENIED_MESSAGE,
+  MCP_PREFIX,
+} from "../control-handler";
+
+function createMockStdin() {
+  const stream = new PassThrough();
+  const chunks: string[] = [];
+  stream.on("data", (data: Buffer) => chunks.push(data.toString()));
+  return { stream, chunks };
+}
+
+function makeControlRequest(
+  toolName: string,
+  requestId = "req-test-001",
+  input: Record<string, unknown> = {},
+): ClaudeControlRequest {
+  return {
+    type: "control_request",
+    request_id: requestId,
+    request: {
+      subtype: "can_use_tool",
+      tool_name: toolName,
+      input,
+    },
+  };
+}
+
+describe("control-handler", () => {
+  describe("exported constants", () => {
+    it("exports TOOL_EXECUTION_DENIED_MESSAGE", () => {
+      expect(TOOL_EXECUTION_DENIED_MESSAGE).toBe(
+        "Tool execution is unavailable in this environment.",
+      );
+    });
+
+    it("exports MCP_PREFIX", () => {
+      expect(MCP_PREFIX).toBe("mcp__");
+    });
+  });
+
+  describe("denies custom MCP tools (mcp__custom-tools__*)", () => {
+    it("denies mcp__custom-tools__weather and returns false", () => {
+      const { stream, chunks } = createMockStdin();
+      const msg = makeControlRequest("mcp__custom-tools__weather");
+
+      const result = handleControlRequest(msg, stream);
+
+      expect(result).toBe(false);
+      const response = JSON.parse(chunks[0].trim());
+      expect(response.response.response.behavior).toBe("deny");
+      expect(response.response.response.message).toBe(
+        TOOL_EXECUTION_DENIED_MESSAGE,
+      );
+    });
+
+    it("denies mcp__custom-tools__deploy", () => {
+      const { stream, chunks } = createMockStdin();
+      const msg = makeControlRequest("mcp__custom-tools__deploy");
+
+      const result = handleControlRequest(msg, stream);
+
+      expect(result).toBe(false);
+      const response = JSON.parse(chunks[0].trim());
+      expect(response.response.response.behavior).toBe("deny");
+    });
+  });
+
+  describe("allows user MCP tools and other tools", () => {
+    it("allows user MCP tool mcp__database__query and returns true", () => {
+      const { stream, chunks } = createMockStdin();
+      const msg = makeControlRequest("mcp__database__query");
+
+      const result = handleControlRequest(msg, stream);
+
+      expect(result).toBe(true);
+      const response = JSON.parse(chunks[0].trim());
+      expect(response.response.response.behavior).toBe("allow");
+    });
+
+    it("allows built-in tool Read", () => {
+      const { stream, chunks } = createMockStdin();
+      const msg = makeControlRequest("Read");
+
+      const result = handleControlRequest(msg, stream);
+
+      expect(result).toBe(true);
+      const response = JSON.parse(chunks[0].trim());
+      expect(response.response.response.behavior).toBe("allow");
+    });
+
+    it("allows internal tools like ToolSearch", () => {
+      const { stream, chunks } = createMockStdin();
+      const msg = makeControlRequest("ToolSearch");
+
+      const result = handleControlRequest(msg, stream);
+
+      expect(result).toBe(true);
+      const response = JSON.parse(chunks[0].trim());
+      expect(response.response.response.behavior).toBe("allow");
+    });
+
+    it("allows unknown tools", () => {
+      const { stream, chunks } = createMockStdin();
+      const msg = makeControlRequest("SomeUnknownTool");
+
+      const result = handleControlRequest(msg, stream);
+
+      expect(result).toBe(true);
+      const response = JSON.parse(chunks[0].trim());
+      expect(response.response.response.behavior).toBe("allow");
+    });
+  });
+
+  describe("response format", () => {
+    it("includes matching request_id", () => {
+      const { stream, chunks } = createMockStdin();
+      const msg = makeControlRequest("Read", "custom-req-id-42");
+
+      handleControlRequest(msg, stream);
+
+      const response = JSON.parse(chunks[0].trim());
+      expect(response.request_id).toBe("custom-req-id-42");
+    });
+
+    it("writes response as NDJSON (JSON + newline)", () => {
+      const { stream, chunks } = createMockStdin();
+      const msg = makeControlRequest("Read");
+
+      handleControlRequest(msg, stream);
+
+      expect(chunks[0].endsWith("\n")).toBe(true);
+      expect(() => JSON.parse(chunks[0].trim())).not.toThrow();
+    });
+
+    it("deny response includes message field", () => {
+      const { stream, chunks } = createMockStdin();
+      const msg = makeControlRequest("mcp__custom-tools__foo");
+
+      handleControlRequest(msg, stream);
+
+      const response = JSON.parse(chunks[0].trim());
+      expect(response.response.response.message).toBe(
+        TOOL_EXECUTION_DENIED_MESSAGE,
+      );
+    });
+
+    it("allow response does not include a message field", () => {
+      const { stream, chunks } = createMockStdin();
+      const msg = makeControlRequest("mcp__database__query");
+
+      handleControlRequest(msg, stream);
+
+      const response = JSON.parse(chunks[0].trim());
+      expect(response.response.response.message).toBeUndefined();
+    });
+  });
+
+  describe("malformed input", () => {
+    it("returns false for missing request_id", () => {
+      const { stream } = createMockStdin();
+      const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      const msg = {
+        type: "control_request",
+      } as unknown as ClaudeControlRequest;
+      const result = handleControlRequest(msg, stream);
+
+      expect(result).toBe(false);
+      spy.mockRestore();
+    });
+
+    it("returns false for missing request object", () => {
+      const { stream } = createMockStdin();
+      const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      const msg = {
+        type: "control_request",
+        request_id: "req-001",
+      } as unknown as ClaudeControlRequest;
+      const result = handleControlRequest(msg, stream);
+
+      expect(result).toBe(false);
+      spy.mockRestore();
+    });
+  });
+});