n8n-workflow-builder-mcp 0.1.0

package/src/tools/workflowCreation.js

@@ -0,0 +1,100 @@
+/**
+ * Workflow Creation Tools
+ * 
+ * Tools for creating and modifying workflows
+ */
+
+const { v4: uuidv4 } = require('uuid');
+const path = require('path');
+const fs = require('fs');
+const { logger } = require('../utils/logger');
+const { logSecurityEvent } = require('../utils/securityLogger');
+const { workflowStorage } = require('../models/storage');
+
+// Constants
+const DEFAULT_WORKFLOW_DIR = process.env.WORKFLOW_DIR || path.join(process.cwd(), 'workflow_data');
+
+// Create workflow directory if it doesn't exist
+if (!fs.existsSync(DEFAULT_WORKFLOW_DIR)) {
+    fs.mkdirSync(DEFAULT_WORKFLOW_DIR, { recursive: true });
+    logger.info(`Created workflow directory: ${DEFAULT_WORKFLOW_DIR}`);
+}
+
+/**
+ * Create a new workflow
+ * 
+ * @param {Object} params - Parameters for creating workflow
+ * @param {string} params.name - Name of the workflow
+ * @param {string} [params.workflow_filename] - Custom filename for the workflow
+ * @param {string} [params.description] - Description of the workflow
+ * @param {boolean} [params.active] - Whether the workflow is active
+ * @param {Object} [params.settings] - Custom workflow settings
+ * @param {string} [params.userId] - User ID for security logging
+ * @returns {Object} Created workflow data and file path
+ */
+const createWorkflowExecute = async (params) => {
+    const { name, workflow_filename, description = '', active = false, settings = {}, userId } = params;
+
+    // Security logging
+    logSecurityEvent({
+        level: 'info',
+        eventType: 'workflow_create',
+        userId: userId || 'anonymous',
+        details: {
+            name,
+            active,
+            workflow_filename
+        }
+    });
+
+    // Generate a unique ID for the workflow
+    const workflowId = uuidv4();
+
+    // Create basic workflow structure
+    const workflow = {
+        id: workflowId,
+        name,
+        description,
+        active,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        settings: {
+            saveExecutionProgress: true,
+            saveManualExecutions: true,
+            saveDataErrorExecution: 'all',
+            saveDataSuccessExecution: 'all',
+            executionTimeout: 3600,
+            ...settings
+        },
+        nodes: [],
+        connections: {},
+        pinData: {},
+        staticData: null,
+        tags: []
+    };
+
+    // Determine the file path
+    let filePath;
+    if (workflow_filename) {
+        // Ensure filename ends with .json
+        const filename = workflow_filename.endsWith('.json') ? workflow_filename : `${workflow_filename}.json`;
+        filePath = path.join(DEFAULT_WORKFLOW_DIR, filename);
+    } else {
+        filePath = path.join(DEFAULT_WORKFLOW_DIR, `${workflowId}.json`);
+    }
+
+    // Save the workflow
+    await workflowStorage.saveWorkflow(workflowId, workflow, filePath);
+
+    logger.info(`Created new workflow: ${name} (${workflowId}) at ${filePath}`);
+
+    return {
+        workflowId,
+        workflowData: workflow,
+        filePath
+    };
+};
+
+module.exports = {
+    createWorkflowExecute
+}; 

package/src/tools/workflowGenerator.js

