n8n-atom-mcp 0.0.1

package/dist/mcp/tools-n8n-manager.js

@@ -0,0 +1,1320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.n8nManagementTools = void 0;
+exports.n8nManagementTools = [
+    {
+        name: 'n8n_create_workflow',
+        description: `Create workflow. Requires: name, nodes[], connections{}. Created inactive. Returns workflow with ID.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Workflow name (required)'
+                },
+                nodes: {
+                    type: 'array',
+                    description: 'Array of workflow nodes. Each node must have: id, name, type, typeVersion, position, and parameters',
+                    items: {
+                        type: 'object',
+                        required: ['id', 'name', 'type', 'typeVersion', 'position', 'parameters'],
+                        properties: {
+                            id: { type: 'string' },
+                            name: { type: 'string' },
+                            type: { type: 'string' },
+                            typeVersion: { type: 'number' },
+                            position: {
+                                type: 'array',
+                                items: { type: 'number' },
+                                minItems: 2,
+                                maxItems: 2
+                            },
+                            parameters: { type: 'object' },
+                            credentials: { type: 'object' },
+                            disabled: { type: 'boolean' },
+                            notes: { type: 'string' },
+                            continueOnFail: { type: 'boolean' },
+                            retryOnFail: { type: 'boolean' },
+                            maxTries: { type: 'number' },
+                            waitBetweenTries: { type: 'number' }
+                        }
+                    }
+                },
+                connections: {
+                    type: 'object',
+                    description: 'Workflow connections object. Keys are source node names (the name field, not id), values define output connections'
+                },
+                settings: {
+                    type: 'object',
+                    description: 'Optional workflow settings (execution order, timezone, error handling)',
+                    properties: {
+                        executionOrder: { type: 'string', enum: ['v0', 'v1'] },
+                        timezone: { type: 'string' },
+                        saveDataErrorExecution: { type: 'string', enum: ['all', 'none'] },
+                        saveDataSuccessExecution: { type: 'string', enum: ['all', 'none'] },
+                        saveManualExecutions: { type: 'boolean' },
+                        saveExecutionProgress: { type: 'boolean' },
+                        executionTimeout: { type: 'number' },
+                        errorWorkflow: { type: 'string' }
+                    }
+                }
+            },
+            required: ['name', 'nodes', 'connections']
+        },
+        annotations: {
+            title: 'Create Workflow',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_get_workflow',
+        description: `Get workflow by ID with different detail levels. Use mode='full' for complete workflow, 'details' for metadata+stats, 'structure' for nodes/connections only, 'minimal' for id/name/active/tags.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Workflow ID'
+                },
+                mode: {
+                    type: 'string',
+                    enum: ['full', 'details', 'structure', 'minimal'],
+                    default: 'full',
+                    description: 'Detail level: full=complete workflow, details=full+execution stats, structure=nodes/connections topology, minimal=metadata only'
+                }
+            },
+            required: ['id']
+        },
+        annotations: {
+            title: 'Get Workflow',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_update_full_workflow',
+        description: `Full workflow update. Requires complete nodes[] and connections{}. For incremental use n8n_update_partial_workflow.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Workflow ID to update'
+                },
+                name: {
+                    type: 'string',
+                    description: 'New workflow name'
+                },
+                nodes: {
+                    type: 'array',
+                    description: 'Complete array of workflow nodes (required if modifying workflow structure)',
+                    items: {
+                        type: 'object',
+                        additionalProperties: true
+                    }
+                },
+                connections: {
+                    type: 'object',
+                    description: 'Complete connections object (required if modifying workflow structure)'
+                },
+                settings: {
+                    type: 'object',
+                    description: 'Workflow settings to update'
+                }
+            },
+            required: ['id']
+        },
+        annotations: {
+            title: 'Update Full Workflow',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_update_partial_workflow',
+        description: `Update workflow incrementally with diff operations. Types: addNode, removeNode, updateNode, moveNode, enable/disableNode, addConnection, removeConnection, updateSettings, updateName, add/removeTag. See tools_documentation("n8n_update_partial_workflow", "full") for details.`,
+        inputSchema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Workflow ID to update'
+                },
+                operations: {
+                    type: 'array',
+                    description: 'Array of diff operations to apply. Each operation must have a "type" field and relevant properties for that operation type.',
+                    items: {
+                        type: 'object',
+                        additionalProperties: true
+                    }
+                },
+                validateOnly: {
+                    type: 'boolean',
+                    description: 'If true, only validate operations without applying them'
+                },
+                continueOnError: {
+                    type: 'boolean',
+                    description: 'If true, apply valid operations even if some fail (best-effort mode). Returns applied and failed operation indices. Default: false (atomic)'
+                }
+            },
+            required: ['id', 'operations']
+        },
+        annotations: {
+            title: 'Update Partial Workflow',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_delete_workflow',
+        description: `Permanently delete a workflow. This action cannot be undone.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Workflow ID to delete'
+                }
+            },
+            required: ['id']
+        },
+        annotations: {
+            title: 'Delete Workflow',
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_list_workflows',
+        description: `List workflows (minimal metadata only). Returns id/name/active/dates/tags. Check hasMore/nextCursor for pagination.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Number of workflows to return (1-100, default: 100)'
+                },
+                cursor: {
+                    type: 'string',
+                    description: 'Pagination cursor from previous response'
+                },
+                active: {
+                    type: 'boolean',
+                    description: 'Filter by active status'
+                },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by tags (exact match)'
+                },
+                projectId: {
+                    type: 'string',
+                    description: 'Filter by project ID (enterprise feature)'
+                },
+                excludePinnedData: {
+                    type: 'boolean',
+                    description: 'Exclude pinned data from response (default: true)'
+                }
+            }
+        },
+        annotations: {
+            title: 'List Workflows',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_validate_workflow',
+        description: `Validate workflow by ID. Checks nodes, connections, expressions. Returns errors/warnings/suggestions.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Workflow ID to validate'
+                },
+                options: {
+                    type: 'object',
+                    description: 'Validation options',
+                    properties: {
+                        validateNodes: {
+                            type: 'boolean',
+                            description: 'Validate node configurations (default: true)'
+                        },
+                        validateConnections: {
+                            type: 'boolean',
+                            description: 'Validate workflow connections (default: true)'
+                        },
+                        validateExpressions: {
+                            type: 'boolean',
+                            description: 'Validate n8n expressions (default: true)'
+                        },
+                        profile: {
+                            type: 'string',
+                            enum: ['minimal', 'runtime', 'ai-friendly', 'strict'],
+                            description: 'Validation profile to use (default: runtime)'
+                        }
+                    }
+                }
+            },
+            required: ['id']
+        },
+        annotations: {
+            title: 'Validate Workflow',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_autofix_workflow',
+        description: `Automatically fix common workflow validation errors. Preview fixes or apply them. Fixes expression format, typeVersion, error output config, webhook paths.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Workflow ID to fix'
+                },
+                applyFixes: {
+                    type: 'boolean',
+                    description: 'Apply fixes to workflow (default: false - preview mode)'
+                },
+                fixTypes: {
+                    type: 'array',
+                    description: 'Types of fixes to apply (default: all)',
+                    items: {
+                        type: 'string',
+                        enum: ['expression-format', 'typeversion-correction', 'error-output-config', 'node-type-correction', 'webhook-missing-path', 'typeversion-upgrade', 'version-migration']
+                    }
+                },
+                confidenceThreshold: {
+                    type: 'string',
+                    enum: ['high', 'medium', 'low'],
+                    description: 'Minimum confidence level for fixes (default: medium)'
+                },
+                maxFixes: {
+                    type: 'number',
+                    description: 'Maximum number of fixes to apply (default: 50)'
+                }
+            },
+            required: ['id']
+        },
+        annotations: {
+            title: 'Autofix Workflow',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_test_workflow',
+        description: `Test/trigger workflow execution. Auto-detects trigger type (webhook/form/chat). Supports: webhook (HTTP), form (fields), chat (message). Note: Only workflows with these trigger types can be executed externally.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflowId: {
+                    type: 'string',
+                    description: 'Workflow ID to execute (required)'
+                },
+                triggerType: {
+                    type: 'string',
+                    enum: ['webhook', 'form', 'chat'],
+                    description: 'Trigger type. Auto-detected if not specified. Workflow must have a matching trigger node.'
+                },
+                httpMethod: {
+                    type: 'string',
+                    enum: ['GET', 'POST', 'PUT', 'DELETE'],
+                    description: 'For webhook: HTTP method (default: from workflow config or POST)'
+                },
+                webhookPath: {
+                    type: 'string',
+                    description: 'For webhook: override the webhook path'
+                },
+                message: {
+                    type: 'string',
+                    description: 'For chat: message to send (required for chat triggers)'
+                },
+                sessionId: {
+                    type: 'string',
+                    description: 'For chat: session ID for conversation continuity'
+                },
+                data: {
+                    type: 'object',
+                    description: 'Input data/payload for webhook, form fields, or execution data'
+                },
+                headers: {
+                    type: 'object',
+                    description: 'Custom HTTP headers'
+                },
+                timeout: {
+                    type: 'number',
+                    description: 'Timeout in ms (default: 120000)'
+                },
+                waitForResponse: {
+                    type: 'boolean',
+                    description: 'Wait for workflow completion (default: true)'
+                }
+            },
+            required: ['workflowId']
+        },
+        annotations: {
+            title: 'Test Workflow',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_executions',
+        description: `Manage workflow executions: get details, list, or delete. Use action='get' with id for execution details, action='list' for listing executions, action='delete' to remove execution record.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['get', 'list', 'delete'],
+                    description: 'Operation: get=get execution details, list=list executions, delete=delete execution'
+                },
+                id: {
+                    type: 'string',
+                    description: 'Execution ID (required for action=get or action=delete)'
+                },
+                mode: {
+                    type: 'string',
+                    enum: ['preview', 'summary', 'filtered', 'full', 'error'],
+                    description: 'For action=get: preview=structure only, summary=2 items (default), filtered=custom, full=all data, error=optimized error debugging'
+                },
+                nodeNames: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'For action=get with mode=filtered: filter to specific nodes by name'
+                },
+                itemsLimit: {
+                    type: 'number',
+                    description: 'For action=get with mode=filtered: items per node (0=structure, 2=default, -1=unlimited)'
+                },
+                includeInputData: {
+                    type: 'boolean',
+                    description: 'For action=get: include input data in addition to output (default: false)'
+                },
+                errorItemsLimit: {
+                    type: 'number',
+                    description: 'For action=get with mode=error: sample items from upstream node (default: 2, max: 100)'
+                },
+                includeStackTrace: {
+                    type: 'boolean',
+                    description: 'For action=get with mode=error: include full stack trace (default: false, shows truncated)'
+                },
+                includeExecutionPath: {
+                    type: 'boolean',
+                    description: 'For action=get with mode=error: include execution path leading to error (default: true)'
+                },
+                fetchWorkflow: {
+                    type: 'boolean',
+                    description: 'For action=get with mode=error: fetch workflow for accurate upstream detection (default: true)'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'For action=list: number of executions to return (1-100, default: 100)'
+                },
+                cursor: {
+                    type: 'string',
+                    description: 'For action=list: pagination cursor from previous response'
+                },
+                workflowId: {
+                    type: 'string',
+                    description: 'For action=list: filter by workflow ID'
+                },
+                projectId: {
+                    type: 'string',
+                    description: 'For action=list: filter by project ID (enterprise feature)'
+                },
+                status: {
+                    type: 'string',
+                    enum: ['success', 'error', 'waiting'],
+                    description: 'For action=list: filter by execution status'
+                },
+                includeData: {
+                    type: 'boolean',
+                    description: 'For action=list: include execution data (default: false)'
+                }
+            },
+            required: ['action']
+        },
+        annotations: {
+            title: 'Manage Executions',
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_health_check',
+        description: `Check n8n instance health and API connectivity. Use mode='diagnostic' for detailed troubleshooting with env vars and tool status.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                mode: {
+                    type: 'string',
+                    enum: ['status', 'diagnostic'],
+                    description: 'Mode: "status" (default) for quick health check, "diagnostic" for detailed debug info including env vars and tool status',
+                    default: 'status'
+                },
+                verbose: {
+                    type: 'boolean',
+                    description: 'Include extra details in diagnostic mode (default: false)'
+                }
+            }
+        },
+        annotations: {
+            title: 'Health Check',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_workflow_versions',
+        description: `Manage workflow version history, rollback, and cleanup. Six modes:
+- list: Show version history for a workflow
+- get: Get details of specific version
+- rollback: Restore workflow to previous version (creates backup first)
+- delete: Delete specific version or all versions for a workflow
+- prune: Manually trigger pruning to keep N most recent versions
+- truncate: Delete ALL versions for ALL workflows (requires confirmation)`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                mode: {
+                    type: 'string',
+                    enum: ['list', 'get', 'rollback', 'delete', 'prune', 'truncate'],
+                    description: 'Operation mode'
+                },
+                workflowId: {
+                    type: 'string',
+                    description: 'Workflow ID (required for list, rollback, delete, prune)'
+                },
+                versionId: {
+                    type: 'number',
+                    description: 'Version ID (required for get mode and single version delete, optional for rollback)'
+                },
+                limit: {
+                    type: 'number',
+                    default: 10,
+                    description: 'Max versions to return in list mode'
+                },
+                validateBefore: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Validate workflow structure before rollback'
+                },
+                deleteAll: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Delete all versions for workflow (delete mode only)'
+                },
+                maxVersions: {
+                    type: 'number',
+                    default: 10,
+                    description: 'Keep N most recent versions (prune mode only)'
+                },
+                confirmTruncate: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'REQUIRED: Must be true to truncate all versions (truncate mode only)'
+                }
+            },
+            required: ['mode']
+        },
+        annotations: {
+            title: 'Workflow Versions',
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_import_workflow_file',
+        description: `Import a workflow from .n8n file content. The file will be parsed and uploaded to the n8n instance.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                fileContent: {
+                    type: 'string',
+                    description: 'Raw .n8n file content (JSON string)'
+                },
+                name: {
+                    type: 'string',
+                    description: 'Override workflow name'
+                },
+                activate: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Activate workflow after import'
+                }
+            },
+            required: ['fileContent']
+        },
+        annotations: {
+            title: 'Import Workflow File',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_export_workflow_file',
+        description: `Export a workflow as .n8n file content. Returns the file content as a string ready to save.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflowId: {
+                    type: 'string',
+                    description: 'ID of the workflow to export'
+                },
+                includeCredentials: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Include credential references (default: false for security)'
+                },
+                format: {
+                    type: 'string',
+                    enum: ['json', 'pretty'],
+                    default: 'pretty',
+                    description: 'Output format: json (minified) or pretty (formatted)'
+                }
+            },
+            required: ['workflowId']
+        },
+        annotations: {
+            title: 'Export Workflow File',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_sync_workflow',
+        description: `Synchronize a workflow between .n8n file and n8n server. Supports compare, file-to-server, and server-to-file directions.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflowId: {
+                    type: 'string',
+                    description: 'ID of the workflow on n8n server'
+                },
+                fileContent: {
+                    type: 'string',
+                    description: 'Current .n8n file content'
+                },
+                direction: {
+                    type: 'string',
+                    enum: ['file_to_server', 'server_to_file', 'compare'],
+                    description: 'Sync direction: file_to_server (update server), server_to_file (update file), compare (show differences)'
+                }
+            },
+            required: ['workflowId', 'fileContent', 'direction']
+        },
+        annotations: {
+            title: 'Sync Workflow',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_validate_workflow_file',
+        description: `Validate .n8n file format and workflow structure without importing to server.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                fileContent: {
+                    type: 'string',
+                    description: 'Raw .n8n file content (JSON string)'
+                }
+            },
+            required: ['fileContent']
+        },
+        annotations: {
+            title: 'Validate Workflow File',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'n8n_deploy_template',
+        description: `Deploy a workflow template from n8n.io directly to your n8n instance. Deploys first, then auto-fixes common issues (expression format, typeVersions). Returns workflow ID, required credentials, and fixes applied.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                templateId: {
+                    type: 'number',
+                    description: 'Template ID from n8n.io (required)'
+                },
+                name: {
+                    type: 'string',
+                    description: 'Custom workflow name (default: template name)'
+                },
+                autoUpgradeVersions: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Automatically upgrade node typeVersions to latest supported (default: true)'
+                },
+                autoFix: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Auto-apply fixes after deployment for expression format issues, missing = prefix, etc. (default: true)'
+                },
+                stripCredentials: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Remove credential references from nodes - user configures in n8n UI (default: true)'
+                }
+            },
+            required: ['templateId']
+        },
+        annotations: {
+            title: 'Deploy Template',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_search_community_nodes',
+        description: `Search for community nodes from the n8n community node registry and npm. Returns packages that can be installed with n8n_install_community_package.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Search query (e.g., "slack", "telegram", "database")'
+                },
+                verifiedOnly: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Only return verified community nodes (default: false)'
+                },
+                limit: {
+                    type: 'number',
+                    default: 20,
+                    description: 'Maximum number of results to return (default: 20, max: 50)'
+                }
+            },
+            required: ['query']
+        },
+        annotations: {
+            title: 'Search Community Nodes',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_list_community_packages',
+        description: `List all community packages installed on the n8n instance. Shows package name, version, installed nodes, and available updates.`,
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        },
+        annotations: {
+            title: 'List Community Packages',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_install_community_package',
+        description: `Install a community package on the n8n instance by npm package name. Requires instance owner permissions. Note: n8n may need to be restarted after installation.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                packageName: {
+                    type: 'string',
+                    description: 'npm package name to install (e.g., "n8n-nodes-chatwoot", "@company/n8n-nodes-custom")'
+                }
+            },
+            required: ['packageName']
+        },
+        annotations: {
+            title: 'Install Community Package',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_uninstall_community_package',
+        description: `Uninstall a community package from the n8n instance. Requires instance owner permissions. Warning: This will remove all nodes from this package and may break workflows using them.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                packageName: {
+                    type: 'string',
+                    description: 'npm package name to uninstall'
+                }
+            },
+            required: ['packageName']
+        },
+        annotations: {
+            title: 'Uninstall Community Package',
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_update_community_package',
+        description: `Update a community package to the latest version. Requires instance owner permissions.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                packageName: {
+                    type: 'string',
+                    description: 'npm package name to update'
+                }
+            },
+            required: ['packageName']
+        },
+        annotations: {
+            title: 'Update Community Package',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_sync_installed_nodes',
+        description: `Sync installed community nodes from n8n instance to local database. This enables search_nodes and get_node to find community nodes installed on your n8n. Run after installing new community packages.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                cleanup: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Also remove nodes from packages that are no longer installed (default: false)'
+                }
+            }
+        },
+        annotations: {
+            title: 'Sync Installed Nodes',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_list_credentials',
+        description: `List all credentials from n8n instance. Returns credential metadata (id, name, type) but NEVER exposes actual credential data/secrets for security.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Max number of credentials to return (1-100, default: 50)'
+                },
+                cursor: {
+                    type: 'string',
+                    description: 'Pagination cursor from previous response'
+                }
+            }
+        },
+        annotations: {
+            title: 'List Credentials',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_get_credential',
+        description: `Get credential metadata by ID. Returns name, type, and access info but NEVER returns the actual credential data/secrets.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Credential ID'
+                }
+            },
+            required: ['id']
+        },
+        annotations: {
+            title: 'Get Credential',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_create_credential',
+        description: `Create a new credential. Requires credential type and name. The data object contains service-specific authentication fields.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Credential name (required)'
+                },
+                type: {
+                    type: 'string',
+                    description: 'Credential type (e.g., "slackApi", "googleSheetsOAuth2Api", "httpBasicAuth"). Use n8n_get_credential_types to see available types.'
+                },
+                data: {
+                    type: 'object',
+                    description: 'Credential data object with authentication fields specific to the type (e.g., API key, OAuth tokens, username/password)'
+                }
+            },
+            required: ['name', 'type', 'data']
+        },
+        annotations: {
+            title: 'Create Credential',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_delete_credential',
+        description: `Delete a credential by ID. Warning: Workflows using this credential will fail until updated with a new credential.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Credential ID to delete'
+                }
+            },
+            required: ['id']
+        },
+        annotations: {
+            title: 'Delete Credential',
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_get_credential_types',
+        description: `Get list of available credential types that can be created. Returns type name, display name, and description for each credential type.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filter: {
+                    type: 'string',
+                    description: 'Optional filter to search credential types by name (case-insensitive)'
+                }
+            }
+        },
+        annotations: {
+            title: 'Get Credential Types',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'n8n_list_tags',
+        description: `List all tags from n8n instance. Returns tag id, name, and optionally usage count (number of workflows using each tag).`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Max number of tags to return (1-100, default: 100)'
+                },
+                cursor: {
+                    type: 'string',
+                    description: 'Pagination cursor from previous response'
+                },
+                withUsageCount: {
+                    type: 'boolean',
+                    description: 'Include count of workflows using each tag (default: false)'
+                }
+            }
+        },
+        annotations: {
+            title: 'List Tags',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_create_tag',
+        description: `Create a new tag. Tags help organize workflows by category, project, or any custom classification.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Tag name (required, must be unique)'
+                }
+            },
+            required: ['name']
+        },
+        annotations: {
+            title: 'Create Tag',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_update_tag',
+        description: `Update tag name. This renames the tag across all workflows that use it.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Tag ID to update'
+                },
+                name: {
+                    type: 'string',
+                    description: 'New tag name'
+                }
+            },
+            required: ['id', 'name']
+        },
+        annotations: {
+            title: 'Update Tag',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_delete_tag',
+        description: `Delete a tag. The tag will be removed from all workflows that use it.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Tag ID to delete'
+                }
+            },
+            required: ['id']
+        },
+        annotations: {
+            title: 'Delete Tag',
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_assign_tags_to_workflow',
+        description: `Assign one or more tags to a workflow. This replaces all existing tags on the workflow.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflowId: {
+                    type: 'string',
+                    description: 'Workflow ID to tag'
+                },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of tag IDs to assign. Use empty array [] to remove all tags.'
+                }
+            },
+            required: ['workflowId', 'tags']
+        },
+        annotations: {
+            title: 'Assign Tags to Workflow',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_clone_workflow',
+        description: `Clone an existing workflow with a new name. Creates an exact copy with a different ID, optionally activating it immediately.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflowId: {
+                    type: 'string',
+                    description: 'Source workflow ID to clone'
+                },
+                newName: {
+                    type: 'string',
+                    description: 'Name for the cloned workflow'
+                },
+                activate: {
+                    type: 'boolean',
+                    description: 'Activate the cloned workflow immediately (default: false)'
+                },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional: assign different tags to the clone'
+                }
+            },
+            required: ['workflowId', 'newName']
+        },
+        annotations: {
+            title: 'Clone Workflow',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_backup_workflows',
+        description: `Export all workflows as JSON for backup purposes. Optionally filter by tags or active status. Returns array of workflow objects ready for storage.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                active: {
+                    type: 'boolean',
+                    description: 'Filter by active status (true=active only, false=inactive only, undefined=all)'
+                },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by tag IDs (workflows with any of these tags)'
+                },
+                includeCredentials: {
+                    type: 'boolean',
+                    description: 'Include credential references in backup (default: false for security)'
+                }
+            }
+        },
+        annotations: {
+            title: 'Backup Workflows',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_restore_workflow',
+        description: `Restore a workflow from backup JSON. Can update an existing workflow by ID or create a new one.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflowData: {
+                    type: 'object',
+                    description: 'Workflow JSON data from backup (must include name, nodes, connections)'
+                },
+                mode: {
+                    type: 'string',
+                    enum: ['create', 'update'],
+                    description: 'Restore mode: "create" creates new workflow (ignores ID), "update" updates existing workflow by ID (default: create)'
+                },
+                activate: {
+                    type: 'boolean',
+                    description: 'Activate the restored workflow (default: false)'
+                }
+            },
+            required: ['workflowData']
+        },
+        annotations: {
+            title: 'Restore Workflow',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_activate_workflow',
+        description: `Activate a workflow to enable its triggers (webhooks, polling, schedule). Active workflows run automatically based on their trigger configuration.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflowId: {
+                    type: 'string',
+                    description: 'Workflow ID to activate'
+                }
+            },
+            required: ['workflowId']
+        },
+        annotations: {
+            title: 'Activate Workflow',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_deactivate_workflow',
+        description: `Deactivate a workflow to disable its triggers. The workflow will stop running automatically until reactivated.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflowId: {
+                    type: 'string',
+                    description: 'Workflow ID to deactivate'
+                }
+            },
+            required: ['workflowId']
+        },
+        annotations: {
+            title: 'Deactivate Workflow',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_list_active_workflows',
+        description: `List all currently active workflows. Returns workflows that are enabled and running their triggers.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Max number of workflows to return (1-100, default: 100)'
+                },
+                cursor: {
+                    type: 'string',
+                    description: 'Pagination cursor from previous response'
+                },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by tag IDs (workflows with any of these tags)'
+                }
+            }
+        },
+        annotations: {
+            title: 'List Active Workflows',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_get_workflow_stats',
+        description: `Get execution statistics for a workflow including success rate, average execution time, and execution counts. Analyzes recent executions to provide comprehensive metrics.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflowId: {
+                    type: 'string',
+                    description: 'Workflow ID to analyze'
+                },
+                daysBack: {
+                    type: 'number',
+                    description: 'Number of days to analyze (default: 30, max: 90)'
+                }
+            },
+            required: ['workflowId']
+        },
+        annotations: {
+            title: 'Get Workflow Statistics',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_get_execution_trends',
+        description: `Analyze execution trends over time for a workflow. Returns daily statistics including execution counts, success/error rates, and average execution times.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflowId: {
+                    type: 'string',
+                    description: 'Workflow ID to analyze'
+                },
+                days: {
+                    type: 'number',
+                    description: 'Number of days to analyze (default: 7, max: 30)'
+                }
+            },
+            required: ['workflowId']
+        },
+        annotations: {
+            title: 'Get Execution Trends',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_get_slow_workflows',
+        description: `Identify workflows with slowest execution times. Returns workflows sorted by average execution time with percentile metrics (median, p95) to help optimize performance.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Number of slow workflows to return (default: 10, max: 50)'
+                }
+            }
+        },
+        annotations: {
+            title: 'Get Slow Workflows',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_trace_execution',
+        description: `Trace the execution path of a workflow run step-by-step. Shows which nodes executed, their status, execution time, input/output counts, and any errors. Essential for debugging failed workflows.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                executionId: {
+                    type: 'string',
+                    description: 'Execution ID to trace'
+                }
+            },
+            required: ['executionId']
+        },
+        annotations: {
+            title: 'Trace Execution',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: 'n8n_compare_executions',
+        description: `Compare two workflow executions side-by-side to identify differences. Shows status, timing, and node execution differences. Useful for debugging why one execution succeeded while another failed.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                executionId1: {
+                    type: 'string',
+                    description: 'First execution ID to compare'
+                },
+                executionId2: {
+                    type: 'string',
+                    description: 'Second execution ID to compare'
+                }
+            },
+            required: ['executionId1', 'executionId2']
+        },
+        annotations: {
+            title: 'Compare Executions',
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }
+];
+//# sourceMappingURL=tools-n8n-manager.js.map