@runfusion/fusion 0.1.2 → 0.1.3

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

@@ -0,0 +1,111 @@
+/**
+ * Custom tool discovery and MCP config file generation.
+ *
+ * Discovers non-built-in tools from pi, writes their schemas to a temp file,
+ * and generates an MCP config that points to the schema-only MCP server.
+ */
+
+import { writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+/**
+ * A single tool descriptor returned by pi.getAllTools().
+ */
+interface PiToolInfo {
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+}
+
+/**
+ * Minimal duck-type interface for the pi ExtensionAPI instance.
+ * We only call getAllTools(), so we only declare that method.
+ * The return type is unknown to accommodate defensive runtime checks.
+ */
+interface PiInstance {
+  getAllTools(): unknown;
+}
+
+/** The 6 built-in tools that pi handles natively (match pi tool names). */
+const BUILT_IN_TOOL_NAMES = new Set([
+  "read",
+  "write",
+  "edit",
+  "bash",
+  "grep",
+  "find",
+]);
+
+/** A custom tool definition with MCP-compatible schema. */
+export interface McpToolDef {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+
+/**
+ * Get custom tool definitions from pi, filtering out built-in tools.
+ *
+ * @param pi - The pi ExtensionAPI instance
+ * @returns Array of custom tool definitions (empty if all tools are built-in)
+ */
+export function getCustomToolDefs(pi: PiInstance): McpToolDef[] {
+  const allTools = pi.getAllTools();
+
+  if (!Array.isArray(allTools)) {
+    return [];
+  }
+
+  return (allTools as PiToolInfo[])
+    .filter((tool) => !BUILT_IN_TOOL_NAMES.has(tool.name))
+    .map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.parameters,
+    }));
+}
+
+/**
+ * Write MCP config and tool schemas to temp files.
+ *
+ * Creates two temp files:
+ * 1. Schema file: JSON array of tool definitions
+ * 2. Config file: MCP config pointing to the schema-only server
+ *
+ * @param toolDefs - Array of custom tool definitions
+ * @returns Path to the MCP config file
+ */
+export function writeMcpConfig(toolDefs: McpToolDef[]): string {
+  // Write tool schemas to temp file
+  const schemaFilePath = join(
+    tmpdir(),
+    `pi-claude-mcp-schemas-${process.pid}.json`,
+  );
+  writeFileSync(schemaFilePath, JSON.stringify(toolDefs));
+
+  // Resolve path to the schema server .cjs file (sibling of this module)
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const serverPath = join(__dirname, "mcp-schema-server.cjs");
+
+  // Build MCP config
+  const config = {
+    mcpServers: {
+      "custom-tools": {
+        command: "node",
+        args: [serverPath, schemaFilePath],
+      },
+    },
+  };
+
+  // Write config to temp file
+  const configFilePath = join(
+    tmpdir(),
+    `pi-claude-mcp-config-${process.pid}.json`,
+  );
+  writeFileSync(configFilePath, JSON.stringify(config));
+
+  return configFilePath;
+}

package/dist/pi-claude-cli/src/mcp-schema-server.cjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+// Schema-only MCP server. Reads tool schemas from a JSON file.
+// Only implements initialize + tools/list. tools/call is never reached
+// because the parent process kills the Claude subprocess at message_stop
+// before tool execution (break-early pattern).
+"use strict";
+
+const fs = require("fs");
+const readline = require("readline");
+
+const schemaPath = process.argv[2];
+if (!schemaPath) {
+  process.exit(1);
+}
+
+let tools = [];
+try {
+  tools = JSON.parse(fs.readFileSync(schemaPath, "utf-8"));
+} catch {
+  process.exit(1);
+}
+
+const rl = readline.createInterface({ input: process.stdin });
+rl.on("line", (line) => {
+  let msg;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  if (msg.method === "initialize") {
+    const resp = {
+      jsonrpc: "2.0",
+      id: msg.id,
+      result: {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "custom-tools", version: "1.0.0" },
+      },
+    };
+    process.stdout.write(JSON.stringify(resp) + "\n");
+  } else if (msg.method === "tools/list") {
+    const resp = { jsonrpc: "2.0", id: msg.id, result: { tools } };
+    process.stdout.write(JSON.stringify(resp) + "\n");
+  }
+  // notifications/initialized: no response needed (notification)
+  // tools/call: never reached (break-early kills subprocess first)
+});

package/dist/pi-claude-cli/src/process-manager.ts

