@synergenius/flow-weaver 0.2.0

package/dist/mcp/response-utils.js

@@ -0,0 +1,89 @@
+/**
+ * Wraps a data payload into a successful MCP tool result with JSON text content.
+ * @param data - The result data to include in the response.
+ * @returns An MCP tool result object with `success: true` and the serialized data.
+ */
+export function makeToolResult(data) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ success: true, data }, null, 2) }],
+    };
+}
+/**
+ * Wraps an error code and message into a failed MCP tool result.
+ * @param code - A machine-readable error code (e.g. "UNKNOWN_NODE_TYPE").
+ * @param message - A human-readable error description.
+ * @returns An MCP tool result object with `success: false`, `isError: true`, and the serialized error.
+ */
+export function makeErrorResult(code, message) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({ success: false, error: { code, message } }, null, 2),
+            },
+        ],
+        isError: true,
+    };
+}
+/**
+ * Maps validation error codes to suggested next MCP tool actions.
+ * Used to guide LLM agents toward resolving workflow issues.
+ */
+export const ERROR_HINTS = {
+    UNKNOWN_NODE_TYPE: 'Run fw_query(query="node-types") to see available types',
+    UNKNOWN_SOURCE_NODE: 'Run fw_query(query="nodes") to see all node instances',
+    UNKNOWN_TARGET_NODE: 'Run fw_query(query="nodes") to see all node instances',
+    UNKNOWN_SOURCE_PORT: 'Run fw_describe(node="<nodeId>") to see available ports. Use fw_modify(operation="addConnection") to safely wire ports.',
+    UNKNOWN_TARGET_PORT: 'Run fw_describe(node="<nodeId>") to see available ports. Use fw_modify(operation="addConnection") to safely wire ports.',
+    MISSING_REQUIRED_INPUT: 'Add a @connect to this port, or make it optional with @input portName [optional]',
+    CYCLE_DETECTED: 'Use a scoped forEach node instead of graph loops. See flow-weaver:flow-weaver-export-interface',
+    STEP_PORT_TYPE_MISMATCH: 'STEP ports (execute, onSuccess, onFailure) can only connect to other STEP ports',
+    MULTIPLE_CONNECTIONS_TO_INPUT: 'Data inputs accept only one connection. Use a merge node or separate ports',
+    UNUSED_NODE: 'Connect this node or remove it with fw_modify(operation="removeNode")',
+    NO_START_CONNECTIONS: 'Add @connect Start.portName -> node.port, or use fw_modify(operation="addConnection") to wire it.',
+    NO_EXIT_CONNECTIONS: 'Add @connect node.port -> Exit.portName, or use fw_modify(operation="addConnection") to wire it.',
+    UNREACHABLE_EXIT_PORT: 'Use fw_modify(operation="addConnection") to connect a node output to this Exit port.',
+    RESERVED_NODE_NAME: 'Rename the node type — "Start" and "Exit" are reserved',
+    RESERVED_INSTANCE_ID: 'Rename the instance — "Start" and "Exit" are reserved IDs',
+    MULTIPLE_WORKFLOWS_FOUND: 'Specify workflowName parameter to select which workflow to use',
+    DUPLICATE_NODE_NAME: 'Rename one of the duplicate node type functions to be unique',
+    UNDEFINED_NODE: 'Add a @node annotation for the referenced instance, or fix the connection',
+    INVALID_EXIT_PORT_TYPE: 'Ensure Exit onSuccess/onFailure ports are STEP type (auto-generated)',
+    // Agent-specific rules
+    AGENT_LLM_MISSING_ERROR_HANDLER: 'Use fw_modify(operation="addConnection", params={from:"<nodeId>.onFailure", to:"Exit.onFailure"}) or add a retry/fallback node',
+    AGENT_UNGUARDED_TOOL_EXECUTOR: 'Add a human-approval node before the tool executor. Use fw_scaffold(template="human-approval") to create one',
+    AGENT_MISSING_MEMORY_IN_LOOP: 'Add a conversation-memory node inside the loop scope. Use fw_scaffold(template="conversation-memory") to create one',
+    AGENT_LLM_NO_FALLBACK: 'Add a retry or fallback node between the LLM onFailure and Exit. Consider a second LLM provider as fallback',
+    AGENT_TOOL_NO_OUTPUT_HANDLING: 'Use fw_modify(operation="addConnection") to wire tool output ports to downstream nodes',
+};
+/**
+ * Enriches validation items with actionable hints from {@link ERROR_HINTS} and optional
+ * friendly error explanations. Replaces `<nodeId>` placeholders in hints with actual node IDs.
+ * @param items - Array of validation errors/warnings, each with a message, severity, and optional code.
+ * @param friendlyErrorFn - Optional function that produces user-friendly error explanations.
+ * @returns A new array with `hint` and `friendly` fields added where applicable.
+ */
+export function addHintsToItems(items, friendlyErrorFn) {
+    return items.map((item) => {
+        if (!item.code)
+            return item;
+        const result = { ...item };
+        // Add MCP tool hint
+        let hint = ERROR_HINTS[item.code];
+        if (hint) {
+            if (item.nodeId && hint.includes('<nodeId>')) {
+                hint = hint.replace(/<nodeId>/g, item.nodeId);
+            }
+            result.hint = hint;
+        }
+        // Add friendly error explanation
+        if (friendlyErrorFn) {
+            const friendly = friendlyErrorFn({ code: item.code, message: item.message, node: item.nodeId });
+            if (friendly) {
+                result.friendly = { title: friendly.title, explanation: friendly.explanation, fix: friendly.fix };
+            }
+        }
+        return result;
+    });
+}
+//# sourceMappingURL=response-utils.js.map

