n8n-workflow-builder-mcp 0.1.0

package/src/models/workflow.js

@@ -0,0 +1,229 @@
+/**
+ * Workflow Model
+ * 
+ * Data structure and validation for n8n workflows.
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+const { v4: uuidv4 } = require('uuid');
+const { logger } = require('../utils/logger');
+
+// Basic workflow schema (to be expanded in future tasks)
+const workflowSchema = {
+    type: 'object',
+    properties: {
+        id: { type: 'string' },
+        name: { type: 'string' },
+        nodes: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    type: { type: 'string' },
+                    position: {
+                        type: 'object',
+                        properties: {
+                            x: { type: 'number' },
+                            y: { type: 'number' }
+                        },
+                        required: ['x', 'y']
+                    },
+                    parameters: { type: 'object' }
+                },
+                required: ['id', 'type', 'position']
+            }
+        },
+        connections: {
+            type: 'object',
+            additionalProperties: {
+                type: 'object',
+                additionalProperties: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            node: { type: 'string' },
+                            type: { type: 'string' },
+                            index: { type: 'integer' }
+                        },
+                        required: ['node', 'type', 'index']
+                    }
+                }
+            }
+        },
+        active: { type: 'boolean' },
+        settings: { type: 'object' },
+        createdAt: { type: 'string', format: 'date-time' },
+        updatedAt: { type: 'string', format: 'date-time' },
+        versionId: { type: 'string' }
+    },
+    required: ['id', 'name', 'nodes', 'connections']
+};
+
+// Storage directory for workflow files
+const WORKFLOWS_DIR = path.join(process.cwd(), 'workflow_nodes');
+
+/**
+ * Ensure the workflows directory exists
+ */
+const ensureWorkflowsDir = async () => {
+    try {
+        await fs.mkdir(WORKFLOWS_DIR, { recursive: true });
+    } catch (error) {
+        logger.error('Failed to create workflows directory', { error: error.message });
+        throw error;
+    }
+};
+
+// Ensure directory exists when module is loaded
+ensureWorkflowsDir().catch(err => {
+    logger.error('Critical error ensuring workflows directory', { error: err.message });
+});
+
+/**
+ * Generate a unique workflow ID
+ * 
+ * @returns {string} UUID for the workflow
+ */
+const generateWorkflowId = () => {
+    return uuidv4();
+};
+
+/**
+ * Save a workflow to the filesystem
+ * 
+ * @param {string} id - Workflow ID
+ * @param {Object} workflow - Workflow data to save
+ * @returns {Promise<Object>} - Saved workflow data
+ */
+const saveWorkflow = async (id, workflow) => {
+    try {
+        const filePath = path.join(WORKFLOWS_DIR, `${id}.json`);
+        await fs.writeFile(filePath, JSON.stringify(workflow, null, 2));
+        logger.info(`Workflow saved: ${id}`);
+        return workflow;
+    } catch (error) {
+        logger.error(`Failed to save workflow: ${id}`, { error: error.message });
+        throw new Error(`Failed to save workflow: ${error.message}`);
+    }
+};
+
+/**
+ * Get a workflow by ID
+ * 
+ * @param {string} id - Workflow ID
+ * @returns {Promise<Object>} - Workflow data
+ */
+const getWorkflow = async (id) => {
+    try {
+        const filePath = path.join(WORKFLOWS_DIR, `${id}.json`);
+        const data = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(data);
+    } catch (error) {
+        logger.error(`Failed to get workflow: ${id}`, { error: error.message });
+        throw new Error(`Workflow not found: ${id}`);
+    }
+};
+
+/**
+ * List all workflows
+ * 
+ * @param {Object} options - List options (limit, offset)
+ * @returns {Promise<Array>} - Array of workflow summaries
+ */
+const listWorkflows = async ({ limit = 10, offset = 0 } = {}) => {
+    try {
+        const files = await fs.readdir(WORKFLOWS_DIR);
+        const workflowFiles = files.filter(file => file.endsWith('.json'));
+
+        // Apply pagination
+        const paginatedFiles = workflowFiles.slice(offset, offset + limit);
+
+        // Read each workflow file for summary data
+        const workflows = await Promise.all(
+            paginatedFiles.map(async (file) => {
+                try {
+                    const data = await fs.readFile(path.join(WORKFLOWS_DIR, file), 'utf8');
+                    const workflow = JSON.parse(data);
+
+                    // Return just the summary data
+                    return {
+                        id: workflow.id,
+                        name: workflow.name,
+                        active: workflow.active || false,
+                        nodeCount: workflow.nodes.length,
+                        createdAt: workflow.createdAt,
+                        updatedAt: workflow.updatedAt
+                    };
+                } catch (error) {
+                    logger.error(`Error reading workflow file: ${file}`, { error: error.message });
+                    return null;
+                }
+            })
+        );
+
+        // Filter out any null entries from failed reads
+        return workflows.filter(workflow => workflow !== null);
+    } catch (error) {
+        logger.error('Failed to list workflows', { error: error.message });
+        throw new Error(`Failed to list workflows: ${error.message}`);
+    }
+};
+
+// Workflow model with unified methods
+const WorkflowModel = {
+    // Validate a workflow object against the schema
+    validate: (workflow) => {
+        // To be implemented with Ajv validation in future task
+        return true;
+    },
+
+    // Create a new workflow
+    create: async (workflowData) => {
+        const id = workflowData.id || generateWorkflowId();
+        const timestamp = new Date().toISOString();
+
+        const workflow = {
+            id,
+            name: workflowData.name || 'Untitled Workflow',
+            description: workflowData.description || '',
+            active: workflowData.active !== undefined ? workflowData.active : false,
+            nodes: workflowData.nodes || [],
+            connections: workflowData.connections || {},
+            settings: workflowData.settings || {
+                saveExecutionProgress: true,
+                saveManualExecutions: true,
+                saveDataErrorExecution: "all",
+                saveDataSuccessExecution: "all",
+                executionTimeout: 3600,
+                timezone: "UTC"
+            },
+            tags: workflowData.tags || [],
+            createdAt: workflowData.createdAt || timestamp,
+            updatedAt: workflowData.updatedAt || timestamp,
+            versionId: workflowData.versionId || generateWorkflowId()
+        };
+
+        return saveWorkflow(id, workflow);
+    },
+
+    // Get a workflow by ID
+    get: async (id) => {
+        return getWorkflow(id);
+    },
+
+    // List workflows with pagination
+    list: async (options) => {
+        return listWorkflows(options);
+    },
+
+    // Generate a unique workflow ID
+    generateId: generateWorkflowId,
+};
+
+module.exports = {
+    workflowSchema,
+    WorkflowModel
+}; 