@@ -0,0 +1,152 @@
+/**
+ * Workflow Generator Tool
+ * 
+ * Converts natural language descriptions into complete n8n workflow JSON.
+ * Uses LLM to generate nodes and connections based on the workflow description.
+ */
+
+const { createTool } = require('../models/tool');
+const { logger } = require('../utils/logger');
+const fs = require('fs').promises;
+const path = require('path');
+const config = require('../../config/default');
+const { workflowStorage } = require('../models/storage');
+const { logDataAccess } = require('../utils/securityLogger');
+const { generateWorkflow } = require('../models/llmService');
+
+/**
+ * Generate an n8n workflow JSON based on a natural language description
+ * 
+ * @param {Object} params - Tool parameters
+ * @returns {Promise<Object>} Generated workflow data and file path
+ */
+const generateWorkflowExecute = async (params) => {
+    try {
+        const { description, name, savePath, userId, llmProvider, copyToClipboard } = params;
+
+        logger.info('Generating workflow from description', {
+            name: name || 'Unnamed Workflow',
+            descriptionLength: description.length,
+            llmProvider: llmProvider || 'default'
+        });
+
+        // Create workflow structure
+        const workflow = {
+            name: name || `Generated Workflow ${new Date().toISOString().split('T')[0]}`,
+            active: false,
+            nodes: [],
+            connections: {},
+            settings: {
+                executionOrder: 'v1', // Standard n8n execution order
+                saveExecutionProgress: true,
+                saveManualExecutions: true,
+                saveDataErrorExecution: 'all',
+                saveDataSuccessExecution: 'all',
+                callerPolicy: 'workflowsFromSameOwner',
+                errorWorkflow: ''
+            },
+            tags: [],
+            pinData: {},
+            id: `generated-workflow-${Date.now()}`,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString()
+        };
+
+        // Setup LLM options
+        const llmOptions = {};
+        if (llmProvider) {
+            llmOptions.provider = llmProvider;
+        }
+
+        // Process description to generate nodes using LLM
+        const generatedNodes = await generateWorkflow(description, llmOptions);
+        workflow.nodes = generatedNodes.nodes;
+        workflow.connections = generatedNodes.connections;
+
+        // Add relevant tags based on the workflow purpose
+        if (description.toLowerCase().includes('http') || description.toLowerCase().includes('api')) {
+            workflow.tags.push({ name: 'API' });
+        }
+        if (description.toLowerCase().includes('automat')) {
+            workflow.tags.push({ name: 'Automation' });
+        }
+
+        // Save workflow to file if path is provided
+        let filePath;
+        if (savePath) {
+            filePath = savePath;
+        } else {
+            // Use default storage location
+            filePath = path.join(config.storage.workflowsPath, `${workflow.id}.json`);
+        }
+
+        await workflowStorage.saveWorkflow(workflow.id, workflow, filePath);
+
+        // Log the operation
+        logDataAccess({
+            success: true,
+            userId: userId || 'anonymous',
+            dataType: 'workflow',
+            action: 'generate',
+            resourceId: workflow.id,
+            details: { nodeCount: workflow.nodes.length }
+        });
+
+        return {
+            success: true,
+            workflow,
+            filePath,
+            json: JSON.stringify(workflow, null, 2), // Pretty-printed JSON for easy copying
+            message: `Workflow generated successfully from description and saved to ${filePath}`
+        };
+    } catch (error) {
+        logger.error('Failed to generate workflow', { error: error.message });
+
+        // Log the failed operation
+        logDataAccess({
+            success: false,
+            userId: params.userId || 'anonymous',
+            dataType: 'workflow',
+            action: 'generate',
+            reason: error.message
+        });
+
+        throw new Error(`Failed to generate workflow: ${error.message}`);
+    }
+};
+
+// Define the generate workflow tool
+const generateWorkflowTool = createTool(
+    'Generate a complete n8n workflow from a natural language description',
+    {
+        description: {
+            type: 'string',
+            description: 'Natural language description of the workflow to generate'
+        },
+        name: {
+            type: 'string',
+            description: 'Name for the generated workflow',
+            optional: true
+        },
+        savePath: {
+            type: 'string',
+            description: 'Path where the workflow JSON file should be saved',
+            optional: true
+        },
+        llmProvider: {
+            type: 'string',
+            description: 'LLM provider to use (openai, anthropic)',
+            optional: true
+        },
+        userId: {
+            type: 'string',
+            description: 'User identifier for security logging',
+            optional: true
+        }
+    },
+    generateWorkflowExecute
+);
+
+module.exports = {
+    generateWorkflowTool
+}; 

package/src/tools/workflowStorage.js

