n8n-workflow-builder-mcp 0.1.0

package/src/models/storage.js

@@ -0,0 +1,196 @@
+/**
+ * Workflow Storage Module
+ * 
+ * Provides filesystem-based storage capabilities for n8n workflows,
+ * allowing workflows to be saved and retrieved from specified locations.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+const { logger } = require('../utils/logger');
+const config = require('../../config/default');
+
+// Default storage directory for workflows from config for backward compatibility only
+const DEFAULT_WORKFLOWS_DIR = path.resolve(process.cwd(), config.storage.workflowsPath);
+
+/**
+ * Ensure a directory exists
+ * 
+ * @param {string} dirPath - Directory path to ensure exists
+ */
+const ensureDirectoryExists = async (dirPath) => {
+    try {
+        await fs.mkdir(dirPath, { recursive: true });
+        return true;
+    } catch (error) {
+        logger.error('Failed to create directory', { path: dirPath, error: error.message });
+        throw error;
+    }
+};
+
+// Ensure the default directory exists for backward compatibility
+ensureDirectoryExists(DEFAULT_WORKFLOWS_DIR).catch(err => {
+    logger.error('Critical error ensuring directory', { error: err.message });
+});
+
+/**
+ * Workflow Storage Service
+ */
+const workflowStorage = {
+    /**
+     * Save a workflow to the filesystem
+     * 
+     * @param {string} workflowId - Unique ID for the workflow
+     * @param {Object} workflowData - Workflow data to save
+     * @param {string} filePath - Required filepath specified by LLM
+     * @returns {Promise<Object>} Result with success status and path
+     */
+    async saveWorkflow(workflowId, workflowData, filePath) {
+        try {
+            if (!filePath) {
+                throw new Error('filePath is required - workflow must be saved at the location specified by the LLM');
+            }
+
+            // Make sure the path is valid - use absolute path or resolve relative path
+            const targetPath = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
+
+            // Ensure the parent directory exists
+            await ensureDirectoryExists(path.dirname(targetPath));
+
+            // Add timestamp if not present
+            if (!workflowData.updatedAt) {
+                workflowData.updatedAt = new Date().toISOString();
+            }
+
+            // Write the workflow file
+            await fs.writeFile(targetPath, JSON.stringify(workflowData, null, 2));
+
+            logger.info('Workflow saved successfully', { workflowId, path: targetPath });
+            return { success: true, path: targetPath };
+        } catch (error) {
+            logger.error('Error saving workflow', { workflowId, error: error.message });
+            throw new Error(`Failed to save workflow: ${error.message}`);
+        }
+    },
+
+    /**
+     * Load a workflow from a specific filepath
+     * 
+     * @param {string} workflowIdOrPath - The complete filepath to the workflow
+     * @returns {Promise<Object>} Workflow data or null if not found
+     */
+    async loadWorkflow(workflowIdOrPath) {
+        try {
+            // Determine the file path - treat as a path by default
+            let filePath = workflowIdOrPath;
+
+            // For backward compatibility, check if it looks like just an ID
+            if (!workflowIdOrPath.includes('/') && !workflowIdOrPath.includes('\\') && !workflowIdOrPath.endsWith('.json')) {
+                logger.warn('Using workflow ID instead of filepath is deprecated, use complete filepath instead', { id: workflowIdOrPath });
+                filePath = path.join(DEFAULT_WORKFLOWS_DIR, `${workflowIdOrPath}.json`);
+            }
+
+            // Make sure the path is valid - use absolute path or resolve relative path
+            const targetPath = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
+
+            const data = await fs.readFile(targetPath, 'utf8');
+            const workflow = JSON.parse(data);
+            logger.info('Workflow loaded successfully', { path: targetPath });
+            return workflow;
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                logger.warn('Workflow not found', { path: workflowIdOrPath });
+                return null;
+            }
+            logger.error('Error loading workflow', { path: workflowIdOrPath, error: error.message });
+            throw new Error(`Failed to load workflow: ${error.message}`);
+        }
+    },
+
+    /**
+     * List workflows from a specific directory
+     * 
+     * @param {string} [directoryPath] - Directory to list workflows from
+     * @param {Object} [options] - List options like limit and offset
+     * @returns {Promise<Array>} Array of workflow summary objects
+     */
+    async listWorkflows(directoryPath = DEFAULT_WORKFLOWS_DIR, options = {}) {
+        try {
+            // Ensure the directory exists
+            await ensureDirectoryExists(directoryPath);
+
+            const { limit = 100, offset = 0 } = options;
+            const files = await fs.readdir(directoryPath);
+            const jsonFiles = files.filter(file => file.endsWith('.json'));
+
+            // Apply pagination
+            const paginatedFiles = jsonFiles.slice(offset, offset + limit);
+
+            // Load each workflow file and extract summary information
+            const workflowPromises = paginatedFiles.map(async (file) => {
+                const fullPath = path.join(directoryPath, file);
+                try {
+                    const data = await fs.readFile(fullPath, 'utf8');
+                    const workflow = JSON.parse(data);
+
+                    return {
+                        id: workflow.id || path.basename(file, '.json'),
+                        name: workflow.name || 'Unnamed Workflow',
+                        description: workflow.description || '',
+                        updatedAt: workflow.updatedAt || null,
+                        path: fullPath
+                    };
+                } catch (error) {
+                    logger.error('Error reading workflow file', { path: fullPath, error: error.message });
+                    return null;
+                }
+            });
+
+            // Wait for all files to be processed
+            const workflows = await Promise.all(workflowPromises);
+
+            // Filter out any null entries from failed reads
+            return workflows.filter(workflow => workflow !== null);
+        } catch (error) {
+            logger.error('Error listing workflows', { directory: directoryPath, error: error.message });
+            throw new Error(`Failed to list workflows: ${error.message}`);
+        }
+    },
+
+    /**
+     * Delete a workflow by ID or filepath
+     * 
+     * @param {string} workflowIdOrPath - Workflow ID or complete filepath
+     * @returns {Promise<Object>} Result with success status
+     */
+    async deleteWorkflow(workflowIdOrPath) {
+        let filePath;
+
+        // Check if the input is a full path or just an ID
+        if (workflowIdOrPath.includes('/') || workflowIdOrPath.includes('\\')) {
+            filePath = workflowIdOrPath;
+        } else {
+            filePath = path.join(DEFAULT_WORKFLOWS_DIR, `${workflowIdOrPath}.json`);
+        }
+
+        try {
+            await fs.unlink(filePath);
+            logger.info('Workflow deleted successfully', { path: filePath });
+            return { success: true, path: filePath };
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                logger.warn('Workflow not found for deletion', { path: filePath });
+                return { success: false, error: 'Workflow not found' };
+            }
+            logger.error('Error deleting workflow', { path: filePath, error: error.message });
+            throw new Error(`Failed to delete workflow: ${error.message}`);
+        }
+    }
+};
+
+module.exports = {
+    workflowStorage,
+    DEFAULT_WORKFLOWS_DIR,
+    ensureDirectoryExists
+}; 