package/dist/mcp/server.d.ts

@@ -0,0 +1,4 @@
+import type { McpServerOptions } from './types.js';
+export declare function startMcpServer(options: McpServerOptions): Promise<void>;
+export declare function mcpServerCommand(options: McpServerOptions): Promise<void>;
+//# sourceMappingURL=server.d.ts.map

package/dist/mcp/server.js

@@ -0,0 +1,99 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { DEFAULT_SERVER_URL } from '../defaults.js';
+import { EventBuffer } from './event-buffer.js';
+import { EditorConnection } from './editor-connection.js';
+import { offerClaudeRegistration } from './auto-registration.js';
+import { registerEditorTools } from './tools-editor.js';
+import { registerQueryTools } from './tools-query.js';
+import { registerTemplateTools } from './tools-template.js';
+import { registerPatternTools } from './tools-pattern.js';
+import { registerExportTools } from './tools-export.js';
+import { registerMarketplaceTools } from './tools-marketplace.js';
+import { registerDiagramTools } from './tools-diagram.js';
+import { registerResources } from './resources.js';
+function parseEventFilterFromEnv() {
+    const filter = {};
+    const include = process.env.FW_EVENT_INCLUDE;
+    if (include) {
+        filter.include = include
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }
+    const exclude = process.env.FW_EVENT_EXCLUDE;
+    if (exclude) {
+        filter.exclude = exclude
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }
+    const dedupeMs = process.env.FW_EVENT_DEDUPE_MS;
+    if (dedupeMs) {
+        const parsed = parseInt(dedupeMs, 10);
+        if (!isNaN(parsed))
+            filter.dedupeWindowMs = parsed;
+    }
+    const maxBuf = process.env.FW_EVENT_MAX;
+    if (maxBuf) {
+        const parsed = parseInt(maxBuf, 10);
+        if (!isNaN(parsed))
+            filter.maxBufferSize = parsed;
+    }
+    return filter;
+}
+export async function startMcpServer(options) {
+    const serverUrl = options.server || DEFAULT_SERVER_URL;
+    // Parse event filter config from environment variables
+    const filterFromEnv = parseEventFilterFromEnv();
+    // Use injected deps for testing, or create real ones
+    const buffer = options._testDeps?.buffer ?? new EventBuffer(undefined, undefined, filterFromEnv);
+    const connection = options._testDeps?.connection ?? new EditorConnection(serverUrl, buffer);
+    // Connect to editor (non-blocking)
+    if (!options._testDeps) {
+        const log = options.stdio
+            ? (msg) => process.stderr.write(msg + '\n')
+            : // eslint-disable-next-line no-console
+                (msg) => console.log(msg);
+        connection.connect(log);
+    }
+    // Create MCP server
+    const mcp = new McpServer({
+        name: 'flow-weaver',
+        version: '1.0.0',
+    });
+    // Register all tools and resources
+    registerEditorTools(mcp, connection, buffer);
+    registerQueryTools(mcp);
+    registerTemplateTools(mcp);
+    registerPatternTools(mcp);
+    registerExportTools(mcp);
+    registerMarketplaceTools(mcp);
+    registerDiagramTools(mcp);
+    registerResources(mcp, connection, buffer);
+    // Connect transport (only in stdio MCP mode)
+    if (!options._testDeps && options.stdio) {
+        const transport = new StdioServerTransport();
+        await mcp.connect(transport);
+    }
+}
+export async function mcpServerCommand(options) {
+    const serverUrl = options.server || DEFAULT_SERVER_URL;
+    // In stdio mode, stdout is reserved for JSON-RPC — log to stderr.
+    // In interactive mode, log to stdout (write + flush to survive SIGTERM).
+    const log = options.stdio
+        ? (msg) => process.stderr.write(msg + '\n')
+        : (msg) => process.stdout.write(msg + '\n');
+    if (!options.stdio) {
+        // Interactive mode — offer registration first
+        await offerClaudeRegistration(options);
+        log(`Starting MCP server (editor: ${serverUrl})...`);
+    }
+    await startMcpServer(options);
+    if (!options.stdio) {
+        log('MCP server running. Waiting for connections...');
+    }
+    // Keep alive
+    await new Promise(() => { });
+}
+//# sourceMappingURL=server.js.map