@@ -0,0 +1,218 @@
+/**
+ * Process manager for spawning and managing Claude CLI subprocesses.
+ *
+ * Handles subprocess lifecycle: spawn with correct CLI flags, write NDJSON
+ * messages to stdin, force-kill after result (CLI hangs bug), and stderr capture.
+ * Also provides startup validation for CLI presence and authentication.
+ */
+
+import spawn from "cross-spawn";
+import { execSync } from "node:child_process";
+import { writeFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { ChildProcess } from "node:child_process";
+
+/**
+ * Spawn a Claude CLI subprocess with all required flags for stream-json communication.
+ *
+ * @param modelId - The model ID to pass via --model flag
+ * @param systemPrompt - Optional system prompt appended via --append-system-prompt
+ * @param options - Optional cwd, AbortSignal, and effort level
+ * @returns The spawned ChildProcess with piped stdin/stdout/stderr
+ */
+export function spawnClaude(
+  modelId: string,
+  systemPrompt?: string,
+  options?: {
+    cwd?: string;
+    signal?: AbortSignal;
+    effort?: string;
+    mcpConfigPath?: string;
+    resumeSessionId?: string;
+    newSessionId?: string;
+  },
+): ChildProcess {
+  const args = [
+    "-p",
+    "--input-format",
+    "stream-json",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--include-partial-messages",
+    "--model",
+    modelId,
+    "--permission-prompt-tool",
+    "stdio",
+  ];
+
+  if (options?.resumeSessionId) {
+    // Resume an existing session — CLI loads prior conversation from disk
+    args.push("--resume", options.resumeSessionId);
+  } else if (options?.newSessionId) {
+    // First turn: create session with this ID so subsequent turns can --resume it
+    args.push("--session-id", options.newSessionId);
+  }
+
+  if (systemPrompt) {
+    // Write system prompt to a temp file to avoid ENAMETOOLONG on Windows.
+    // Claude CLI's --append-system-prompt accepts a file path or literal text.
+    const tmpFile = join(
+      tmpdir(),
+      `pi-claude-cli-sysprompt-${process.pid}.txt`,
+    );
+    writeFileSync(tmpFile, systemPrompt, "utf-8");
+    args.push("--append-system-prompt", tmpFile);
+  }
+
+  if (options?.effort) {
+    args.push("--effort", options.effort);
+  }
+
+  if (options?.mcpConfigPath) {
+    args.push("--mcp-config", options.mcpConfigPath);
+  }
+
+  const proc = spawn("claude", args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    cwd: options?.cwd ?? process.cwd(),
+  });
+
+  return proc as ChildProcess;
+}
+
+/**
+ * Clean up the temp system prompt file created by spawnClaude.
+ * Safe to call multiple times or when no file exists.
+ */
+export function cleanupSystemPromptFile(): void {
+  try {
+    unlinkSync(join(tmpdir(), `pi-claude-cli-sysprompt-${process.pid}.txt`));
+  } catch {
+    // File doesn't exist or already deleted — ignore
+  }
+}
+
+/**
+ * Write a user message to the subprocess stdin as NDJSON.
+ * Does NOT call stdin.end() -- stdin stays open for control_response in Phase 2.
+ *
+ * Accepts both string (text-only prompt) and array (ContentBlock[] with images)
+ * content. JSON.stringify handles both natively. The stream-json protocol
+ * supports either format in the content field.
+ *
+ * @param proc - The Claude subprocess
+ * @param prompt - The prompt text or ContentBlock[] to send
+ */
+export function writeUserMessage(
+  proc: ChildProcess,
+  prompt: string | unknown[],
+): void {
+  const message = {
+    type: "user",
+    message: {
+      role: "user",
+      content: prompt,
+    },
+  };
+  proc.stdin!.write(JSON.stringify(message) + "\n");
+}
+
+/**
+ * Force-kill a subprocess immediately via SIGKILL.
+ * No-ops if the process is already dead (killed or exited).
+ * Cross-platform safe: Node.js treats SIGKILL as forceful termination on Windows.
+ *
+ * @param proc - The subprocess to force-kill
+ */
+export function forceKillProcess(proc: ChildProcess): void {
+  if (proc.killed || proc.exitCode !== null) return;
+  proc.kill("SIGKILL");
+}
+
+/** Registry of active subprocesses for cleanup on teardown. */
+const activeProcesses = new Set<ChildProcess>();
+
+/**
+ * Register a subprocess in the global process registry.
+ * The process is automatically removed from the registry when it exits.
+ *
+ * @param proc - The subprocess to track
+ */
+export function registerProcess(proc: ChildProcess): void {
+  activeProcesses.add(proc);
+  proc.on("exit", () => activeProcesses.delete(proc));
+}
+
+/**
+ * Force-kill all registered subprocesses and clear the registry.
+ * Safe to call multiple times -- no-ops on already-dead processes.
+ */
+export function killAllProcesses(): void {
+  for (const proc of activeProcesses) {
+    forceKillProcess(proc);
+  }
+  activeProcesses.clear();
+}
+
+/**
+ * Force-kill the subprocess after a 500ms grace period.
+ * The Claude CLI hangs after emitting the result message (known bug).
+ * Brief grace period allows final stdout flushing before force-kill.
+ *
+ * @param proc - The Claude subprocess to clean up
+ */
+export function cleanupProcess(proc: ChildProcess): void {
+  setTimeout(() => {
+    forceKillProcess(proc);
+  }, 500);
+}
+
+/**
+ * Attach a data listener to stderr and accumulate output into a buffer.
+ *
+ * @param proc - The Claude subprocess
+ * @returns A function that returns the accumulated stderr string
+ */
+export function captureStderr(proc: ChildProcess): () => string {
+  let buffer = "";
+  proc.stderr!.on("data", (data: Buffer) => {
+    buffer += data.toString();
+  });
+  return () => buffer;
+}
+
+/**
+ * Validate that the Claude CLI is installed and on PATH.
+ * Throws with install instructions if not found.
+ */
+export function validateCliPresence(): void {
+  try {
+    execSync("claude --version", { stdio: "pipe", timeout: 5000 });
+  } catch {
+    throw new Error(
+      "Claude Code CLI not found. Install it: npm install -g @anthropic-ai/claude-code\n" +
+        "Then authenticate: claude auth login",
+    );
+  }
+}
+
+/**
+ * Validate that the Claude CLI is authenticated.
+ * Returns false and warns if not authenticated.
+ *
+ * @returns true if authenticated, false otherwise
+ */
+export function validateCliAuth(): boolean {
+  try {
+    execSync("claude auth status", { stdio: "pipe", timeout: 5000 });
+    return true;
+  } catch {
+    console.warn(
+      "[pi-claude-cli] Claude CLI is not authenticated. " +
+        "Run 'claude auth login' to authenticate.",
+    );
+    return false;
+  }
+}