package/src/routes/toolDefinitions.js

@@ -0,0 +1,62 @@
+/**
+ * Tool Definition Routes
+ * 
+ * Implements the MCP tool definition endpoint that returns proper JSON Schema for all tools.
+ */
+
+const express = require('express');
+const router = express.Router();
+const { authenticate } = require('../middleware/auth');
+const { logMcpRequest } = require('../middleware/logging');
+const { createSuccessResponse, createErrorResponse } = require('../utils/mcp');
+const { getAllToolDefinitions } = require('../tools/toolDefinitions');
+const { logger } = require('../utils/logger');
+
+/**
+ * GET /tools
+ * 
+ * Returns standardized MCP tool definitions for all available tools
+ * Compliant with latest MCP protocol specification
+ */
+router.post('/tools', authenticate, logMcpRequest, (req, res) => {
+    try {
+        // Get all tool definitions
+        const definitions = getAllToolDefinitions();
+
+        // Format the definitions for MCP response
+        const toolDefinitions = Object.keys(definitions).map(key => {
+            const tool = definitions[key];
+            return {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.input_schema,
+                returns: tool.output_schema
+            };
+        });
+
+        // Create success response
+        const response = createSuccessResponse({ tools: toolDefinitions });
+
+        // Log success
+        logger.debug(`Serving ${toolDefinitions.length} tool definitions through MCP endpoint`);
+
+        // Return the response
+        res.status(response.status).json(response.data);
+    } catch (error) {
+        // Log error
+        logger.error(`Error generating tool definitions: ${error.message}`);
+        logger.debug(error.stack);
+
+        // Create error response
+        const errorResponse = createErrorResponse(
+            'Failed to generate tool definitions',
+            'TOOL_DEFINITION_ERROR',
+            500
+        );
+
+        // Return error response
+        res.status(errorResponse.status).json({ error: errorResponse.error });
+    }
+});
+
+module.exports = router; 

package/src/routes/toolExecution.js