package/dist/mcp/tools-diagram.d.ts

@@ -0,0 +1,8 @@
+/**
+ * MCP Diagram Tool - fw_diagram
+ *
+ * Generates SVG diagrams from workflow files.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerDiagramTools(mcp: McpServer): void;
+//# sourceMappingURL=tools-diagram.d.ts.map

package/dist/mcp/tools-diagram.js

@@ -0,0 +1,53 @@
+/**
+ * MCP Diagram Tool - fw_diagram
+ *
+ * Generates SVG diagrams from workflow files.
+ */
+import { z } from 'zod';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileToSVG } from '../diagram/index.js';
+import { makeToolResult, makeErrorResult } from './response-utils.js';
+export function registerDiagramTools(mcp) {
+    mcp.tool('fw_diagram', 'Generate an SVG diagram of a workflow. Returns SVG string or writes to a file.', {
+        filePath: z.string().describe('Path to the workflow .ts file'),
+        outputPath: z
+            .string()
+            .optional()
+            .describe('Output file path for the SVG. If omitted, returns SVG as text.'),
+        workflowName: z
+            .string()
+            .optional()
+            .describe('Specific workflow name if file has multiple'),
+        theme: z
+            .enum(['dark', 'light'])
+            .optional()
+            .describe('Color theme (default: dark)'),
+        showPortLabels: z
+            .boolean()
+            .optional()
+            .describe('Show port labels on diagram (default: true)'),
+    }, async (args) => {
+        try {
+            const resolvedPath = path.resolve(args.filePath);
+            if (!fs.existsSync(resolvedPath)) {
+                return makeErrorResult('FILE_NOT_FOUND', `File not found: ${resolvedPath}`);
+            }
+            const svg = fileToSVG(resolvedPath, {
+                workflowName: args.workflowName,
+                theme: args.theme,
+                showPortLabels: args.showPortLabels,
+            });
+            if (args.outputPath) {
+                const outputResolved = path.resolve(args.outputPath);
+                fs.writeFileSync(outputResolved, svg, 'utf-8');
+                return makeToolResult({ written: outputResolved, size: svg.length });
+            }
+            return makeToolResult(svg);
+        }
+        catch (error) {
+            return makeErrorResult('DIAGRAM_ERROR', `Diagram generation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+}
+//# sourceMappingURL=tools-diagram.js.map

package/dist/mcp/tools-editor.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { EditorConnection } from './editor-connection.js';
+import type { EventBuffer } from './event-buffer.js';
+export declare function registerEditorTools(mcp: McpServer, connection: EditorConnection, buffer: EventBuffer): void;
+//# sourceMappingURL=tools-editor.d.ts.map

package/dist/mcp/tools-editor.js

@@ -0,0 +1,190 @@
+import { z } from 'zod';
+import { makeToolResult, makeErrorResult } from './response-utils.js';
+import { executeWorkflowFromFile } from './workflow-executor.js';
+/**
+ * Unwrap editor ack responses to flatten double-nested results.
+ * Editor returns { requestId, success, result: { actualData } } —
+ * we extract the `result` field to avoid double-nesting in MCP output.
+ */
+function unwrapAckResult(ack) {
+    if (ack && typeof ack === 'object' && 'result' in ack && ack.result !== undefined) {
+        return ack.result;
+    }
+    return ack;
+}
+export function registerEditorTools(mcp, connection, buffer) {
+    mcp.tool('fw_check_events', 'Get buffered editor events. Returns and clears the event buffer unless peek=true.', { peek: z.boolean().optional().describe('If true, read events without clearing the buffer') }, async (args) => {
+        const events = args.peek ? buffer.peek() : buffer.drain();
+        return makeToolResult(events);
+    });
+    mcp.tool('fw_get_state', 'Get the current editor/workflow state from Flow Weaver.', {}, async () => {
+        if (!connection.isConnected) {
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+        }
+        const result = await connection.sendCommand('get-state', {});
+        return makeToolResult(unwrapAckResult(result));
+    });
+    mcp.tool('fw_focus_node', 'Select and center a node in the Flow Weaver editor.', { nodeId: z.string().describe('The ID of the node to focus') }, async (args) => {
+        if (!connection.isConnected) {
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+        }
+        const result = await connection.sendCommand('focus-node', { nodeId: args.nodeId });
+        return makeToolResult(unwrapAckResult(result));
+    });
+    mcp.tool('fw_add_node', 'Add a new node to the workflow in the Flow Weaver editor.', {
+        nodeTypeName: z.string().describe('The name of the node type to add'),
+        nodeTypeDefinition: z
+            .record(z.unknown())
+            .optional()
+            .describe('Optional node type definition object'),
+    }, async (args) => {
+        if (!connection.isConnected) {
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+        }
+        const params = { nodeTypeName: args.nodeTypeName };
+        if (args.nodeTypeDefinition) {
+            params.nodeTypeDefinition = args.nodeTypeDefinition;
+        }
+        const result = await connection.sendCommand('add-node', params);
+        return makeToolResult(unwrapAckResult(result));
+    });
+    mcp.tool('fw_open_workflow', 'Open a workflow file in the Flow Weaver editor.', { filePath: z.string().describe('The path to the workflow file to open') }, async (args) => {
+        if (!connection.isConnected) {
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+        }
+        const result = await connection.sendCommand('open-workflow', { filePath: args.filePath });
+        return makeToolResult(unwrapAckResult(result));
+    });
+    mcp.tool('fw_send_command', 'Send a generic command to the Flow Weaver editor.', {
+        action: z.string().describe('The command action name'),
+        params: z.record(z.unknown()).optional().describe('Optional parameters for the command'),
+    }, async (args) => {
+        if (!connection.isConnected) {
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+        }
+        const result = await connection.sendCommand(args.action, args.params ?? {});
+        return makeToolResult(unwrapAckResult(result));
+    });
+    mcp.tool('fw_batch', 'Execute a batch of commands with auto-snapshot rollback support.', {
+        commands: z
+            .array(z.object({
+            action: z.string(),
+            params: z.record(z.unknown()).optional(),
+        }))
+            .describe('Array of commands to execute as a batch'),
+    }, async (args) => {
+        if (!connection.isConnected) {
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+        }
+        const result = await connection.sendBatch(args.commands);
+        return makeToolResult(unwrapAckResult(result));
+    });
+    // --- New tools ---
+    mcp.tool('fw_remove_node', 'Remove a node and its connections from the workflow.', { nodeName: z.string().describe('The name/ID of the node to remove') }, async (args) => {
+        if (!connection.isConnected) {
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+        }
+        const result = await connection.sendCommand('remove-node', { nodeName: args.nodeName });
+        return makeToolResult(unwrapAckResult(result));
+    });
+    mcp.tool('fw_connect', 'Add or remove a connection between ports.', {
+        action: z.enum(['add', 'remove']).describe('Whether to add or remove the connection'),
+        connection: z
+            .object({
+            sourceNode: z.string().describe('Source node ID'),
+            sourcePort: z.string().describe('Source port name'),
+            targetNode: z.string().describe('Target node ID'),
+            targetPort: z.string().describe('Target port name'),
+        })
+            .describe('Connection specification'),
+    }, async (args) => {
+        if (!connection.isConnected) {
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+        }
+        const bridgeAction = args.action === 'add' ? 'add-connection' : 'remove-connection';
+        const result = await connection.sendCommand(bridgeAction, {
+            connection: args.connection,
+        });
+        return makeToolResult(unwrapAckResult(result));
+    });
+    mcp.tool('fw_undo_redo', 'Undo or redo the last workflow change.', { action: z.enum(['undo', 'redo']).describe('Whether to undo or redo') }, async (args) => {
+        if (!connection.isConnected) {
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+        }
+        const result = await connection.sendCommand(args.action, {});
+        return makeToolResult(unwrapAckResult(result));
+    });
+    mcp.tool('fw_execute_workflow', 'Run the current workflow with optional parameters and return the result.', {
+        filePath: z
+            .string()
+            .optional()
+            .describe('Path to workflow file. When provided, compiles and executes directly (no editor needed)'),
+        workflowName: z
+            .string()
+            .optional()
+            .describe('Specific workflow function name (for multi-workflow files)'),
+        params: z.record(z.unknown()).optional().describe('Optional execution parameters'),
+        includeTrace: z
+            .boolean()
+            .optional()
+            .describe('Include execution trace events (default: true)'),
+    }, async (args) => {
+        // When filePath is provided, compile and execute directly (no editor needed)
+        if (args.filePath) {
+            try {
+                const execResult = await executeWorkflowFromFile(args.filePath, args.params, {
+                    workflowName: args.workflowName,
+                    includeTrace: args.includeTrace,
+                });
+                return makeToolResult(execResult);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                // Distinguish compile errors from execution errors
+                const code = message.includes('Parse errors') ? 'COMPILE_ERROR' : 'EXECUTION_ERROR';
+                return makeErrorResult(code, message);
+            }
+        }
+        // No filePath: delegate to editor via Socket.io (existing behavior)
+        if (!connection.isConnected) {
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+        }
+        const result = await connection.sendCommand('execute-workflow', args.params ?? {});
+        return makeToolResult(unwrapAckResult(result));
+    });
+    mcp.tool('fw_get_workflow_details', 'Get full workflow structure including nodes, connections, types, and positions.', {}, async () => {
+        if (!connection.isConnected) {
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+        }
+        const result = await connection.sendCommand('get-workflow-details', {});
+        return makeToolResult(unwrapAckResult(result));
+    });
+    mcp.tool('fw_configure_events', 'Configure event include/exclude filters, dedup window, and buffer size. Returns the active config after applying updates.', {
+        include: z
+            .array(z.string())
+            .optional()
+            .describe('Event patterns to include (empty = all). Supports trailing * for prefix match'),
+        exclude: z
+            .array(z.string())
+            .optional()
+            .describe('Event patterns to exclude (applied after include)'),
+        dedupeWindowMs: z
+            .number()
+            .optional()
+            .describe('Collapse same-type events within this window in ms (0 = disabled)'),
+        maxBufferSize: z.number().optional().describe('Max events before oldest are evicted'),
+    }, async (args) => {
+        const partial = {};
+        if (args.include !== undefined)
+            partial.include = args.include;
+        if (args.exclude !== undefined)
+            partial.exclude = args.exclude;
+        if (args.dedupeWindowMs !== undefined)
+            partial.dedupeWindowMs = args.dedupeWindowMs;
+        if (args.maxBufferSize !== undefined)
+            partial.maxBufferSize = args.maxBufferSize;
+        const config = buffer.setFilter(partial);
+        return makeToolResult(config);
+    });
+}
+//# sourceMappingURL=tools-editor.js.map

package/dist/mcp/tools-export.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MCP Export Tool - fw_export
+ *
+ * Allows Claude Code to export workflows as serverless deployments
+ * without the GUI. Generates handler code, platform config, and deploy instructions.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerExportTools(mcp: McpServer): void;
+//# sourceMappingURL=tools-export.d.ts.map

package/dist/mcp/tools-export.js

@@ -0,0 +1,180 @@
+/**
+ * MCP Export Tool - fw_export
+ *
+ * Allows Claude Code to export workflows as serverless deployments
+ * without the GUI. Generates handler code, platform config, and deploy instructions.
+ */
+import { z } from 'zod';
+import * as path from 'path';
+import * as fs from 'fs';
+import { parseWorkflow } from '../api/index.js';
+import { createTargetRegistry } from '../deployment/index.js';
+import { makeToolResult, makeErrorResult } from './response-utils.js';
+export function registerExportTools(mcp) {
+    mcp.tool('fw_export', 'Export workflows as serverless deployments. Generates handler code, platform config, and deploy instructions.', {
+        filePath: z.string().describe('Path to the workflow .ts file'),
+        target: z
+            .enum(['lambda', 'vercel', 'cloudflare', 'inngest'])
+            .describe('Deployment target platform'),
+        outputDir: z.string().describe('Output directory for generated files'),
+        serviceName: z
+            .string()
+            .optional()
+            .describe('Service name (default: derived from filename)'),
+        workflows: z
+            .array(z.string())
+            .optional()
+            .describe('Specific workflow function names to include (default: all)'),
+        nodeTypes: z
+            .array(z.string())
+            .optional()
+            .describe('Specific node type names to include'),
+        includeDocs: z
+            .boolean()
+            .optional()
+            .describe('Include OpenAPI/Swagger routes (default: true)'),
+        preview: z
+            .boolean()
+            .optional()
+            .describe('Preview without writing files to disk (default: false)'),
+        durableSteps: z
+            .boolean()
+            .optional()
+            .describe('Use deep generator with per-node Inngest steps for durability (inngest target only)'),
+    }, async (args) => {
+        try {
+            const filePath = path.resolve(args.filePath);
+            const outputDir = path.resolve(args.outputDir);
+            const preview = args.preview ?? false;
+            const includeDocs = args.includeDocs ?? true;
+            // 1. Validate file exists
+            try {
+                await fs.promises.access(filePath);
+            }
+            catch {
+                return makeErrorResult('FILE_NOT_FOUND', `File not found: ${filePath}`);
+            }
+            // 2. Parse the file to discover workflows and node types
+            let parseResult;
+            try {
+                parseResult = await parseWorkflow(filePath, { nodeTypesOnly: false });
+            }
+            catch (err) {
+                return makeErrorResult('PARSE_ERROR', `Failed to parse ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            if (parseResult.errors.length > 0) {
+                // Try node-types-only parse
+                try {
+                    const ntResult = await parseWorkflow(filePath, { nodeTypesOnly: true });
+                    if (ntResult.errors.length === 0) {
+                        parseResult = ntResult;
+                    }
+                }
+                catch {
+                    // Use original errors
+                }
+                if (parseResult.errors.length > 0) {
+                    return makeErrorResult('PARSE_ERROR', `Parse errors in ${filePath}: ${parseResult.errors.join('; ')}`);
+                }
+            }
+            // 3. Get the export target
+            const registry = createTargetRegistry();
+            const exportTarget = registry.get(args.target);
+            if (!exportTarget) {
+                return makeErrorResult('INVALID_TARGET', `Unknown target: ${args.target}. Supported: lambda, vercel, cloudflare, inngest`);
+            }
+            if (!exportTarget.generateBundle) {
+                return makeErrorResult('INVALID_TARGET', `Target ${args.target} does not support bundle export`);
+            }
+            // 4. Build workflow and node type lists
+            // parseResult.allWorkflows has all TWorkflowAST[] from the file;
+            // each workflow's nodeTypes are in workflow.nodeTypes (TNodeTypeAST[])
+            const allWorkflows = parseResult.allWorkflows || [];
+            const allNodeTypes = allWorkflows.flatMap((w) => w.nodeTypes || []);
+            // Deduplicate node types by name (same type may appear in multiple workflows)
+            const uniqueNodeTypes = [
+                ...new Map(allNodeTypes.map((nt) => [nt.name, nt])).values(),
+            ];
+            const serviceName = args.serviceName || path.basename(filePath, '.ts').replace(/[^a-zA-Z0-9-]/g, '-');
+            // Filter to requested items
+            const bundleWorkflows = allWorkflows
+                .filter((w) => (args.workflows ? args.workflows.includes(w.name) : true))
+                .map((w) => ({
+                name: w.name,
+                functionName: w.functionName,
+                description: w.description,
+                expose: true,
+            }));
+            const bundleNodeTypes = uniqueNodeTypes
+                .filter((nt) => (args.nodeTypes ? args.nodeTypes.includes(nt.name) : false))
+                .map((nt) => ({
+                name: nt.name,
+                functionName: nt.functionName,
+                description: undefined,
+                inputs: Object.fromEntries(Object.entries(nt.inputs).map(([k, v]) => [
+                    k,
+                    { dataType: v.dataType, tsType: v.tsType, label: v.label, optional: v.optional },
+                ])),
+                outputs: Object.fromEntries(Object.entries(nt.outputs).map(([k, v]) => [
+                    k,
+                    { dataType: v.dataType, tsType: v.tsType, label: v.label },
+                ])),
+                expose: true,
+            }));
+            if (bundleWorkflows.length === 0 && bundleNodeTypes.length === 0) {
+                return makeErrorResult('EXPORT_ERROR', 'No workflows or node types selected for export. ' +
+                    `Found ${allWorkflows.length} workflows and ${allNodeTypes.length} node types in file.`);
+            }
+            // 5. Generate the bundle
+            const artifacts = await exportTarget.generateBundle(bundleWorkflows, bundleNodeTypes, {
+                sourceFile: filePath,
+                workflowName: serviceName,
+                displayName: serviceName,
+                outputDir,
+                production: true,
+                includeDocs,
+                targetOptions: args.durableSteps ? { durableSteps: true } : undefined,
+            });
+            // 6. Write files if not preview
+            if (!preview) {
+                await fs.promises.mkdir(outputDir, { recursive: true });
+                for (const file of artifacts.files) {
+                    const fullPath = path.join(outputDir, file.relativePath);
+                    await fs.promises.mkdir(path.dirname(fullPath), { recursive: true });
+                    await fs.promises.writeFile(fullPath, file.content, 'utf-8');
+                }
+            }
+            // 7. Get deploy instructions
+            const instructions = exportTarget.getDeployInstructions(artifacts);
+            // 8. Return result
+            return makeToolResult({
+                preview,
+                target: args.target,
+                serviceName,
+                outputDir,
+                files: artifacts.files.map((f) => ({
+                    path: f.relativePath,
+                    type: f.type,
+                    size: f.content.length,
+                })),
+                endpoints: bundleWorkflows.map((w) => ({
+                    method: 'POST',
+                    path: `/workflows/${w.functionName}`,
+                    name: w.name,
+                })),
+                instructions: {
+                    title: instructions.title,
+                    steps: instructions.steps,
+                    prerequisites: instructions.prerequisites,
+                },
+                summary: preview
+                    ? `Preview: ${artifacts.files.length} files would be generated in ${outputDir}`
+                    : `Exported ${artifacts.files.length} files to ${outputDir}`,
+            });
+        }
+        catch (err) {
+            return makeErrorResult('EXPORT_ERROR', `Export failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+}
+//# sourceMappingURL=tools-export.js.map

package/dist/mcp/tools-marketplace.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MCP Marketplace Tools — fw_market_search, fw_market_install, fw_market_list
+ *
+ * Allows Claude Code to discover, install, and inspect marketplace packages
+ * during vibe coding sessions.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerMarketplaceTools(mcp: McpServer): void;
+//# sourceMappingURL=tools-marketplace.d.ts.map