@synergenius/flow-weaver 0.22.6 → 0.22.8

package/dist/agent/mcp-bridge.js

@@ -0,0 +1,132 @@
+/**
+ * MCP bridge — creates a Unix domain socket server that the MCP tool server
+ * connects to for executing tools. Also generates the temporary MCP config
+ * and tool definition files needed by the Claude CLI.
+ *
+ * Usage:
+ *   const bridge = await createMcpBridge(tools, executor, onToolEvent);
+ *   // pass bridge.configPath to --mcp-config
+ *   // ...run CLI...
+ *   bridge.cleanup();
+ */
+import * as net from 'node:net';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { fileURLToPath } from 'node:url';
+/**
+ * Create an MCP bridge that the Claude CLI can connect to for tool execution.
+ *
+ * @param tools       Tool definitions to advertise to the CLI
+ * @param executor    Function that executes a tool call
+ * @param onToolEvent Optional callback for relaying tool events
+ * @param logger      Optional logger
+ */
+export async function createMcpBridge(tools, executor, onToolEvent, logger) {
+    // Create temp directory for bridge files
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'fw-mcp-bridge-'));
+    fs.chmodSync(tmpDir, 0o700);
+    const socketPath = path.join(tmpDir, 'bridge.sock');
+    const defsPath = path.join(tmpDir, 'tools.json');
+    const configPath = path.join(tmpDir, 'mcp-config.json');
+    // Write tool definitions in MCP format
+    const mcpToolDefs = tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+    }));
+    fs.writeFileSync(defsPath, JSON.stringify(mcpToolDefs), 'utf-8');
+    // Resolve the MCP tool server script path.
+    // In prod: sibling .js file. In dev (tsx): sibling .ts file.
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const jsPath = path.resolve(__dirname, 'mcp-tool-server.js');
+    const tsPath = path.resolve(__dirname, 'mcp-tool-server.ts');
+    const scriptPath = fs.existsSync(jsPath) ? jsPath : tsPath;
+    // In dev the script is .ts — use tsx as the loader.
+    const mcpCommand = process.execPath; // node
+    let mcpArgs = [scriptPath];
+    if (scriptPath.endsWith('.ts')) {
+        // Look for tsx in the package's node_modules
+        const tsxCli = path.resolve(__dirname, '../../node_modules/tsx/dist/cli.mjs');
+        if (fs.existsSync(tsxCli)) {
+            mcpArgs = [tsxCli, scriptPath];
+        }
+    }
+    // Write MCP config
+    const mcpConfig = {
+        mcpServers: {
+            'fw-agent': {
+                type: 'stdio',
+                command: mcpCommand,
+                args: mcpArgs,
+                env: {
+                    FW_TOOL_SOCKET: socketPath,
+                    FW_TOOL_DEFS: defsPath,
+                },
+            },
+        },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(mcpConfig), 'utf-8');
+    // Mutable handlers — swapped per request via setHandlers()
+    let currentExecutor = executor;
+    let currentOnToolEvent = onToolEvent;
+    // Create Unix domain socket server.
+    // The tool server sends a newline-terminated JSON request and waits for a
+    // JSON response on the same connection.
+    const server = net.createServer((conn) => {
+        let buf = '';
+        conn.on('data', async (chunk) => {
+            buf += chunk.toString();
+            const nlIdx = buf.indexOf('\n');
+            if (nlIdx === -1)
+                return; // wait for complete line
+            const line = buf.slice(0, nlIdx).trim();
+            buf = ''; // consume — one request per connection
+            try {
+                const { name, args } = JSON.parse(line);
+                currentOnToolEvent?.({ type: 'tool_call_start', name, args });
+                const { result, isError } = await currentExecutor(name, args);
+                currentOnToolEvent?.({ type: 'tool_call_result', name, result, isError });
+                conn.end(JSON.stringify({ result, isError }));
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger?.error('MCP bridge tool execution error', err);
+                conn.end(JSON.stringify({ result: msg, isError: true }));
+            }
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.on('error', reject);
+        server.listen(socketPath, () => resolve());
+    });
+    let cleaned = false;
+    const cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        server.close();
+        try {
+            fs.unlinkSync(socketPath);
+        }
+        catch { }
+        try {
+            fs.unlinkSync(defsPath);
+        }
+        catch { }
+        try {
+            fs.unlinkSync(configPath);
+        }
+        catch { }
+        try {
+            fs.rmdirSync(tmpDir);
+        }
+        catch { }
+    };
+    const setHandlers = (exec, onEvt) => {
+        currentExecutor = exec;
+        currentOnToolEvent = onEvt;
+    };
+    return { configPath, setHandlers, cleanup };
+}
+//# sourceMappingURL=mcp-bridge.js.map