@@ -0,0 +1,79 @@
+/**
+ * Tool Execution Routes
+ * 
+ * Implements the MCP tool execution endpoint that receives requests to execute tools.
+ */
+
+const express = require('express');
+const router = express.Router();
+const { authenticate } = require('../middleware/auth');
+const { logMcpRequest } = require('../middleware/logging');
+const { validateToolRequest } = require('../middleware/mcp');
+const { createSuccessResponse, createErrorResponse, parseToolName } = require('../utils/mcp');
+const { toolDefinitions } = require('../tools/toolDefinitions');
+const { logger } = require('../utils/logger');
+
+/**
+ * POST /execute
+ * 
+ * Executes an MCP tool
+ */
+router.post('/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 });
+        }
+
+        // Log tool execution attempt
+        logger.info(`Executing tool: ${name}`, {
+            tool: name,
+            hasParameters: Object.keys(parameters || {}).length > 0
+        });
+
+        // Execute the tool
+        let result;
+        try {
+            result = await tool.execute(parameters || {});
+        } catch (toolError) {
+            // Handle execution errors from the tool
+            logger.error(`Tool execution error: ${toolError.message}`);
+
+            const errorResponse = createErrorResponse(
+                toolError.message || 'Tool execution failed',
+                'TOOL_EXECUTION_ERROR',
+                500
+            );
+            return res.status(errorResponse.status).json({ error: errorResponse.error });
+        }
+
+        // Log successful execution
+        logger.info(`Tool executed successfully: ${name}`);
+
+        // Return successful result
+        const response = createSuccessResponse(result);
+        res.status(response.status).json(response.data);
+    } catch (error) {
+        // Handle unexpected errors
+        logger.error(`Unexpected error during tool execution: ${error.message}`);
+        logger.error(error.stack);
+
+        const errorResponse = createErrorResponse(
+            'An unexpected error occurred',
+            'INTERNAL_SERVER_ERROR',
+            500
+        );
+        res.status(errorResponse.status).json({ error: errorResponse.error });
+    }
+});
+
+module.exports = router; 

package/src/tools/__index.js