@@ -0,0 +1,113 @@
+/**
+ * Workflow Storage Tools
+ * 
+ * Tools for saving, loading, and managing workflow files
+ */
+
+const { v4: uuidv4 } = require('uuid');
+const { logger } = require('../utils/logger');
+
+/**
+ * Save a workflow to storage
+ * 
+ * @param {Object} params - Save parameters
+ * @param {string} params.workflowId - ID of the workflow to save
+ * @param {Object} params.workflowData - Workflow data to save
+ * @returns {Object} Save operation result
+ */
+const saveWorkflowExecute = async (params) => {
+    const { workflowId, workflowData } = params;
+
+    logger.info(`Saving workflow ${workflowId}`);
+
+    // Mock implementation
+    return {
+        success: true,
+        workflowId,
+        filePath: `/path/to/workflows/${workflowId}.json`
+    };
+};
+
+/**
+ * Load a workflow from storage
+ * 
+ * @param {Object} params - Load parameters
+ * @param {string} params.workflowId - ID of the workflow to load
+ * @returns {Object} Load operation result with workflow data
+ */
+const loadWorkflowExecute = async (params) => {
+    const { workflowId } = params;
+
+    logger.info(`Loading workflow ${workflowId}`);
+
+    // Mock implementation
+    return {
+        workflowId,
+        workflowData: {
+            id: workflowId,
+            name: 'Mock Workflow',
+            nodes: [],
+            connections: {}
+        }
+    };
+};
+
+/**
+ * List available workflows
+ * 
+ * @param {Object} params - List parameters
+ * @param {number} [params.limit] - Maximum number of workflows to return
+ * @param {number} [params.offset] - Number of workflows to skip
+ * @returns {Object} List of workflows
+ */
+const listWorkflowsExecute = async (params) => {
+    const { limit = 10, offset = 0 } = params;
+
+    logger.info(`Listing workflows (limit: ${limit}, offset: ${offset})`);
+
+    // Mock implementation
+    return {
+        workflows: [
+            {
+                id: 'wf1',
+                name: 'Mock Workflow 1',
+                path: '/path/to/workflows/wf1.json',
+                lastModified: new Date().toISOString()
+            },
+            {
+                id: 'wf2',
+                name: 'Mock Workflow 2',
+                path: '/path/to/workflows/wf2.json',
+                lastModified: new Date().toISOString()
+            }
+        ],
+        total: 2
+    };
+};
+
+/**
+ * Delete a workflow
+ * 
+ * @param {Object} params - Delete parameters
+ * @param {string} params.workflowId - ID of the workflow to delete
+ * @returns {Object} Delete operation result
+ */
+const deleteWorkflowExecute = async (params) => {
+    const { workflowId } = params;
+
+    logger.info(`Deleting workflow ${workflowId}`);
+
+    // Mock implementation
+    return {
+        success: true,
+        workflowId,
+        deletedPath: `/path/to/workflows/${workflowId}.json`
+    };
+};
+
+module.exports = {
+    saveWorkflowExecute,
+    loadWorkflowExecute,
+    listWorkflowsExecute,
+    deleteWorkflowExecute
+}; 

package/src/tools/workflowTesting.js