package/dist/agent/mcp-tool-server.d.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+/**
+ * Minimal MCP stdio server that bridges tool calls to a parent process.
+ *
+ * Spawned by the Claude CLI via --mcp-config. Advertises tool definitions
+ * and delegates execution to the parent process through a Unix domain socket.
+ *
+ * Environment:
+ *   FW_TOOL_SOCKET - Unix socket path for tool execution RPC
+ *   FW_TOOL_DEFS   - Path to JSON file with tool definitions
+ *
+ * Protocol over Unix socket (newline-delimited JSON):
+ *   Request:  {"name":"fw_run_command","args":{"command":"ls"}}
+ *   Response: {"result":"...","isError":false}
+ *
+ * IMPORTANT — Transport compatibility:
+ *   Claude Code CLI v2.1.76+ uses NDJSON (newline-delimited JSON) for MCP
+ *   stdio, NOT the Content-Length framing from the MCP SDK spec. This server
+ *   auto-detects the transport on the first stdin chunk: if the first
+ *   non-whitespace character is '{', it uses NDJSON; otherwise Content-Length.
+ *   Responses match the detected format.
+ *
+ *   The CLI also sends protocolVersion "2025-11-25" (not the spec's
+ *   "2024-11-05"). We echo back whatever version the client requests.
+ *
+ *   If these behaviors change in a future CLI version, the auto-detect
+ *   and version echo should adapt automatically.
+ */
+export {};
+//# sourceMappingURL=mcp-tool-server.d.ts.map