package/src/models/tool.js

@@ -0,0 +1,148 @@
+/**
+ * Tool Model
+ * 
+ * Defines the schema and validation for MCP tools
+ */
+
+const Ajv = require('ajv');
+const ajv = new Ajv({ allErrors: true });
+
+// Schema for MCP tool parameter definitions
+const parameterSchema = {
+    type: 'object',
+    properties: {
+        type: { type: 'string', enum: ['string', 'number', 'boolean', 'object', 'array', 'integer'] },
+        description: { type: 'string' },
+        optional: { type: 'boolean' },
+        properties: { type: 'object' },  // For nested objects
+        items: { type: 'object' }        // For arrays
+    },
+    required: ['type']
+};
+
+// Schema for MCP tool definitions
+const toolSchema = {
+    type: 'object',
+    properties: {
+        description: { type: 'string' },
+        parameters: {
+            type: 'object',
+            properties: {
+                type: { type: 'string', enum: ['object'] },
+                properties: {
+                    type: 'object',
+                    additionalProperties: parameterSchema
+                },
+                required: {
+                    type: 'array',
+                    items: { type: 'string' }
+                }
+            },
+            required: ['type', 'properties']
+        }
+        // Note: We'll validate the execute function separately
+    },
+    required: ['description', 'parameters']
+};
+
+// Validator for tool definitions
+const validateTool = ajv.compile(toolSchema);
+
+/**
+ * Create a new Tool schema
+ * 
+ * @param {string} description - Tool description
+ * @param {Object} parameters - Parameter definitions
+ * @param {Function} execute - Implementation function
+ * @returns {Object} Validated tool object
+ * @throws {Error} If validation fails
+ */
+const createTool = (description, parameters, execute) => {
+    // Validate execute is a function
+    if (typeof execute !== 'function') {
+        throw new Error('Tool execute property must be a function');
+    }
+
+    // Create the tool object
+    const tool = {
+        description,
+        parameters: {
+            type: 'object',
+            properties: parameters,
+            required: Object.keys(parameters).filter(key => !parameters[key].optional)
+        },
+        execute
+    };
+
+    // Validate the tool schema (excluding execute function)
+    const { execute: _, ...toolForValidation } = tool;
+    const valid = validateTool(toolForValidation);
+
+    if (!valid) {
+        const errors = validateTool.errors.map(err =>
+            `${err.instancePath} ${err.message}`
+        ).join('; ');
+
+        throw new Error(`Invalid tool definition: ${errors}`);
+    }
+
+    return tool;
+};
+
+/**
+ * Validate tool parameters against schema before execution
+ * 
+ * @param {Object} tool - Tool definition
+ * @param {Object} params - Parameters to validate
+ * @returns {Object} Validated and processed parameters
+ * @throws {Error} If validation fails
+ */
+const validateParameters = (tool, params) => {
+    // Create validator for this tool's parameters
+    const schema = {
+        type: 'object',
+        properties: {},
+        required: tool.parameters.required
+    };
+
+    // Build properties schema from tool parameters
+    for (const [key, def] of Object.entries(tool.parameters.properties)) {
+        schema.properties[key] = {
+            type: def.type
+        };
+
+        // Add enum if present
+        if (def.enum) {
+            schema.properties[key].enum = def.enum;
+        }
+
+        // Add object properties if present
+        if (def.properties) {
+            schema.properties[key].properties = def.properties;
+        }
+
+        // Add array items if present
+        if (def.items) {
+            schema.properties[key].items = def.items;
+        }
+    }
+
+    const validate = ajv.compile(schema);
+    const valid = validate(params);
+
+    if (!valid) {
+        const errors = validate.errors.map(err =>
+            `${err.instancePath} ${err.message}`
+        ).join('; ');
+
+        throw new Error(`Invalid parameters: ${errors}`);
+    }
+
+    return params;
+};
+
+module.exports = {
+    createTool,
+    validateParameters,
+    validateTool
+}; 

