@iflow-mcp/jimmy974-n8n-workflow-builder 1.0.0

package/56d11557bccd4af1a295124e12a471e3_process.log

@@ -0,0 +1,4 @@
+[2026-01-12 13:21:25] [SUCCESS] 步骤1：获取项目完成 - Fork并克隆项目成功
+[2026-01-12 13:21:45] [SUCCESS] 步骤2：阅读代码完成 - Node.js项目，MCP服务端项目，使用@modelcontextprotocol/sdk，支持stdio协议
+[2026-01-12 13:22:23] [SUCCESS] 步骤3：本地测试完成 - 修改配置、构建、本地测试通过，发现1个工具：create_workflow
+[2026-01-12 13:22:40] [SUCCESS] 步骤4：创建并推送iflow分支完成 - 已推送到https://github.com/iflow-mcp/jimmy974-n8n-workflow-builder

package/Dockerfile

@@ -0,0 +1,36 @@
+# Generated by https://smithery.ai. See: https://smithery.ai/docs/config#dockerfile
+# Use Node.js as the base image
+FROM node:20-alpine AS builder
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the package files and install dependencies
+COPY package.json package-lock.json ./
+RUN npm install
+
+# Copy the source code
+COPY src ./src
+COPY tsconfig.json ./
+
+# Compile the TypeScript code
+RUN npx tsc
+
+# Use a slim Node.js image for the final build
+FROM node:20-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy compiled code from the builder stage
+COPY --from=builder /app/dist ./dist
+
+# Install only production dependencies
+COPY package.json package-lock.json ./
+RUN npm install --omit=dev
+
+# Expose any necessary ports (assuming 3000 as an example)
+EXPOSE 3000
+
+# Command to run the application
+CMD ["node", "dist/index.js"]

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Makafeli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+# n8n Workflow Builder MCP Server
+[![smithery badge](https://smithery.ai/badge/n8n-workflow-builder)](https://smithery.ai/server/n8n-workflow-builder)
+
+A Model Context Protocol (MCP) server for programmatically creating and managing n8n workflows.
+
+<a href="https://glama.ai/mcp/servers/fhoynrlnpp"><img width="380" height="200" src="https://glama.ai/mcp/servers/fhoynrlnpp/badge" alt="n8n Workflow Builder Server MCP server" /></a>
+
+## Features
+- Create workflows with nodes and connections
+- Validate workflow specifications
+- Export complete workflow configurations
+- REST API interface through MCP
+
+## Installation
+
+### Installing via Smithery
+
+To install n8n Workflow Builder for Claude Desktop automatically via [Smithery](https://smithery.ai/server/n8n-workflow-builder):
+
+```bash
+npx -y @smithery/cli install n8n-workflow-builder --client claude
+```
+
+### Manual Installation
+1. Clone the repository:
+```bash
+git clone https://github.com/[your-username]/n8n-workflow-builder.git
+cd n8n-workflow-builder
+```
+
+2. Install dependencies:
+```bash
+npm install
+```
+
+3. Compile TypeScript:
+```bash
+npx tsc
+```
+
+4. Start the server:
+```bash
+npm start
+```
+
+## Usage
+
+The server provides a `create_workflow` tool that accepts a workflow specification:
+
+```json
+{
+  "nodes": [
+    {
+      "type": "n8n-nodes-base.httpRequest",
+      "name": "HTTP Request",
+      "parameters": {
+        "url": "https://example.com",
+        "method": "GET"
+      }
+    }
+  ],
+  "connections": []
+}
+```
+
+## Configuration
+
+Add the server to your MCP configuration:
+
+```json
+{
+  "n8n-workflow-builder": {
+    "command": "node",
+    "args": ["/path/to/n8n-workflow-builder/dist/index.js"]
+  }
+}
+```
+
+## License
+MIT

package/dist/index.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+class N8NWorkflowBuilder {
+    constructor() {
+        this.nodes = [];
+        this.connections = [];
+        this.nextPosition = { x: 100, y: 100 };
+    }
+    addNode(nodeType, name, parameters) {
+        const node = {
+            type: nodeType,
+            name: name,
+            parameters: parameters,
+            position: Object.assign({}, this.nextPosition)
+        };
+        this.nodes.push(node);
+        this.nextPosition.x += 200;
+        return name;
+    }
+    connectNodes(source, target, sourceOutput = 0, targetInput = 0) {
+        this.connections.push({
+            source_node: source,
+            target_node: target,
+            source_output: sourceOutput,
+            target_input: targetInput
+        });
+    }
+    exportWorkflow() {
+        const workflow = {
+            nodes: this.nodes,
+            connections: { main: [] }
+        };
+        for (const conn of this.connections) {
+            const connection = {
+                node: conn.target_node,
+                type: 'main',
+                index: conn.target_input,
+                sourceNode: conn.source_node,
+                sourceIndex: conn.source_output
+            };
+            workflow.connections.main.push(connection);
+        }
+        return workflow;
+    }
+}
+class N8NWorkflowServer {
+    constructor() {
+        this.server = new Server({
+            name: 'n8n-workflow-builder',
+            version: '0.1.0'
+        }, {
+            capabilities: {
+                resources: {},
+                tools: {}
+            }
+        });
+        this.setupToolHandlers();
+        this.server.onerror = (error) => console.error('[MCP Error]', error);
+    }
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, () => __awaiter(this, void 0, void 0, function* () {
+            return ({
+                tools: [{
+                        name: 'create_workflow',
+                        description: 'Create and configure n8n workflows programmatically',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                nodes: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            type: { type: 'string' },
+                                            name: { type: 'string' },
+                                            parameters: { type: 'object' }
+                                        },
+                                        required: ['type', 'name']
+                                    }
+                                },
+                                connections: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            source: { type: 'string' },
+                                            target: { type: 'string' },
+                                            sourceOutput: { type: 'number', default: 0 },
+                                            targetInput: { type: 'number', default: 0 }
+                                        },
+                                        required: ['source', 'target']
+                                    }
+                                }
+                            },
+                            required: ['nodes']
+                        }
+                    }]
+            });
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, (request) => __awaiter(this, void 0, void 0, function* () {
+            if (request.params.name !== 'create_workflow') {
+                throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+            }
+            try {
+                const builder = new N8NWorkflowBuilder();
+                function isWorkflowSpec(obj) {
+                    return obj &&
+                        typeof obj === 'object' &&
+                        Array.isArray(obj.nodes) &&
+                        obj.nodes.every((node) => typeof node === 'object' &&
+                            typeof node.type === 'string' &&
+                            typeof node.name === 'string') &&
+                        (!obj.connections || (Array.isArray(obj.connections) &&
+                            obj.connections.every((conn) => typeof conn === 'object' &&
+                                typeof conn.source === 'string' &&
+                                typeof conn.target === 'string')));
+                }
+                const args = request.params.arguments;
+                if (!isWorkflowSpec(args)) {
+                    throw new McpError(ErrorCode.InvalidParams, 'Invalid workflow specification: must include nodes array with type and name properties');
+                }
+                const { nodes, connections } = args;
+                for (const node of nodes) {
+                    builder.addNode(node.type, node.name, node.parameters || {});
+                }
+                for (const conn of connections || []) {
+                    builder.connectNodes(conn.source, conn.target, conn.sourceOutput, conn.targetInput);
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(builder.exportWorkflow(), null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                throw new McpError(ErrorCode.InternalError, `Workflow creation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }));
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transport = new StdioServerTransport();
+            yield this.server.connect(transport);
+            console.error('N8N Workflow Builder MCP server running on stdio');
+        });
+    }
+}
+const server = new N8NWorkflowServer();
+server.run().catch(console.error);

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@iflow-mcp/jimmy974-n8n-workflow-builder",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "start": "node dist/index.js"
+  },
+  "bin": {
+    "n8n-workflow-builder": "dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  }
+}

package/push_info.json

@@ -0,0 +1 @@
+{"push_platform":"github","fork_url":"https://github.com/iflow-mcp/jimmy974-n8n-workflow-builder","fork_branch":"iflow"}

package/smithery.yaml

@@ -0,0 +1,13 @@
+# Smithery configuration file: https://smithery.ai/docs/config#smitheryyaml
+
+startCommand:
+  type: stdio
+  configSchema:
+    # JSON Schema defining the configuration options for the MCP.
+    type: object
+    required: []
+    properties: {}
+  commandFunction:
+    # A function that produces the CLI command to start the MCP on stdio.
+    |-
+    (config) => ({command: 'node', args: ['dist/index.js']})

package/src/index.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+class N8NWorkflowBuilder {
+    constructor() {
+        this.nodes = [];
+        this.connections = [];
+        this.nextPosition = { x: 100, y: 100 };
+    }
+    addNode(nodeType, name, parameters) {
+        const node = {
+            type: nodeType,
+            name: name,
+            parameters: parameters,
+            position: Object.assign({}, this.nextPosition)
+        };
+        this.nodes.push(node);
+        this.nextPosition.x += 200;
+        return name;
+    }
+    connectNodes(source, target, sourceOutput = 0, targetInput = 0) {
+        this.connections.push({
+            source_node: source,
+            target_node: target,
+            source_output: sourceOutput,
+            target_input: targetInput
+        });
+    }
+    exportWorkflow() {
+        const workflow = {
+            nodes: this.nodes,
+            connections: { main: [] }
+        };
+        for (const conn of this.connections) {
+            const connection = {
+                node: conn.target_node,
+                type: 'main',
+                index: conn.target_input,
+                sourceNode: conn.source_node,
+                sourceIndex: conn.source_output
+            };
+            workflow.connections.main.push(connection);
+        }
+        return workflow;
+    }
+}
+class N8NWorkflowServer {
+    constructor() {
+        this.server = new index_js_1.Server({
+            name: 'n8n-workflow-builder',
+            version: '0.1.0'
+        }, {
+            capabilities: {
+                resources: {},
+                tools: {}
+            }
+        });
+        this.setupToolHandlers();
+        this.server.onerror = (error) => console.error('[MCP Error]', error);
+    }
+    setupToolHandlers() {
+        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, () => __awaiter(this, void 0, void 0, function* () {
+            return ({
+                tools: [{
+                        name: 'create_workflow',
+                        description: 'Create and configure n8n workflows programmatically',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                nodes: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            type: { type: 'string' },
+                                            name: { type: 'string' },
+                                            parameters: { type: 'object' }
+                                        },
+                                        required: ['type', 'name']
+                                    }
+                                },
+                                connections: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            source: { type: 'string' },
+                                            target: { type: 'string' },
+                                            sourceOutput: { type: 'number', default: 0 },
+                                            targetInput: { type: 'number', default: 0 }
+                                        },
+                                        required: ['source', 'target']
+                                    }
+                                }
+                            },
+                            required: ['nodes']
+                        }
+                    }]
+            });
+        }));
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, (request) => __awaiter(this, void 0, void 0, function* () {
+            if (request.params.name !== 'create_workflow') {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+            }
+            try {
+                const builder = new N8NWorkflowBuilder();
+                function isWorkflowSpec(obj) {
+                    return obj &&
+                        typeof obj === 'object' &&
+                        Array.isArray(obj.nodes) &&
+                        obj.nodes.every((node) => typeof node === 'object' &&
+                            typeof node.type === 'string' &&
+                            typeof node.name === 'string') &&
+                        (!obj.connections || (Array.isArray(obj.connections) &&
+                            obj.connections.every((conn) => typeof conn === 'object' &&
+                                typeof conn.source === 'string' &&
+                                typeof conn.target === 'string')));
+                }
+                const args = request.params.arguments;
+                if (!isWorkflowSpec(args)) {
+                    throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, 'Invalid workflow specification: must include nodes array with type and name properties');
+                }
+                const { nodes, connections } = args;
+                for (const node of nodes) {
+                    builder.addNode(node.type, node.name, node.parameters || {});
+                }
+                for (const conn of connections || []) {
+                    builder.connectNodes(conn.source, conn.target, conn.sourceOutput, conn.targetInput);
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(builder.exportWorkflow(), null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Workflow creation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }));
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transport = new stdio_js_1.StdioServerTransport();
+            yield this.server.connect(transport);
+            console.error('N8N Workflow Builder MCP server running on stdio');
+        });
+    }
+}
+const server = new N8NWorkflowServer();
+server.run().catch(console.error);

package/src/index.ts

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  McpError,
+  ErrorCode
+} from '@modelcontextprotocol/sdk/types.js';
+
+class N8NWorkflowBuilder {
+  private nodes: any[];
+  private connections: any[];
+  private nextPosition: { x: number, y: number };
+
+  constructor() {
+    this.nodes = [];
+    this.connections = [];
+    this.nextPosition = { x: 100, y: 100 };
+  }
+
+  addNode(nodeType: string, name: string, parameters: any) {
+    const node = {
+      type: nodeType,
+      name: name,
+      parameters: parameters,
+      position: { ...this.nextPosition }
+    };
+    this.nodes.push(node);
+    this.nextPosition.x += 200;
+    return name;
+  }
+
+  connectNodes(source: string, target: string, sourceOutput = 0, targetInput = 0) {
+    this.connections.push({
+      source_node: source,
+      target_node: target,
+      source_output: sourceOutput,
+      target_input: targetInput
+    });
+  }
+
+  exportWorkflow(): any {
+    interface WorkflowConnection {
+      node: string;
+      type: string;
+      index: number;
+      sourceNode: string;
+      sourceIndex: number;
+    }
+
+    interface Workflow {
+      nodes: any[];
+      connections: {
+        main: WorkflowConnection[];
+      };
+    }
+
+    const workflow: Workflow = {
+      nodes: this.nodes,
+      connections: { main: [] }
+    };
+    
+    for (const conn of this.connections) {
+      const connection: WorkflowConnection = {
+        node: conn.target_node,
+        type: 'main',
+        index: conn.target_input,
+        sourceNode: conn.source_node,
+        sourceIndex: conn.source_output
+      };
+      workflow.connections.main.push(connection);
+    }
+    
+    return workflow;
+  }
+}
+
+class N8NWorkflowServer {
+  private server: Server;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'n8n-workflow-builder',
+        version: '0.1.0'
+      },
+      {
+        capabilities: {
+          resources: {},
+          tools: {}
+        }
+      }
+    );
+
+    this.setupToolHandlers();
+    this.server.onerror = (error) => console.error('[MCP Error]', error);
+  }
+
+  private setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [{
+        name: 'create_workflow',
+        description: 'Create and configure n8n workflows programmatically',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            nodes: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  type: { type: 'string' },
+                  name: { type: 'string' },
+                  parameters: { type: 'object' }
+                },
+                required: ['type', 'name']
+              }
+            },
+            connections: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  source: { type: 'string' },
+                  target: { type: 'string' },
+                  sourceOutput: { type: 'number', default: 0 },
+                  targetInput: { type: 'number', default: 0 }
+                },
+                required: ['source', 'target']
+              }
+            }
+          },
+          required: ['nodes']
+        }
+      }]
+    }));
+
+    interface WorkflowNode {
+      type: string;
+      name: string;
+      parameters?: Record<string, any>;
+    }
+
+    interface WorkflowConnectionSpec {
+      source: string;
+      target: string;
+      sourceOutput?: number;
+      targetInput?: number;
+    }
+
+    interface WorkflowSpec {
+      nodes: WorkflowNode[];
+      connections?: WorkflowConnectionSpec[];
+    }
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      if (request.params.name !== 'create_workflow') {
+        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+      }
+
+      try {
+        const builder = new N8NWorkflowBuilder();
+        function isWorkflowSpec(obj: any): obj is WorkflowSpec {
+          return obj &&
+            typeof obj === 'object' &&
+            Array.isArray(obj.nodes) &&
+            obj.nodes.every((node: any) => 
+              typeof node === 'object' &&
+              typeof node.type === 'string' &&
+              typeof node.name === 'string'
+            ) &&
+            (!obj.connections || (
+              Array.isArray(obj.connections) &&
+              obj.connections.every((conn: any) =>
+                typeof conn === 'object' &&
+                typeof conn.source === 'string' &&
+                typeof conn.target === 'string'
+              )
+            ));
+        }
+
+        const args = request.params.arguments;
+        if (!isWorkflowSpec(args)) {
+          throw new McpError(
+            ErrorCode.InvalidParams,
+            'Invalid workflow specification: must include nodes array with type and name properties'
+          );
+        }
+        
+        const { nodes, connections } = args;
+
+        for (const node of nodes) {
+          builder.addNode(node.type, node.name, node.parameters || {});
+        }
+
+        for (const conn of connections || []) {
+          builder.connectNodes(
+            conn.source,
+            conn.target,
+            conn.sourceOutput,
+            conn.targetInput
+          );
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(builder.exportWorkflow(), null, 2)
+          }]
+        };
+      } catch (error) {
+        throw new McpError(
+          ErrorCode.InternalError,
+          `Workflow creation failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+        );
+      }
+    });
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('N8N Workflow Builder MCP server running on stdio');
+  }
+}
+
+const server = new N8NWorkflowServer();
+server.run().catch(console.error);

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}