"""
n8n Plugin - Workflow Automation Management
Complete n8n workflow automation management through REST API.
Provides 56 tools across 8 categories: workflows, executions,
credentials, tags, users, projects, variables, and system.
"""
from typing import Any
from plugins.base import BasePlugin
from plugins.n8n import handlers
from plugins.n8n.client import N8nClient
class N8nPlugin(BasePlugin):
"""
n8n Automation Plugin - Comprehensive workflow management.
Provides complete n8n management capabilities including:
- Workflow management (CRUD, activate, deactivate, execute)
- Execution monitoring (list, get, delete, retry, wait)
- Credential management (get, create, delete, schema, transfer)
- Tag management (CRUD, bulk delete)
- User management (CRUD, roles)
- Project management (CRUD, user assignment) - Enterprise/Pro
- Variable management (CRUD, bulk set) - Enterprise/Pro
- System operations (audit, source control, health)
Total: 56 tools
"""
@staticmethod
def get_plugin_name() -> str:
"""Return plugin type identifier"""
return "n8n"
@staticmethod
def get_required_config_keys() -> list[str]:
"""Return required configuration keys"""
return ["url", "api_key"]
def __init__(self, config: dict[str, Any], project_id: str | None = None):
"""
Initialize n8n plugin with client.
Args:
config: Configuration dictionary containing:
- url: n8n instance URL
- api_key: n8n API key
project_id: Optional project ID (auto-generated if not provided)
"""
super().__init__(config, project_id=project_id)
# Create n8n API client
self.client = N8nClient(site_url=config["url"], api_key=config["api_key"])
@staticmethod
def get_tool_specifications() -> list[dict[str, Any]]:
"""
Return all tool specifications for ToolGenerator.
This method is called by ToolGenerator to create unified tools
with site parameter routing.
Returns:
List of tool specification dictionaries (56 tools total)
"""
specs = []
# Collect specifications from all handlers
specs.extend(handlers.workflows.get_tool_specifications()) # 14 tools
specs.extend(handlers.executions.get_tool_specifications()) # 8 tools
specs.extend(handlers.credentials.get_tool_specifications()) # 5 tools
specs.extend(handlers.tags.get_tool_specifications()) # 6 tools
specs.extend(handlers.users.get_tool_specifications()) # 5 tools
specs.extend(handlers.projects.get_tool_specifications()) # 8 tools [Enterprise]
specs.extend(handlers.variables.get_tool_specifications()) # 6 tools [Enterprise]
specs.extend(handlers.system.get_tool_specifications()) # 4 tools
return specs
def __getattr__(self, name: str):
"""
Dynamically delegate method calls to appropriate handlers.
This allows ToolGenerator to call methods like plugin.list_workflows()
without explicitly defining each method.
Args:
name: Method name being called
Returns:
Handler function from the appropriate handler module
"""
# Try to find the method in handler modules
handler_modules = [
handlers.workflows,
handlers.executions,
handlers.credentials,
handlers.tags,
handlers.users,
handlers.projects,
handlers.variables,
handlers.system,
]
for handler_module in handler_modules:
if hasattr(handler_module, name):
func = getattr(handler_module, name)
# Create wrapper that passes self.client
async def wrapper(_func=func, **kwargs):
return await _func(self.client, **kwargs)
return wrapper
# Method not found in any handler
raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
async def check_health(self) -> dict[str, Any]:
"""
Check if n8n instance is accessible (internal use).
Note: This is named check_health to avoid shadowing the handler's
health_check function which is exposed as an MCP tool.
Returns:
Dict containing health check result
"""
try:
result = await self.client.health_check()
return {
"healthy": result.get("healthy", False),
"message": f"n8n instance at {self.client.site_url} is {'accessible' if result.get('healthy') else 'not accessible'}",
}
except Exception as e:
return {"healthy": False, "message": f"n8n health check failed: {str(e)}"}
async def health_check(self, **kwargs) -> str:
"""
Override BasePlugin.health_check to use handler function.
This ensures the MCP tool returns a JSON string, not a Dict.
"""
return await handlers.system.health_check(self.client)