package/dist/agent/mcp-tool-server.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+/**
+ * Minimal MCP stdio server that bridges tool calls to a parent process.
+ *
+ * Spawned by the Claude CLI via --mcp-config. Advertises tool definitions
+ * and delegates execution to the parent process through a Unix domain socket.
+ *
+ * Environment:
+ *   FW_TOOL_SOCKET - Unix socket path for tool execution RPC
+ *   FW_TOOL_DEFS   - Path to JSON file with tool definitions
+ *
+ * Protocol over Unix socket (newline-delimited JSON):
+ *   Request:  {"name":"fw_run_command","args":{"command":"ls"}}
+ *   Response: {"result":"...","isError":false}
+ *
+ * IMPORTANT — Transport compatibility:
+ *   Claude Code CLI v2.1.76+ uses NDJSON (newline-delimited JSON) for MCP
+ *   stdio, NOT the Content-Length framing from the MCP SDK spec. This server
+ *   auto-detects the transport on the first stdin chunk: if the first
+ *   non-whitespace character is '{', it uses NDJSON; otherwise Content-Length.
+ *   Responses match the detected format.
+ *
+ *   The CLI also sends protocolVersion "2025-11-25" (not the spec's
+ *   "2024-11-05"). We echo back whatever version the client requests.
+ *
+ *   If these behaviors change in a future CLI version, the auto-detect
+ *   and version echo should adapt automatically.
+ */
+import * as net from 'node:net';
+import * as fs from 'node:fs';
+const SOCKET_PATH = process.env.FW_TOOL_SOCKET;
+const DEFS_PATH = process.env.FW_TOOL_DEFS;
+if (!SOCKET_PATH || !DEFS_PATH) {
+    process.stderr.write('mcp-tool-server: FW_TOOL_SOCKET and FW_TOOL_DEFS are required\n');
+    process.exit(1);
+}
+// Load tool definitions (written by the bridge before spawning the CLI)
+const toolDefs = JSON.parse(fs.readFileSync(DEFS_PATH, 'utf-8'));
+// ---------------------------------------------------------------------------
+// Unix socket RPC: send tool call, receive result
+// ---------------------------------------------------------------------------
+function callTool(name, args) {
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(SOCKET_PATH, () => {
+            client.write(JSON.stringify({ name, args }) + '\n');
+        });
+        let buf = '';
+        client.on('data', (chunk) => {
+            buf += chunk.toString();
+        });
+        client.on('end', () => {
+            try {
+                resolve(JSON.parse(buf.trim()));
+            }
+            catch {
+                reject(new Error(`Invalid response from tool bridge: ${buf}`));
+            }
+        });
+        client.on('error', (err) => reject(err));
+        // Safety timeout
+        setTimeout(() => {
+            client.destroy();
+            reject(new Error('Tool execution timed out'));
+        }, 130_000);
+    });
+}
+// ---------------------------------------------------------------------------
+// MCP stdio protocol (JSON-RPC over stdin/stdout)
+// ---------------------------------------------------------------------------
+// Auto-detect transport: NDJSON (newline-delimited) or Content-Length framed.
+// Claude Code CLI uses NDJSON; standard MCP SDK uses Content-Length.
+let useNdjson = false;
+let transportDetected = false;
+function send(msg) {
+    const json = JSON.stringify(msg);
+    if (useNdjson) {
+        process.stdout.write(json + '\n');
+    }
+    else {
+        const header = `Content-Length: ${Buffer.byteLength(json)}\r\n\r\n`;
+        process.stdout.write(header + json);
+    }
+}
+async function handleMessage(msg) {
+    const { method, id, params } = msg;
+    if (method === 'initialize') {
+        // Echo back the client's protocol version for compatibility
+        const clientVersion = params?.protocolVersion || '2024-11-05';
+        send({
+            jsonrpc: '2.0',
+            id,
+            result: {
+                protocolVersion: clientVersion,
+                capabilities: { tools: {} },
+                serverInfo: { name: 'fw-agent-tools', version: '1.0.0' },
+            },
+        });
+        return;
+    }
+    if (method === 'notifications/initialized') {
+        // No response needed for notifications
+        return;
+    }
+    if (method === 'tools/list') {
+        send({
+            jsonrpc: '2.0',
+            id,
+            result: { tools: toolDefs },
+        });
+        return;
+    }
+    if (method === 'tools/call') {
+        const toolName = params?.name;
+        const toolArgs = params?.arguments ?? {};
+        try {
+            const { result, isError } = await callTool(toolName, toolArgs);
+            send({
+                jsonrpc: '2.0',
+                id,
+                result: {
+                    content: [{ type: 'text', text: result }],
+                    isError,
+                },
+            });
+        }
+        catch (err) {
+            send({
+                jsonrpc: '2.0',
+                id,
+                result: {
+                    content: [{ type: 'text', text: err instanceof Error ? err.message : String(err) }],
+                    isError: true,
+                },
+            });
+        }
+        return;
+    }
+    // Unknown method — return empty result for requests, ignore notifications
+    if (id !== undefined) {
+        send({ jsonrpc: '2.0', id, result: {} });
+    }
+}
+// ---------------------------------------------------------------------------
+// Read JSON-RPC messages from stdin (auto-detect NDJSON vs Content-Length)
+// ---------------------------------------------------------------------------
+let inputBuf = '';
+process.stdin.on('data', (chunk) => {
+    inputBuf += chunk.toString();
+    // Auto-detect transport on first data: if it starts with '{', it's NDJSON
+    if (!transportDetected) {
+        const trimmed = inputBuf.trimStart();
+        if (trimmed.startsWith('{')) {
+            useNdjson = true;
+        }
+        transportDetected = true;
+    }
+    if (useNdjson) {
+        processNdjson();
+    }
+    else {
+        processContentLength();
+    }
+});
+function processNdjson() {
+    const lines = inputBuf.split('\n');
+    inputBuf = lines.pop() || '';
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const msg = JSON.parse(line);
+            handleMessage(msg).catch((err) => {
+                process.stderr.write(`mcp-tool-server error: ${err}\n`);
+            });
+        }
+        catch {
+            process.stderr.write(`mcp-tool-server: failed to parse line: ${line.slice(0, 200)}\n`);
+        }
+    }
+}
+function processContentLength() {
+    while (true) {
+        const headerEnd = inputBuf.indexOf('\r\n\r\n');
+        if (headerEnd === -1)
+            break;
+        const header = inputBuf.slice(0, headerEnd);
+        const match = header.match(/Content-Length:\s*(\d+)/i);
+        if (!match) {
+            inputBuf = inputBuf.slice(headerEnd + 4);
+            continue;
+        }
+        const contentLength = parseInt(match[1], 10);
+        const bodyStart = headerEnd + 4;
+        if (inputBuf.length < bodyStart + contentLength)
+            break;
+        const body = inputBuf.slice(bodyStart, bodyStart + contentLength);
+        inputBuf = inputBuf.slice(bodyStart + contentLength);
+        try {
+            const msg = JSON.parse(body);
+            handleMessage(msg).catch((err) => {
+                process.stderr.write(`mcp-tool-server error: ${err}\n`);
+            });
+        }
+        catch {
+            process.stderr.write(`mcp-tool-server: failed to parse message: ${body}\n`);
+        }
+    }
+}
+process.stdin.on('end', () => process.exit(0));
+//# sourceMappingURL=mcp-tool-server.js.map

