n8n-mcp 2.24.0 → 2.26.0

package/dist/mcp/server.js

@@ -586,38 +586,30 @@ class N8NDocumentationMCPServer {
         try {
             let validationResult;
             switch (toolName) {
-                case 'validate_node_operation':
+                case 'validate_node':
                     validationResult = validation_schemas_1.ToolValidation.validateNodeOperation(args);
                     break;
-                case 'validate_node_minimal':
-                    validationResult = validation_schemas_1.ToolValidation.validateNodeMinimal(args);
-                    break;
                 case 'validate_workflow':
-                case 'validate_workflow_connections':
-                case 'validate_workflow_expressions':
                     validationResult = validation_schemas_1.ToolValidation.validateWorkflow(args);
                     break;
                 case 'search_nodes':
                     validationResult = validation_schemas_1.ToolValidation.validateSearchNodes(args);
                     break;
-                case 'list_node_templates':
-                    validationResult = validation_schemas_1.ToolValidation.validateListNodeTemplates(args);
-                    break;
                 case 'n8n_create_workflow':
                     validationResult = validation_schemas_1.ToolValidation.validateCreateWorkflow(args);
                     break;
                 case 'n8n_get_workflow':
-                case 'n8n_get_workflow_details':
-                case 'n8n_get_workflow_structure':
-                case 'n8n_get_workflow_minimal':
                 case 'n8n_update_full_workflow':
                 case 'n8n_delete_workflow':
                 case 'n8n_validate_workflow':
                 case 'n8n_autofix_workflow':
-                case 'n8n_get_execution':
-                case 'n8n_delete_execution':
                     validationResult = validation_schemas_1.ToolValidation.validateWorkflowId(args);
                     break;
+                case 'n8n_executions':
+                    validationResult = args.action
+                        ? { valid: true, errors: [] }
+                        : { valid: false, errors: [{ field: 'action', message: 'action is required' }] };
+                    break;
                 default:
                     return this.validateToolParamsBasic(toolName, args, legacyRequiredParams || []);
             }
@@ -726,32 +718,39 @@ class N8NDocumentationMCPServer {
         switch (name) {
             case 'tools_documentation':
                 return this.getToolsDocumentation(args.topic, args.depth);
-            case 'list_nodes':
-                return this.listNodes(args);
             case 'search_nodes':
                 this.validateToolParams(name, args, ['query']);
                 const limit = args.limit !== undefined ? Number(args.limit) || 20 : 20;
                 return this.searchNodes(args.query, limit, { mode: args.mode, includeExamples: args.includeExamples });
-            case 'list_ai_tools':
-                return this.listAITools();
-            case 'get_node_documentation':
-                this.validateToolParams(name, args, ['nodeType']);
-                return this.getNodeDocumentation(args.nodeType);
-            case 'get_database_statistics':
-                return this.getDatabaseStatistics();
             case 'get_node':
                 this.validateToolParams(name, args, ['nodeType']);
+                if (args.mode === 'docs') {
+                    return this.getNodeDocumentation(args.nodeType);
+                }
+                if (args.mode === 'search_properties') {
+                    if (!args.propertyQuery) {
+                        throw new Error('propertyQuery is required for mode=search_properties');
+                    }
+                    const maxResults = args.maxPropertyResults !== undefined ? Number(args.maxPropertyResults) || 20 : 20;
+                    return this.searchNodeProperties(args.nodeType, args.propertyQuery, maxResults);
+                }
                 return this.getNode(args.nodeType, args.detail, args.mode, args.includeTypeInfo, args.includeExamples, args.fromVersion, args.toVersion);
-            case 'search_node_properties':
-                this.validateToolParams(name, args, ['nodeType', 'query']);
-                const maxResults = args.maxResults !== undefined ? Number(args.maxResults) || 20 : 20;
-                return this.searchNodeProperties(args.nodeType, args.query, maxResults);
-            case 'list_tasks':
-                return this.listTasks(args.category);
-            case 'validate_node_operation':
+            case 'validate_node':
                 this.validateToolParams(name, args, ['nodeType', 'config']);
                 if (typeof args.config !== 'object' || args.config === null) {
-                    logger_1.logger.warn(`validate_node_operation called with invalid config type: ${typeof args.config}`);
+                    logger_1.logger.warn(`validate_node called with invalid config type: ${typeof args.config}`);
+                    const validationMode = args.mode || 'full';
+                    if (validationMode === 'minimal') {
+                        return {
+                            nodeType: args.nodeType || 'unknown',
+                            displayName: 'Unknown Node',
+                            valid: false,
+                            missingRequiredFields: [
+                                'Invalid config format - expected object',
+                                '🔧 RECOVERY: Use format { "resource": "...", "operation": "..." } or {} for empty config'
+                            ]
+                        };
+                    }
                     return {
                         nodeType: args.nodeType || 'unknown',
                         workflowNodeType: args.nodeType || 'unknown',
@@ -767,7 +766,7 @@ class N8NDocumentationMCPServer {
                         suggestions: [
                             '🔧 RECOVERY: Invalid config detected. Fix with:',
                             '   • Ensure config is an object: { "resource": "...", "operation": "..." }',
-                            '   • Use get_node_essentials to see required fields for this node type',
+                            '   • Use get_node to see required fields for this node type',
                             '   • Check if the node type is correct before configuring it'
                         ],
                         summary: {
@@ -778,90 +777,70 @@ class N8NDocumentationMCPServer {
                         }
                     };
                 }
-                return this.validateNodeConfig(args.nodeType, args.config, 'operation', args.profile);
-            case 'validate_node_minimal':
-                this.validateToolParams(name, args, ['nodeType', 'config']);
-                if (typeof args.config !== 'object' || args.config === null) {
-                    logger_1.logger.warn(`validate_node_minimal called with invalid config type: ${typeof args.config}`);
-                    return {
-                        nodeType: args.nodeType || 'unknown',
-                        displayName: 'Unknown Node',
-                        valid: false,
-                        missingRequiredFields: [
-                            'Invalid config format - expected object',
-                            '🔧 RECOVERY: Use format { "resource": "...", "operation": "..." } or {} for empty config'
-                        ]
-                    };
+                const validationMode = args.mode || 'full';
+                if (validationMode === 'minimal') {
+                    return this.validateNodeMinimal(args.nodeType, args.config);
                 }
-                return this.validateNodeMinimal(args.nodeType, args.config);
-            case 'get_property_dependencies':
-                this.validateToolParams(name, args, ['nodeType']);
-                return this.getPropertyDependencies(args.nodeType, args.config);
-            case 'get_node_as_tool_info':
-                this.validateToolParams(name, args, ['nodeType']);
-                return this.getNodeAsToolInfo(args.nodeType);
-            case 'list_templates':
-                const listLimit = Math.min(Math.max(Number(args.limit) || 10, 1), 100);
-                const listOffset = Math.max(Number(args.offset) || 0, 0);
-                const sortBy = args.sortBy || 'views';
-                const includeMetadata = Boolean(args.includeMetadata);
-                return this.listTemplates(listLimit, listOffset, sortBy, includeMetadata);
-            case 'list_node_templates':
-                this.validateToolParams(name, args, ['nodeTypes']);
-                const templateLimit = Math.min(Math.max(Number(args.limit) || 10, 1), 100);
-                const templateOffset = Math.max(Number(args.offset) || 0, 0);
-                return this.listNodeTemplates(args.nodeTypes, templateLimit, templateOffset);
+                return this.validateNodeConfig(args.nodeType, args.config, 'operation', args.profile);
             case 'get_template':
                 this.validateToolParams(name, args, ['templateId']);
                 const templateId = Number(args.templateId);
-                const mode = args.mode || 'full';
-                return this.getTemplate(templateId, mode);
-            case 'search_templates':
-                this.validateToolParams(name, args, ['query']);
+                const templateMode = args.mode || 'full';
+                return this.getTemplate(templateId, templateMode);
+            case 'search_templates': {
+                const searchMode = args.searchMode || 'keyword';
                 const searchLimit = Math.min(Math.max(Number(args.limit) || 20, 1), 100);
                 const searchOffset = Math.max(Number(args.offset) || 0, 0);
-                const searchFields = args.fields;
-                return this.searchTemplates(args.query, searchLimit, searchOffset, searchFields);
-            case 'get_templates_for_task':
-                this.validateToolParams(name, args, ['task']);
-                const taskLimit = Math.min(Math.max(Number(args.limit) || 10, 1), 100);
-                const taskOffset = Math.max(Number(args.offset) || 0, 0);
-                return this.getTemplatesForTask(args.task, taskLimit, taskOffset);
-            case 'search_templates_by_metadata':
-                const metadataLimit = Math.min(Math.max(Number(args.limit) || 20, 1), 100);
-                const metadataOffset = Math.max(Number(args.offset) || 0, 0);
-                return this.searchTemplatesByMetadata({
-                    category: args.category,
-                    complexity: args.complexity,
-                    maxSetupMinutes: args.maxSetupMinutes ? Number(args.maxSetupMinutes) : undefined,
-                    minSetupMinutes: args.minSetupMinutes ? Number(args.minSetupMinutes) : undefined,
-                    requiredService: args.requiredService,
-                    targetAudience: args.targetAudience
-                }, metadataLimit, metadataOffset);
+                switch (searchMode) {
+                    case 'by_nodes':
+                        if (!args.nodeTypes || !Array.isArray(args.nodeTypes) || args.nodeTypes.length === 0) {
+                            throw new Error('nodeTypes array is required for searchMode=by_nodes');
+                        }
+                        return this.listNodeTemplates(args.nodeTypes, searchLimit, searchOffset);
+                    case 'by_task':
+                        if (!args.task) {
+                            throw new Error('task is required for searchMode=by_task');
+                        }
+                        return this.getTemplatesForTask(args.task, searchLimit, searchOffset);
+                    case 'by_metadata':
+                        return this.searchTemplatesByMetadata({
+                            category: args.category,
+                            complexity: args.complexity,
+                            maxSetupMinutes: args.maxSetupMinutes ? Number(args.maxSetupMinutes) : undefined,
+                            minSetupMinutes: args.minSetupMinutes ? Number(args.minSetupMinutes) : undefined,
+                            requiredService: args.requiredService,
+                            targetAudience: args.targetAudience
+                        }, searchLimit, searchOffset);
+                    case 'keyword':
+                    default:
+                        if (!args.query) {
+                            throw new Error('query is required for searchMode=keyword');
+                        }
+                        const searchFields = args.fields;
+                        return this.searchTemplates(args.query, searchLimit, searchOffset, searchFields);
+                }
+            }
             case 'validate_workflow':
                 this.validateToolParams(name, args, ['workflow']);
                 return this.validateWorkflow(args.workflow, args.options);
-            case 'validate_workflow_connections':
-                this.validateToolParams(name, args, ['workflow']);
-                return this.validateWorkflowConnections(args.workflow);
-            case 'validate_workflow_expressions':
-                this.validateToolParams(name, args, ['workflow']);
-                return this.validateWorkflowExpressions(args.workflow);
             case 'n8n_create_workflow':
                 this.validateToolParams(name, args, ['name', 'nodes', 'connections']);
                 return n8nHandlers.handleCreateWorkflow(args, this.instanceContext);
-            case 'n8n_get_workflow':
-                this.validateToolParams(name, args, ['id']);
-                return n8nHandlers.handleGetWorkflow(args, this.instanceContext);
-            case 'n8n_get_workflow_details':
-                this.validateToolParams(name, args, ['id']);
-                return n8nHandlers.handleGetWorkflowDetails(args, this.instanceContext);
-            case 'n8n_get_workflow_structure':
-                this.validateToolParams(name, args, ['id']);
-                return n8nHandlers.handleGetWorkflowStructure(args, this.instanceContext);
-            case 'n8n_get_workflow_minimal':
+            case 'n8n_get_workflow': {
                 this.validateToolParams(name, args, ['id']);
-                return n8nHandlers.handleGetWorkflowMinimal(args, this.instanceContext);
+                const workflowMode = args.mode || 'full';
+                switch (workflowMode) {
+                    case 'details':
+                        return n8nHandlers.handleGetWorkflowDetails(args, this.instanceContext);
+                    case 'structure':
+                        return n8nHandlers.handleGetWorkflowStructure(args, this.instanceContext);
+                    case 'minimal':
+                        return n8nHandlers.handleGetWorkflowMinimal(args, this.instanceContext);
+                    case 'full':
+                    default:
+                        return n8nHandlers.handleGetWorkflow(args, this.instanceContext);
+                }
+            }
             case 'n8n_update_full_workflow':
                 this.validateToolParams(name, args, ['id']);
                 return n8nHandlers.handleUpdateWorkflow(args, this.repository, this.instanceContext);
@@ -888,20 +867,31 @@ class N8NDocumentationMCPServer {
             case 'n8n_trigger_webhook_workflow':
                 this.validateToolParams(name, args, ['webhookUrl']);
                 return n8nHandlers.handleTriggerWebhookWorkflow(args, this.instanceContext);
-            case 'n8n_get_execution':
-                this.validateToolParams(name, args, ['id']);
-                return n8nHandlers.handleGetExecution(args, this.instanceContext);
-            case 'n8n_list_executions':
-                return n8nHandlers.handleListExecutions(args, this.instanceContext);
-            case 'n8n_delete_execution':
-                this.validateToolParams(name, args, ['id']);
-                return n8nHandlers.handleDeleteExecution(args, this.instanceContext);
+            case 'n8n_executions': {
+                this.validateToolParams(name, args, ['action']);
+                const execAction = args.action;
+                switch (execAction) {
+                    case 'get':
+                        if (!args.id) {
+                            throw new Error('id is required for action=get');
+                        }
+                        return n8nHandlers.handleGetExecution(args, this.instanceContext);
+                    case 'list':
+                        return n8nHandlers.handleListExecutions(args, this.instanceContext);
+                    case 'delete':
+                        if (!args.id) {
+                            throw new Error('id is required for action=delete');
+                        }
+                        return n8nHandlers.handleDeleteExecution(args, this.instanceContext);
+                    default:
+                        throw new Error(`Unknown action: ${execAction}. Valid actions: get, list, delete`);
+                }
+            }
             case 'n8n_health_check':
+                if (args.mode === 'diagnostic') {
+                    return n8nHandlers.handleDiagnostic({ params: { arguments: args } }, this.instanceContext);
+                }
                 return n8nHandlers.handleHealthCheck(this.instanceContext);
-            case 'n8n_list_available_tools':
-                return n8nHandlers.handleListAvailableTools(this.instanceContext);
-            case 'n8n_diagnostic':
-                return n8nHandlers.handleDiagnostic({ params: { arguments: args } }, this.instanceContext);
             case 'n8n_workflow_versions':
                 this.validateToolParams(name, args, ['mode']);
                 return n8nHandlers.handleWorkflowVersions(args, this.repository, this.instanceContext);