n8n-workflow-builder-mcp 0.1.0

package/tests/run-tests.js

@@ -0,0 +1,55 @@
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Get all test files in the unit directory
+const unitTestDir = path.join(__dirname, 'unit');
+const testFiles = fs.readdirSync(unitTestDir)
+    .filter(file => file.endsWith('.test.js'))
+    .map(file => path.join(unitTestDir, file));
+
+console.log('Running memory connection tests...\n');
+
+// Results tracking
+let totalTests = 0;
+let passedTests = 0;
+let failedTests = 0;
+
+// Run each test file
+testFiles.forEach(testFile => {
+    console.log(`\n==== Running tests from ${path.basename(testFile)} ====`);
+
+    try {
+        const output = execSync(`node ${testFile}`, { encoding: 'utf8' });
+        console.log(output);
+
+        // Parse results from output
+        const summaryMatch = output.match(/Total: (\d+), Passed: (\d+), Failed: (\d+)/);
+        if (summaryMatch) {
+            const fileTotal = parseInt(summaryMatch[1], 10);
+            const filePassed = parseInt(summaryMatch[2], 10);
+            const fileFailed = parseInt(summaryMatch[3], 10);
+
+            totalTests += fileTotal;
+            passedTests += filePassed;
+            failedTests += fileFailed;
+        }
+    } catch (error) {
+        console.error(`Error running ${testFile}:`);
+        console.error(error.message);
+        failedTests++;
+    }
+});
+
+// Print overall summary
+console.log('\n======================================');
+console.log('           OVERALL SUMMARY           ');
+console.log('======================================');
+console.log(`Total Test Files: ${testFiles.length}`);
+console.log(`Total Tests: ${totalTests}`);
+console.log(`Passed: ${passedTests}`);
+console.log(`Failed: ${failedTests}`);
+console.log('======================================');
+
+// Exit with appropriate code
+process.exit(failedTests > 0 ? 1 : 0); 

package/tests/server.test.js