package/src/models/user.js

@@ -0,0 +1,164 @@
+/**
+ * User and Permissions Model
+ * 
+ * Defines user roles and permissions for role-based access control.
+ */
+
+// Define permission constants
+const PERMISSIONS = {
+    // Workflow permissions
+    WORKFLOW_VIEW: 'workflow:view',
+    WORKFLOW_CREATE: 'workflow:create',
+    WORKFLOW_EDIT: 'workflow:edit',
+    WORKFLOW_DELETE: 'workflow:delete',
+    WORKFLOW_EXECUTE: 'workflow:execute',
+
+    // Node permissions
+    NODE_VIEW: 'node:view',
+    NODE_ADD: 'node:add',
+    NODE_EDIT: 'node:edit',
+    NODE_DELETE: 'node:delete',
+
+    // Connection permissions
+    CONNECTION_VIEW: 'connection:view',
+    CONNECTION_CREATE: 'connection:create',
+    CONNECTION_DELETE: 'connection:delete',
+
+    // Credential permissions
+    CREDENTIAL_VIEW: 'credential:view',
+    CREDENTIAL_CREATE: 'credential:create',
+    CREDENTIAL_EDIT: 'credential:edit',
+    CREDENTIAL_DELETE: 'credential:delete',
+
+    // System permissions
+    SYSTEM_ADMIN: 'system:admin'
+};
+
+// Define user roles with associated permissions
+const ROLES = {
+    ADMIN: 'admin',
+    EDITOR: 'editor',
+    VIEWER: 'viewer'
+};
+
+// Permission sets for each role
+const ROLE_PERMISSIONS = {
+    [ROLES.ADMIN]: [
+        // System admin has all permissions
+        PERMISSIONS.SYSTEM_ADMIN,
+        PERMISSIONS.WORKFLOW_VIEW,
+        PERMISSIONS.WORKFLOW_CREATE,
+        PERMISSIONS.WORKFLOW_EDIT,
+        PERMISSIONS.WORKFLOW_DELETE,
+        PERMISSIONS.WORKFLOW_EXECUTE,
+        PERMISSIONS.NODE_VIEW,
+        PERMISSIONS.NODE_ADD,
+        PERMISSIONS.NODE_EDIT,
+        PERMISSIONS.NODE_DELETE,
+        PERMISSIONS.CONNECTION_VIEW,
+        PERMISSIONS.CONNECTION_CREATE,
+        PERMISSIONS.CONNECTION_DELETE,
+        PERMISSIONS.CREDENTIAL_VIEW,
+        PERMISSIONS.CREDENTIAL_CREATE,
+        PERMISSIONS.CREDENTIAL_EDIT,
+        PERMISSIONS.CREDENTIAL_DELETE
+    ],
+    [ROLES.EDITOR]: [
+        // Editor can do everything except delete workflows and manage credentials
+        PERMISSIONS.WORKFLOW_VIEW,
+        PERMISSIONS.WORKFLOW_CREATE,
+        PERMISSIONS.WORKFLOW_EDIT,
+        PERMISSIONS.WORKFLOW_EXECUTE,
+        PERMISSIONS.NODE_VIEW,
+        PERMISSIONS.NODE_ADD,
+        PERMISSIONS.NODE_EDIT,
+        PERMISSIONS.NODE_DELETE,
+        PERMISSIONS.CONNECTION_VIEW,
+        PERMISSIONS.CONNECTION_CREATE,
+        PERMISSIONS.CONNECTION_DELETE,
+        PERMISSIONS.CREDENTIAL_VIEW
+    ],
+    [ROLES.VIEWER]: [
+        // Viewer has read-only access
+        PERMISSIONS.WORKFLOW_VIEW,
+        PERMISSIONS.NODE_VIEW,
+        PERMISSIONS.CONNECTION_VIEW
+    ]
+};
+
+/**
+ * Check if a user has a specific permission
+ * 
+ * @param {Object} user - User object with roles property
+ * @param {String} permission - Permission to check
+ * @returns {Boolean} - Whether user has the permission
+ */
+const hasPermission = (user, permission) => {
+    // If no user or roles provided, no permissions
+    if (!user || !user.roles || !Array.isArray(user.roles)) {
+        return false;
+    }
+
+    // Check if any of the user's roles grant the required permission
+    return user.roles.some(role => {
+        const rolePermissions = ROLE_PERMISSIONS[role];
+
+        // If role doesn't exist or has no permissions, skip
+        if (!rolePermissions) {
+            return false;
+        }
+
+        // System admin permission grants access to everything
+        if (rolePermissions.includes(PERMISSIONS.SYSTEM_ADMIN)) {
+            return true;
+        }
+
+        // Check for specific permission
+        return rolePermissions.includes(permission);
+    });
+};
+
+/**
+ * Get all permissions for a user based on their roles
+ * 
+ * @param {Object} user - User object with roles property
+ * @returns {String[]} - Array of permission strings
+ */
+const getUserPermissions = (user) => {
+    // If no user or roles provided, no permissions
+    if (!user || !user.roles || !Array.isArray(user.roles)) {
+        return [];
+    }
+
+    // Create a Set to avoid duplicate permissions
+    const permissionsSet = new Set();
+
+    // Add all permissions from all user roles
+    user.roles.forEach(role => {
+        const rolePermissions = ROLE_PERMISSIONS[role];
+        if (rolePermissions) {
+            rolePermissions.forEach(permission => permissionsSet.add(permission));
+        }
+    });
+
+    return [...permissionsSet];
+};
+
+/**
+ * Validate if a role exists
+ * 
+ * @param {String} role - Role to validate
+ * @returns {Boolean} - Whether the role exists
+ */
+const validateRole = (role) => {
+    return Object.values(ROLES).includes(role);
+};
+
+module.exports = {
+    PERMISSIONS,
+    ROLES,
+    ROLE_PERMISSIONS,
+    hasPermission,
+    getUserPermissions,
+    validateRole
+};