@@ -0,0 +1,285 @@
+/**
+ * Workflow Testing Tools
+ * 
+ * MCP tools for testing workflow execution and returning results.
+ */
+
+const { createTool } = require('../models/tool');
+const { logger } = require('../utils/logger');
+const { logDataAccess } = require('../utils/securityLogger');
+const { workflowStorage } = require('../models/storage');
+const config = require('../../config/default');
+const fetch = require('node-fetch');
+const { getIntegrationType } = require('../models/n8nIntegration');
+const AbortController = require('abort-controller');
+
+/**
+ * Execute a workflow with test data and return the results
+ * 
+ * @param {Object} params - The execution parameters
+ * @returns {Promise<Object>} The execution results
+ */
+const executeWorkflow = async (params) => {
+    const { workflowId, testData, timeout = 60000 } = params;
+    const integrationType = getIntegrationType();
+
+    try {
+        // Load workflow
+        const workflow = await workflowStorage.loadWorkflow(workflowId);
+        if (!workflow) {
+            throw new Error(`Workflow with ID ${workflowId} not found`);
+        }
+
+        logger.info('Executing workflow test', {
+            workflowId,
+            integrationType,
+            hasTestData: !!testData
+        });
+
+        if (integrationType === 'api') {
+            // Create abort controller for timeout handling
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+            try {
+                // Execute via n8n API
+                const response = await fetch(`${config.n8n.apiUrl}workflows/${workflowId}/execute`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-N8N-API-KEY': config.n8n.apiKey
+                    },
+                    body: JSON.stringify({ data: testData || {} }),
+                    signal: controller.signal
+                });
+
+                // Clear the timeout since the request completed
+                clearTimeout(timeoutId);
+
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({}));
+                    logger.error('n8n API error during workflow execution', {
+                        status: response.status,
+                        error: errorData
+                    });
+                    throw new Error(`Failed to execute workflow: ${response.status} ${response.statusText}`);
+                }
+
+                const result = await response.json();
+
+                // Log successful execution
+                logDataAccess({
+                    success: true,
+                    dataType: 'workflow',
+                    action: 'execute',
+                    resourceId: workflowId,
+                    details: { integrationType, executionId: result.executionId || 'unknown' }
+                });
+
+                return {
+                    success: true,
+                    executionId: result.executionId,
+                    data: result.data,
+                    logs: result.logs || [],
+                    executionTime: result.executionTime || null,
+                    status: result.status || 'completed'
+                };
+            } catch (error) {
+                clearTimeout(timeoutId);
+
+                if (error.name === 'AbortError') {
+                    // Handle timeout error
+                    logger.error('Workflow execution timed out', { workflowId, timeout });
+
+                    // Log timeout
+                    logDataAccess({
+                        success: false,
+                        dataType: 'workflow',
+                        action: 'execute',
+                        resourceId: workflowId,
+                        reason: `Execution timed out after ${timeout}ms`
+                    });
+
+                    throw new Error(`Workflow execution timed out after ${timeout}ms`);
+                }
+
+                throw error;
+            }
+        } else if (integrationType === 'filesystem') {
+            // For filesystem integration, we don't have a built-in way to execute
+            logger.warn('Workflow execution not supported for filesystem integration', { workflowId });
+
+            // Log the limitation
+            logDataAccess({
+                success: false,
+                dataType: 'workflow',
+                action: 'execute',
+                resourceId: workflowId,
+                reason: 'Direct workflow execution not supported for filesystem integration'
+            });
+
+            throw new Error('Direct workflow execution not supported for filesystem integration. Please use the n8n API integration type.');
+        } else {
+            throw new Error('Invalid integration type');
+        }
+    } catch (error) {
+        logger.error('Failed to execute workflow', {
+            workflowId,
+            error: error.message
+        });
+
+        // Log the failed operation (if not already logged)
+        if (error.message !== 'Direct workflow execution not supported for filesystem integration. Please use the n8n API integration type.') {
+            logDataAccess({
+                success: false,
+                dataType: 'workflow',
+                action: 'execute',
+                resourceId: workflowId,
+                reason: error.message
+            });
+        }
+
+        throw new Error(`Failed to execute workflow: ${error.message}`);
+    }
+};
+
+/**
+ * Get the execution status of a workflow execution
+ * 
+ * @param {Object} params - The status parameters
+ * @returns {Promise<Object>} The execution status
+ */
+const getExecutionStatus = async (params) => {
+    const { executionId } = params;
+    const integrationType = getIntegrationType();
+
+    try {
+        logger.info('Getting workflow execution status', {
+            executionId,
+            integrationType
+        });
+
+        if (integrationType === 'api') {
+            // Execute via n8n API
+            const response = await fetch(`${config.n8n.apiUrl}executions/${executionId}`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-N8N-API-KEY': config.n8n.apiKey
+                }
+            });
+
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                logger.error('n8n API error during execution status check', {
+                    status: response.status,
+                    error: errorData
+                });
+                throw new Error(`Failed to get execution status: ${response.status} ${response.statusText}`);
+            }
+
+            const result = await response.json();
+
+            // Log successful status check
+            logDataAccess({
+                success: true,
+                dataType: 'execution',
+                action: 'get-status',
+                resourceId: executionId
+            });
+
+            return {
+                success: true,
+                executionId: result.id,
+                status: result.status,
+                data: result.data,
+                startedAt: result.startedAt,
+                finishedAt: result.finishedAt,
+                workflowId: result.workflowId,
+                mode: result.mode
+            };
+        } else if (integrationType === 'filesystem') {
+            // For filesystem integration, we don't have a built-in way to check execution status
+            logger.warn('Execution status check not supported for filesystem integration', { executionId });
+
+            // Log the limitation
+            logDataAccess({
+                success: false,
+                dataType: 'execution',
+                action: 'get-status',
+                resourceId: executionId,
+                reason: 'Execution status check not supported for filesystem integration'
+            });
+
+            throw new Error('Execution status check not supported for filesystem integration. Please use the n8n API integration type.');
+        } else {
+            throw new Error('Invalid integration type');
+        }
+    } catch (error) {
+        logger.error('Failed to get execution status', {
+            executionId,
+            error: error.message
+        });
+
+        // Log the failed operation (if not already logged)
+        if (error.message !== 'Execution status check not supported for filesystem integration. Please use the n8n API integration type.') {
+            logDataAccess({
+                success: false,
+                dataType: 'execution',
+                action: 'get-status',
+                resourceId: executionId,
+                reason: error.message
+            });
+        }
+
+        throw new Error(`Failed to get execution status: ${error.message}`);
+    }
+};
+
+// Create and export the MCP tools
+const testWorkflowTool = createTool(
+    'Test a workflow by executing it and returning results',
+    {
+        workflowId: {
+            type: 'string',
+            description: 'ID of the workflow to execute'
+        },
+        testData: {
+            type: 'object',
+            description: 'Test data to use for the execution',
+            optional: true
+        },
+        timeout: {
+            type: 'number',
+            description: 'Timeout in milliseconds for the execution (default: 60000)',
+            optional: true
+        },
+        userId: {
+            type: 'string',
+            description: 'ID of the user executing the workflow for logging purposes',
+            optional: true
+        }
+    },
+    executeWorkflow
+);
+
+const getExecutionStatusTool = createTool(
+    'Get the status of a workflow execution',
+    {
+        executionId: {
+            type: 'string',
+            description: 'ID of the execution to check'
+        },
+        userId: {
+            type: 'string',
+            description: 'ID of the user checking the execution for logging purposes',
+            optional: true
+        }
+    },
+    getExecutionStatus
+);
+
+module.exports = {
+    testWorkflowTool,
+    getExecutionStatusTool
+};