@@ -0,0 +1,203 @@
+/**
+ * Basic tests for the MCP server
+ */
+
+const request = require('supertest');
+const express = require('express');
+const cors = require('cors');
+const { authenticate } = require('../src/middleware/auth');
+const { validateToolRequest, logMcpRequest } = require('../src/middleware/mcp');
+const { formatToolDefinitions, createSuccessResponse, createErrorResponse } = require('../src/utils/mcp');
+const { toolDefinitions } = require('../src/tools/toolDefinitions');
+
+// Mock logger
+jest.mock('../src/utils/logger', () => ({
+    logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        debug: jest.fn(),
+        warn: jest.fn()
+    }
+}));
+
+// Setup test environment variables to bypass authentication
+beforeAll(() => {
+    process.env.NODE_ENV = 'development';
+    process.env.SKIP_AUTH = 'true';
+});
+
+afterAll(() => {
+    delete process.env.NODE_ENV;
+    delete process.env.SKIP_AUTH;
+});
+
+// Create a test app
+const createTestApp = () => {
+    const app = express();
+    app.use(cors());
+    app.use(express.json());
+
+    // Health check
+    app.get('/health', (req, res) => {
+        res.status(200).json({ status: 'ok', message: 'MCP server is running' });
+    });
+
+    // Default route
+    app.get('/', (req, res) => {
+        res.status(200).json({
+            message: 'n8n Workflow Builder MCP API',
+            version: '0.1.0',
+        });
+    });
+
+    // MCP Protocol routes
+    app.post('/mcp/tools', authenticate, logMcpRequest, (req, res) => {
+        try {
+            const toolDefs = formatToolDefinitions(toolDefinitions);
+            const response = createSuccessResponse({ tools: toolDefs });
+            res.status(response.status).json(response.data);
+        } catch (error) {
+            const errorResponse = createErrorResponse(
+                'Failed to generate tool definitions',
+                'TOOL_DEFINITION_ERROR'
+            );
+            res.status(errorResponse.status).json({ error: errorResponse.error });
+        }
+    });
+
+    app.post('/mcp/execute', authenticate, logMcpRequest, validateToolRequest, async (req, res) => {
+        try {
+            const { name, parameters } = req.body;
+
+            // Get tool definition
+            const tool = toolDefinitions[name];
+
+            if (!tool) {
+                const errorResponse = createErrorResponse(
+                    `Tool "${name}" not found`,
+                    'TOOL_NOT_FOUND',
+                    404
+                );
+                return res.status(errorResponse.status).json({ error: errorResponse.error });
+            }
+
+            // For testing, we don't actually call the tool execute function
+            // Just return success with the parameters
+            const response = createSuccessResponse({
+                tool: name,
+                parameters
+            });
+
+            res.status(response.status).json(response.data);
+        } catch (error) {
+            const errorResponse = createErrorResponse(
+                'An unexpected error occurred',
+                'INTERNAL_SERVER_ERROR',
+                500
+            );
+            res.status(errorResponse.status).json({ error: errorResponse.error });
+        }
+    });
+
+    return app;
+};
+
+describe('MCP Server', () => {
+    let app;
+
+    beforeEach(() => {
+        app = createTestApp();
+    });
+
+    describe('Health Check', () => {
+        it('should return 200 OK for health check', async () => {
+            const response = await request(app).get('/health');
+            expect(response.status).toBe(200);
+            expect(response.body).toHaveProperty('status', 'ok');
+            expect(response.body).toHaveProperty('message', 'MCP server is running');
+        });
+    });
+
+    describe('Default Route', () => {
+        it('should return API information for root route', async () => {
+            const response = await request(app).get('/');
+            expect(response.status).toBe(200);
+            expect(response.body).toHaveProperty('message', 'n8n Workflow Builder MCP API');
+            expect(response.body).toHaveProperty('version', '0.1.0');
+        });
+    });
+
+    describe('MCP Tool Definitions', () => {
+        it('should return tool definitions', async () => {
+            const response = await request(app).post('/mcp/tools');
+            expect(response.status).toBe(200);
+            expect(response.body).toHaveProperty('tools');
+            expect(Array.isArray(response.body.tools)).toBe(true);
+        });
+    });
+
+    describe('MCP Tool Execution', () => {
+        it('should return 400 if tool name is missing', async () => {
+            const response = await request(app)
+                .post('/mcp/execute')
+                .send({ parameters: {} });
+
+            expect(response.status).toBe(400);
+            expect(response.body).toHaveProperty('error');
+            expect(response.body.error).toHaveProperty('code', 'INVALID_REQUEST_FORMAT');
+        });
+
+        it('should handle invalid tool name format', async () => {
+            const response = await request(app)
+                .post('/mcp/execute')
+                .send({ name: 'invalid_format_missing_action', parameters: {} });
+
+            // This should return 404 since the tool doesn't exist in toolDefinitions
+            expect(response.status).toBe(404);
+            expect(response.body).toHaveProperty('error');
+            expect(response.body.error).toHaveProperty('code', 'TOOL_NOT_FOUND');
+        });
+
+        it('should return 404 if tool does not exist', async () => {
+            const response = await request(app)
+                .post('/mcp/execute')
+                .send({ name: 'nonexistent_tool', parameters: {} });
+
+            expect(response.status).toBe(404);
+            expect(response.body).toHaveProperty('error');
+            expect(response.body.error).toHaveProperty('code', 'TOOL_NOT_FOUND');
+        });
+
+        it('should process valid tool execution request', async () => {
+            // We need to use a tool that actually exists in toolDefinitions
+            // Let's check what tools are available first
+            const toolsResponse = await request(app).post('/mcp/tools');
+            const availableTools = toolsResponse.body.tools;
+
+            // Use the first available tool for testing
+            if (availableTools && availableTools.length > 0) {
+                const testTool = availableTools[0];
+
+                // Provide required parameters based on the tool
+                let testParameters = {};
+                if (testTool.name === 'workflow_manage') {
+                    testParameters = { operation: 'list' }; // Provide required operation parameter
+                }
+
+                const response = await request(app)
+                    .post('/mcp/execute')
+                    .send({
+                        name: testTool.name,
+                        parameters: testParameters
+                    });
+
+                expect(response.status).toBe(200);
+                expect(response.body).toHaveProperty('tool', testTool.name);
+                expect(response.body).toHaveProperty('parameters');
+            } else {
+                // If no tools are available, skip this test
+                expect(true).toBe(true);
+            }
+        });
+    });
+}); 

package/tests/unit/add-ai-connections.test.js