package/dist/agent/providers/anthropic.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Anthropic API provider — streams messages via raw fetch + SSE parsing.
+ * No SDK dependency. Uses only Node.js native fetch (available since Node 18).
+ *
+ * Adapted from pack-weaver's streamAnthropicWithTools.
+ */
+import type { AgentProvider, AgentMessage, ToolDefinition, StreamEvent, StreamOptions } from '../types.js';
+export interface AnthropicProviderOptions {
+    apiKey: string;
+    model?: string;
+    maxTokens?: number;
+    baseUrl?: string;
+}
+export declare class AnthropicProvider implements AgentProvider {
+    private apiKey;
+    private model;
+    private maxTokens;
+    private baseUrl;
+    constructor(options: AnthropicProviderOptions);
+    stream(messages: AgentMessage[], tools: ToolDefinition[], options?: StreamOptions): AsyncGenerator<StreamEvent>;
+}
+export declare function createAnthropicProvider(options: AnthropicProviderOptions): AnthropicProvider;
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/agent/providers/anthropic.js

@@ -0,0 +1,185 @@
+/**
+ * Anthropic API provider — streams messages via raw fetch + SSE parsing.
+ * No SDK dependency. Uses only Node.js native fetch (available since Node 18).
+ *
+ * Adapted from pack-weaver's streamAnthropicWithTools.
+ */
+export class AnthropicProvider {
+    apiKey;
+    model;
+    maxTokens;
+    baseUrl;
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new Error('AnthropicProvider requires an API key');
+        }
+        this.apiKey = options.apiKey;
+        this.model = options.model ?? 'claude-sonnet-4-20250514';
+        this.maxTokens = options.maxTokens ?? 8192;
+        this.baseUrl = options.baseUrl ?? 'https://api.anthropic.com';
+    }
+    async *stream(messages, tools, options) {
+        const model = options?.model ?? this.model;
+        const maxTokens = options?.maxTokens ?? this.maxTokens;
+        // Build Anthropic API request body
+        const apiMessages = messages.map((m) => {
+            if (m.role === 'tool') {
+                return {
+                    role: 'user',
+                    content: [{ type: 'tool_result', tool_use_id: m.toolCallId, content: m.content }],
+                };
+            }
+            if (m.role === 'assistant' && m.toolCalls?.length) {
+                const blocks = [];
+                if (m.content)
+                    blocks.push({ type: 'text', text: m.content });
+                for (const tc of m.toolCalls) {
+                    blocks.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.arguments });
+                }
+                return { role: 'assistant', content: blocks };
+            }
+            return { role: m.role, content: m.content };
+        });
+        const apiTools = tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.inputSchema,
+        }));
+        const body = JSON.stringify({
+            model,
+            max_tokens: maxTokens,
+            stream: true,
+            ...(options?.systemPrompt ? { system: options.systemPrompt } : {}),
+            messages: apiMessages,
+            ...(apiTools.length > 0 ? { tools: apiTools } : {}),
+        });
+        const response = await fetch(`${this.baseUrl}/v1/messages`, {
+            method: 'POST',
+            headers: {
+                'x-api-key': this.apiKey,
+                'anthropic-version': '2025-04-15',
+                'content-type': 'application/json',
+            },
+            body,
+            signal: options?.signal ?? AbortSignal.timeout(300_000),
+        });
+        if (!response.ok) {
+            const err = await response.text();
+            throw new Error(`Anthropic API error ${response.status}: ${err.slice(0, 200)}`);
+        }
+        if (!response.body)
+            throw new Error('No response body');
+        // Parse SSE stream
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        const activeToolUses = new Map();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const jsonStr = line.slice(6).trim();
+                    if (jsonStr === '[DONE]')
+                        continue;
+                    let event;
+                    try {
+                        event = JSON.parse(jsonStr);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const eventType = event.type;
+                    if (eventType === 'content_block_start') {
+                        const block = event.content_block;
+                        const index = event.index;
+                        if (block.type === 'tool_use' && block.id && block.name) {
+                            activeToolUses.set(index, { id: block.id, name: block.name, jsonChunks: [] });
+                            yield { type: 'tool_use_start', id: block.id, name: block.name };
+                        }
+                    }
+                    if (eventType === 'content_block_delta') {
+                        const delta = event.delta;
+                        const index = event.index;
+                        if (delta.type === 'text_delta' && delta.text) {
+                            yield { type: 'text_delta', text: delta.text };
+                        }
+                        if (delta.type === 'thinking_delta' && delta.thinking) {
+                            yield { type: 'thinking_delta', text: delta.thinking };
+                        }
+                        if (delta.type === 'input_json_delta' && delta.partial_json !== undefined) {
+                            const active = activeToolUses.get(index);
+                            if (active) {
+                                active.jsonChunks.push(delta.partial_json);
+                                yield { type: 'tool_use_delta', id: active.id, partialJson: delta.partial_json };
+                            }
+                        }
+                    }
+                    if (eventType === 'content_block_stop') {
+                        const index = event.index;
+                        const active = activeToolUses.get(index);
+                        if (active) {
+                            activeToolUses.delete(index);
+                            let args = {};
+                            try {
+                                args = JSON.parse(active.jsonChunks.join(''));
+                            }
+                            catch {
+                                /* malformed */
+                            }
+                            yield { type: 'tool_use_end', id: active.id, arguments: args };
+                        }
+                    }
+                    if (eventType === 'message_start' && event.message?.usage) {
+                        const usage = event.message.usage;
+                        yield {
+                            type: 'usage',
+                            promptTokens: usage.input_tokens ?? 0,
+                            completionTokens: usage.output_tokens ?? 0,
+                        };
+                    }
+                    if (eventType === 'message_delta') {
+                        const delta = event.delta;
+                        if (event.usage) {
+                            const usage = event.usage;
+                            yield {
+                                type: 'usage',
+                                promptTokens: 0,
+                                completionTokens: usage.output_tokens ?? 0,
+                            };
+                        }
+                        if (delta?.stop_reason === 'tool_use') {
+                            yield { type: 'message_stop', finishReason: 'tool_calls' };
+                        }
+                        else if (delta?.stop_reason === 'end_turn') {
+                            yield { type: 'message_stop', finishReason: 'stop' };
+                        }
+                        else if (delta?.stop_reason === 'max_tokens') {
+                            yield { type: 'message_stop', finishReason: 'length' };
+                        }
+                        else if (delta?.stop_reason) {
+                            yield { type: 'message_stop', finishReason: 'stop' };
+                        }
+                    }
+                    if (eventType === 'error') {
+                        const errObj = event.error;
+                        throw new Error(`Anthropic stream error: ${errObj?.message ?? 'unknown'}`);
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}
+export function createAnthropicProvider(options) {
+    return new AnthropicProvider(options);
+}
+//# sourceMappingURL=anthropic.js.map

package/dist/agent/providers/claude-cli.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Claude CLI provider — spawns the Claude Code CLI with stream-json output
+ * and MCP bridge for tool execution.
+ *
+ * Adapted from platform's streamClaudeCliChat. Platform-specific dependencies
+ * (spawnSandboxed, getBinPath, config) are replaced with injectable options.
+ */
+import type { AgentProvider, AgentMessage, ToolDefinition, StreamEvent, StreamOptions, ClaudeCliProviderOptions } from '../types.js';
+export declare class ClaudeCliProvider implements AgentProvider {
+    private binPath;
+    private cwd;
+    private env;
+    private model;
+    private mcpConfigPath;
+    private spawnFn;
+    private timeout;
+    constructor(options?: ClaudeCliProviderOptions);
+    stream(messages: AgentMessage[], tools: ToolDefinition[], options?: StreamOptions): AsyncGenerator<StreamEvent>;
+}
+export declare function createClaudeCliProvider(options?: ClaudeCliProviderOptions): ClaudeCliProvider;
+//# sourceMappingURL=claude-cli.d.ts.map