@@ -0,0 +1,242 @@
+/**
+ * MCP Tools Index
+ * 
+ * This file exports all MCP tools used to interact with n8n workflows.
+ */
+
+const { createTool } = require('../models/tool');
+const { logger } = require('../utils/logger');
+const {
+    storeCredential,
+    getCredential,
+    updateCredential,
+    deleteCredential,
+    listCredentials,
+    rotateEncryptionKey
+} = require('../models/credential');
+const { searchNodesTool } = require('./nodeDiscovery');
+const { createWorkflowTool } = require('./workflowCreation');
+const workflowStorageTools = require('./workflowStorage');
+const n8nIntegrationTools = require('./n8nIntegration');
+const { generateWorkflowTool } = require('./workflowGenerator');
+const { addNodeTool, replaceNodeTool } = require('./nodeManagement');
+const {
+    createConnectionTool,
+    removeConnectionTool,
+    removeNodeConnectionsTool
+} = require('./connectionManagement');
+const { testWorkflowTool, getExecutionStatusTool } = require('./workflowTesting');
+
+// Placeholder implementations
+const placeholderExecute = async () => {
+    throw new Error('Tool not yet implemented');
+};
+
+// Workflow management tools
+const workflowTools = {
+    create: createWorkflowTool,
+    save: workflowStorageTools.saveWorkflowTool,
+    load: workflowStorageTools.loadWorkflowTool,
+    list: workflowStorageTools.listWorkflowsTool,
+    delete: workflowStorageTools.deleteWorkflowTool,
+    generate: generateWorkflowTool
+};
+
+// n8n integration tools
+const n8nTools = {
+    deploy: n8nIntegrationTools.deployWorkflowTool,
+    activate: n8nIntegrationTools.activateWorkflowTool,
+    get: n8nIntegrationTools.getWorkflowTool,
+    checkExecution: n8nIntegrationTools.checkExecutionStatusTool,
+    list: n8nIntegrationTools.listWorkflowsTool
+};
+
+// Node management tools
+const nodeTools = {
+    search: searchNodesTool,
+    add: addNodeTool,
+    replace: replaceNodeTool
+};
+
+// Connection management tools
+const connectionTools = {
+    create: createConnectionTool,
+    remove: removeConnectionTool,
+    removeAll: removeNodeConnectionsTool
+};
+
+// Workflow testing tools
+const testingTools = {
+    test: testWorkflowTool,
+    status: getExecutionStatusTool
+};
+
+// Credential management tools
+const credentialTools = {
+    store: createTool(
+        'Securely store a credential',
+        {
+            name: {
+                type: 'string',
+                description: 'Unique name for the credential'
+            },
+            data: {
+                type: 'object',
+                description: 'Credential data to encrypt and store'
+            },
+            type: {
+                type: 'string',
+                description: 'Type of credential (api, oauth, database, generic)',
+                optional: true
+            }
+        },
+        async (params) => {
+            try {
+                const result = await storeCredential(params.name, params.data, {
+                    type: params.type || 'generic'
+                });
+                return result;
+            } catch (error) {
+                logger.error('Error storing credential', { error: error.message });
+                throw new Error(`Failed to store credential: ${error.message}`);
+            }
+        }
+    ),
+
+    get: createTool(
+        'Retrieve a stored credential',
+        {
+            name: {
+                type: 'string',
+                description: 'Name of the credential to retrieve'
+            }
+        },
+        async (params) => {
+            try {
+                const credential = await getCredential(params.name);
+                return credential;
+            } catch (error) {
+                logger.error('Error retrieving credential', { error: error.message });
+                throw new Error(`Failed to retrieve credential: ${error.message}`);
+            }
+        }
+    ),
+
+    update: createTool(
+        'Update a stored credential',
+        {
+            name: {
+                type: 'string',
+                description: 'Name of the credential to update'
+            },
+            data: {
+                type: 'object',
+                description: 'New credential data'
+            },
+            type: {
+                type: 'string',
+                description: 'Type of credential (api, oauth, database, generic)',
+                optional: true
+            }
+        },
+        async (params) => {
+            try {
+                const result = await updateCredential(params.name, params.data, {
+                    type: params.type
+                });
+                return result;
+            } catch (error) {
+                logger.error('Error updating credential', { error: error.message });
+                throw new Error(`Failed to update credential: ${error.message}`);
+            }
+        }
+    ),
+
+    delete: createTool(
+        'Delete a stored credential',
+        {
+            name: {
+                type: 'string',
+                description: 'Name of the credential to delete'
+            }
+        },
+        async (params) => {
+            try {
+                const result = await deleteCredential(params.name);
+                return result;
+            } catch (error) {
+                logger.error('Error deleting credential', { error: error.message });
+                throw new Error(`Failed to delete credential: ${error.message}`);
+            }
+        }
+    ),
+
+    list: createTool(
+        'List all stored credentials (without sensitive data)',
+        {},
+        async () => {
+            try {
+                const credentials = await listCredentials();
+                return { credentials };
+            } catch (error) {
+                logger.error('Error listing credentials', { error: error.message });
+                throw new Error(`Failed to list credentials: ${error.message}`);
+            }
+        }
+    ),
+
+    rotateKey: createTool(
+        'Rotate the encryption key for all credentials',
+        {
+            newKeyId: {
+                type: 'string',
+                description: 'New key identifier for key rotation',
+                optional: true
+            }
+        },
+        async (params) => {
+            try {
+                const result = await rotateEncryptionKey(params.newKeyId);
+                return result;
+            } catch (error) {
+                logger.error('Error rotating encryption key', { error: error.message });
+                throw new Error(`Failed to rotate encryption key: ${error.message}`);
+            }
+        }
+    )
+};
+
+// Log available tools at startup
+const logAvailableTools = () => {
+    // Count tools by category instead of logging each one individually
+    const toolCounts = Object.entries({
+        workflow: workflowTools,
+        n8n: n8nTools,
+        node: nodeTools,
+        connection: connectionTools,
+        test: testingTools,
+        credential: credentialTools
+    }).reduce((counts, [category, tools]) => {
+        counts[category] = Object.keys(tools).length;
+        return counts;
+    }, {});
+
+    logger.info(`Tool categories initialized: ${Object.entries(toolCounts)
+        .map(([category, count]) => `${category} (${count})`)
+        .join(', ')}`);
+};
+
+// Schedule logging on next tick to not block module loading
+process.nextTick(logAvailableTools);
+
+// Export all tools grouped by category
+const tools = {
+    workflow: workflowTools,
+    n8n: n8nTools,
+    node: nodeTools,
+    connection: connectionTools,
+    test: testingTools,
+    credential: credentialTools
+};
+
+module.exports = tools;