@@ -0,0 +1,385 @@
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Unit tests for AI Connections functionality
+ */
+
+describe('add_ai_connections Tool', () => {
+    it('should properly handle memory nodes in LangChain workflows', () => {
+        // Mock workflow with agent, model, and memory nodes
+        const testWorkflow = {
+            name: "TestWorkflow",
+            nodes: [
+                {
+                    id: "agent-123",
+                    name: "AI Agent",
+                    type: "@n8n/n8n-nodes-langchain.agent",
+                    parameters: {}
+                },
+                {
+                    id: "model-456",
+                    name: "GPT-4",
+                    type: "@n8n/n8n-nodes-langchain.lmChatOpenAi",
+                    parameters: {}
+                },
+                {
+                    id: "memory-789",
+                    name: "Buffer Memory",
+                    type: "@n8n/n8n-nodes-langchain.memoryBufferWindow",
+                    parameters: {}
+                },
+                {
+                    id: "tool-101",
+                    name: "Web Search",
+                    type: "@n8n/n8n-nodes-langchain.toolWebSearch",
+                    parameters: {}
+                }
+            ],
+            connections: {}
+        };
+
+        // Mock the core add_ai_connections function from our implementation
+        function addAIConnections(workflow, params) {
+            const { agent_node_id, model_node_id, tool_node_ids, memory_node_id } = params;
+
+            // Find nodes
+            const agentNode = workflow.nodes.find(node => node.id === agent_node_id);
+            const modelNode = model_node_id ? workflow.nodes.find(node => node.id === model_node_id) : null;
+            const memoryNode = memory_node_id ? workflow.nodes.find(node => node.id === memory_node_id) : null;
+
+            const toolNodes = tool_node_ids?.length > 0
+                ? tool_node_ids.map(id => workflow.nodes.find(node => node.id === id)).filter(Boolean)
+                : [];
+
+            if (!agentNode) {
+                throw new Error("Agent node not found");
+            }
+
+            // Connect model to agent
+            if (modelNode) {
+                if (!workflow.connections[modelNode.name]) {
+                    workflow.connections[modelNode.name] = {};
+                }
+
+                if (!workflow.connections[modelNode.name]["ai_languageModel"]) {
+                    workflow.connections[modelNode.name]["ai_languageModel"] = [];
+                }
+
+                workflow.connections[modelNode.name]["ai_languageModel"].push([{
+                    node: agentNode.name,
+                    type: "ai_languageModel",
+                    index: 0
+                }]);
+            }
+
+            // Connect tools to agent
+            if (toolNodes.length > 0) {
+                toolNodes.forEach((toolNode, i) => {
+                    if (!workflow.connections[toolNode.name]) {
+                        workflow.connections[toolNode.name] = {};
+                    }
+
+                    if (!workflow.connections[toolNode.name]["ai_tool"]) {
+                        workflow.connections[toolNode.name]["ai_tool"] = [];
+                    }
+
+                    workflow.connections[toolNode.name]["ai_tool"].push([{
+                        node: agentNode.name,
+                        type: "ai_tool",
+                        index: 0
+                    }]);
+                });
+            }
+
+            // Connect memory to agent - this is the critical part we're testing
+            if (memoryNode) {
+                if (!workflow.connections[memoryNode.name]) {
+                    workflow.connections[memoryNode.name] = {};
+                }
+
+                if (!workflow.connections[memoryNode.name]["ai_memory"]) {
+                    workflow.connections[memoryNode.name]["ai_memory"] = [];
+                }
+
+                workflow.connections[memoryNode.name]["ai_memory"].push([{
+                    node: agentNode.name,
+                    type: "ai_memory",
+                    index: 0
+                }]);
+            }
+
+            return workflow;
+        }
+
+        // Run the function with our test parameters
+        const result = addAIConnections(testWorkflow, {
+            agent_node_id: "agent-123",
+            model_node_id: "model-456",
+            tool_node_ids: ["tool-101"],
+            memory_node_id: "memory-789"
+        });
+
+        // Verify all connections were created correctly
+
+        // 1. Check model connection
+        expect(result.connections["GPT-4"]).toBeDefined();
+        expect(result.connections["GPT-4"]["ai_languageModel"]).toBeDefined();
+        expect(result.connections["GPT-4"]["ai_languageModel"][0][0].node).toBe("AI Agent");
+
+        // 2. Check tool connection
+        expect(result.connections["Web Search"]).toBeDefined();
+        expect(result.connections["Web Search"]["ai_tool"]).toBeDefined();
+        expect(result.connections["Web Search"]["ai_tool"][0][0].node).toBe("AI Agent");
+
+        // 3. Check memory connection - this is the key test
+        expect(result.connections["Buffer Memory"]).toBeDefined();
+        expect(result.connections["Buffer Memory"]["ai_memory"]).toBeDefined();
+        expect(result.connections["Buffer Memory"]["ai_memory"][0][0].node).toBe("AI Agent");
+        expect(result.connections["Buffer Memory"]["ai_memory"][0][0].type).toBe("ai_memory");
+
+        // Verify no incorrect connection types were used
+        expect(result.connections["Buffer Memory"]["ai_tool"]).toBeUndefined();
+    });
+
+    it('should handle combinations of different node types', () => {
+        // Test workflow with just the core nodes
+        const testWorkflow = {
+            name: "TestWorkflow",
+            nodes: [
+                {
+                    id: "agent-123",
+                    name: "AI Agent",
+                    type: "@n8n/n8n-nodes-langchain.agent",
+                    parameters: {}
+                },
+                {
+                    id: "model-456",
+                    name: "GPT-4",
+                    type: "@n8n/n8n-nodes-langchain.lmChatOpenAi",
+                    parameters: {}
+                },
+                {
+                    id: "memory-789",
+                    name: "Buffer Memory",
+                    type: "@n8n/n8n-nodes-langchain.memoryBufferWindow",
+                    parameters: {}
+                }
+            ],
+            connections: {}
+        };
+
+        // Mock implementation of addAIConnections (same as above)
+        function addAIConnections(workflow, params) {
+            const { agent_node_id, model_node_id, tool_node_ids, memory_node_id } = params;
+
+            // Find nodes
+            const agentNode = workflow.nodes.find(node => node.id === agent_node_id);
+            const modelNode = model_node_id ? workflow.nodes.find(node => node.id === model_node_id) : null;
+            const memoryNode = memory_node_id ? workflow.nodes.find(node => node.id === memory_node_id) : null;
+
+            const toolNodes = tool_node_ids?.length > 0
+                ? tool_node_ids.map(id => workflow.nodes.find(node => node.id === id)).filter(Boolean)
+                : [];
+
+            if (!agentNode) {
+                throw new Error("Agent node not found");
+            }
+
+            // Connect model to agent
+            if (modelNode) {
+                if (!workflow.connections[modelNode.name]) {
+                    workflow.connections[modelNode.name] = {};
+                }
+
+                if (!workflow.connections[modelNode.name]["ai_languageModel"]) {
+                    workflow.connections[modelNode.name]["ai_languageModel"] = [];
+                }
+
+                workflow.connections[modelNode.name]["ai_languageModel"].push([{
+                    node: agentNode.name,
+                    type: "ai_languageModel",
+                    index: 0
+                }]);
+            }
+
+            // Connect tools to agent
+            if (toolNodes.length > 0) {
+                toolNodes.forEach((toolNode, i) => {
+                    if (!workflow.connections[toolNode.name]) {
+                        workflow.connections[toolNode.name] = {};
+                    }
+
+                    if (!workflow.connections[toolNode.name]["ai_tool"]) {
+                        workflow.connections[toolNode.name]["ai_tool"] = [];
+                    }
+
+                    workflow.connections[toolNode.name]["ai_tool"].push([{
+                        node: agentNode.name,
+                        type: "ai_tool",
+                        index: 0
+                    }]);
+                });
+            }
+
+            // Connect memory to agent
+            if (memoryNode) {
+                if (!workflow.connections[memoryNode.name]) {
+                    workflow.connections[memoryNode.name] = {};
+                }
+
+                if (!workflow.connections[memoryNode.name]["ai_memory"]) {
+                    workflow.connections[memoryNode.name]["ai_memory"] = [];
+                }
+
+                workflow.connections[memoryNode.name]["ai_memory"].push([{
+                    node: agentNode.name,
+                    type: "ai_memory",
+                    index: 0
+                }]);
+            }
+
+            return workflow;
+        }
+
+        // Test various combinations
+
+        // Case 1: Only model and memory, no tools
+        let result = addAIConnections({ ...testWorkflow, connections: {} }, {
+            agent_node_id: "agent-123",
+            model_node_id: "model-456",
+            memory_node_id: "memory-789"
+        });
+
+        expect(result.connections["GPT-4"]).toBeDefined();
+        expect(result.connections["GPT-4"]["ai_languageModel"]).toBeDefined();
+        expect(result.connections["Buffer Memory"]).toBeDefined();
+        expect(result.connections["Buffer Memory"]["ai_memory"]).toBeDefined();
+
+        // Case 2: Only memory, no model
+        result = addAIConnections({ ...testWorkflow, connections: {} }, {
+            agent_node_id: "agent-123",
+            memory_node_id: "memory-789"
+        });
+
+        expect(result.connections["GPT-4"]).toBeUndefined();
+        expect(result.connections["Buffer Memory"]).toBeDefined();
+        expect(result.connections["Buffer Memory"]["ai_memory"]).toBeDefined();
+
+        // Case 3: Only model, no memory
+        result = addAIConnections({ ...testWorkflow, connections: {} }, {
+            agent_node_id: "agent-123",
+            model_node_id: "model-456"
+        });
+
+        expect(result.connections["GPT-4"]).toBeDefined();
+        expect(result.connections["GPT-4"]["ai_languageModel"]).toBeDefined();
+        expect(result.connections["Buffer Memory"]).toBeUndefined();
+    });
+});
+
+describe('AI Connections', () => {
+    it('should add AI language model connections', () => {
+        const workflow = {
+            name: "Test Workflow",
+            nodes: [
+                { id: "agent1", name: "AI Agent", type: "agent" },
+                { id: "model1", name: "Language Model", type: "languageModel" }
+            ],
+            connections: {}
+        };
+
+        // Mock adding a language model connection
+        const addConnection = (workflow, sourceNodeName, targetNodeName, connectionType) => {
+            if (!workflow.connections[sourceNodeName]) {
+                workflow.connections[sourceNodeName] = {};
+            }
+            if (!workflow.connections[sourceNodeName][connectionType]) {
+                workflow.connections[sourceNodeName][connectionType] = [];
+            }
+            workflow.connections[sourceNodeName][connectionType].push([{
+                node: targetNodeName,
+                type: connectionType,
+                index: 0
+            }]);
+        };
+
+        addConnection(workflow, "Language Model", "AI Agent", "ai_languageModel");
+
+        expect(workflow.connections["Language Model"]).toBeDefined();
+        expect(workflow.connections["Language Model"]["ai_languageModel"]).toBeDefined();
+        expect(workflow.connections["Language Model"]["ai_languageModel"][0][0].node).toBe("AI Agent");
+    });
+
+    it('should add AI memory connections', () => {
+        const workflow = {
+            name: "Test Workflow",
+            nodes: [
+                { id: "agent1", name: "AI Agent", type: "agent" },
+                { id: "memory1", name: "Memory", type: "memory" }
+            ],
+            connections: {}
+        };
+
+        // Mock adding a memory connection
+        const addConnection = (workflow, sourceNodeName, targetNodeName, connectionType) => {
+            if (!workflow.connections[sourceNodeName]) {
+                workflow.connections[sourceNodeName] = {};
+            }
+            if (!workflow.connections[sourceNodeName][connectionType]) {
+                workflow.connections[sourceNodeName][connectionType] = [];
+            }
+            workflow.connections[sourceNodeName][connectionType].push([{
+                node: targetNodeName,
+                type: connectionType,
+                index: 0
+            }]);
+        };
+
+        addConnection(workflow, "Memory", "AI Agent", "ai_memory");
+
+        expect(workflow.connections["Memory"]).toBeDefined();
+        expect(workflow.connections["Memory"]["ai_memory"]).toBeDefined();
+        expect(workflow.connections["Memory"]["ai_memory"][0][0].node).toBe("AI Agent");
+    });
+
+    it('should handle multiple AI connections', () => {
+        const workflow = {
+            name: "Complex Workflow",
+            nodes: [
+                { id: "agent1", name: "AI Agent", type: "agent" },
+                { id: "model1", name: "Language Model", type: "languageModel" },
+                { id: "memory1", name: "Memory", type: "memory" },
+                { id: "tool1", name: "Tool", type: "tool" }
+            ],
+            connections: {}
+        };
+
+        // Add multiple connections
+        const connections = [
+            { source: "Language Model", target: "AI Agent", type: "ai_languageModel" },
+            { source: "Memory", target: "AI Agent", type: "ai_memory" },
+            { source: "Tool", target: "AI Agent", type: "ai_tool" }
+        ];
+
+        connections.forEach(conn => {
+            if (!workflow.connections[conn.source]) {
+                workflow.connections[conn.source] = {};
+            }
+            if (!workflow.connections[conn.source][conn.type]) {
+                workflow.connections[conn.source][conn.type] = [];
+            }
+            workflow.connections[conn.source][conn.type].push([{
+                node: conn.target,
+                type: conn.type,
+                index: 0
+            }]);
+        });
+
+        expect(Object.keys(workflow.connections)).toHaveLength(3);
+        expect(workflow.connections["Language Model"]["ai_languageModel"]).toBeDefined();
+        expect(workflow.connections["Memory"]["ai_memory"]).toBeDefined();
+        expect(workflow.connections["Tool"]["ai_tool"]).toBeDefined();
+    });
+});