MCP Console Automation Server

/** * Workflow Template Library * Pre-built templates for common automation scenarios */ import { WorkflowTemplate, WorkflowDefinition, TemplateParameter, TemplateExample, } from '../types/workflow.js'; export class WorkflowTemplateLibrary { private templates: Map<string, WorkflowTemplate>; constructor() { this.templates = new Map(); this.registerBuiltInTemplates(); } /** * Register built-in workflow templates */ private registerBuiltInTemplates(): void { // Deployment pipeline templates this.registerTemplate(this.createCiCdPipelineTemplate()); this.registerTemplate(this.createDockerDeploymentTemplate()); this.registerTemplate(this.createKubernetesDeploymentTemplate()); // Data processing templates this.registerTemplate(this.createDataBackupTemplate()); this.registerTemplate(this.createDataSyncTemplate()); this.registerTemplate(this.createEtlPipelineTemplate()); // System maintenance templates this.registerTemplate(this.createSystemHealthCheckTemplate()); this.registerTemplate(this.createLogRotationTemplate()); this.registerTemplate(this.createDiskCleanupTemplate()); // Incident response templates this.registerTemplate(this.createIncidentResponseTemplate()); this.registerTemplate(this.createSecurityScanTemplate()); this.registerTemplate(this.createAlertEscalationTemplate()); // Development environment templates this.registerTemplate(this.createDevEnvSetupTemplate()); this.registerTemplate(this.createTestingPipelineTemplate()); this.registerTemplate(this.createCodeQualityCheckTemplate()); // Monitoring and alerting templates this.registerTemplate(this.createPerformanceMonitoringTemplate()); this.registerTemplate(this.createUptimeMonitoringTemplate()); this.registerTemplate(this.createResourceUsageAlertTemplate()); // Business process templates this.registerTemplate(this.createReportGenerationTemplate()); this.registerTemplate(this.createDataValidationTemplate()); this.registerTemplate(this.createFileProcessingTemplate()); } /** * CI/CD Pipeline Template */ private createCiCdPipelineTemplate(): WorkflowTemplate { return { id: 'cicd-pipeline', name: 'CI/CD Pipeline', description: 'Automated continuous integration and deployment pipeline', category: 'deployment', version: '1.0.0', definition: { id: '', name: 'CI/CD Pipeline', description: 'Build, test, and deploy application', version: '1.0.0', metadata: { category: 'deployment', environment: ['development', 'staging', 'production'], requiredPermissions: ['git.read', 'docker.build', 'deploy.execute'], estimatedDuration: 600000, // 10 minutes resourceRequirements: { cpu: '2 cores', memory: '4GB', disk: '10GB', network: true, services: ['docker', 'git'], }, dependencies: ['git-repo', 'docker-registry', 'deployment-target'], outputs: [ { name: 'build_status', type: 'string', description: 'Build result status', required: true, }, { name: 'deployment_url', type: 'string', description: 'Deployed application URL', required: false, }, ], }, triggers: [ { id: 'git-push', type: 'webhook', name: 'Git Push Trigger', enabled: true, config: { webhook: { path: '/webhook/git-push', method: 'POST', authentication: { type: 'none', config: {} }, validation: [ { type: 'required', value: 'repository', message: 'Repository field required', }, { type: 'required', value: 'ref', message: 'Git ref required', }, ], }, }, conditions: [ { field: 'ref', operator: 'matches', value: '^refs/heads/(main|master|develop)$', type: 'body', }, ], }, ], variables: [ { name: 'repository_url', type: 'string', required: true, description: 'Git repository URL', }, { name: 'branch', type: 'string', defaultValue: 'main', required: false, description: 'Git branch to deploy', }, { name: 'docker_registry', type: 'string', required: true, description: 'Docker registry URL', }, { name: 'deployment_environment', type: 'string', defaultValue: 'staging', required: false, description: 'Target environment', }, ], tasks: [ { id: 'checkout-code', name: 'Checkout Code', type: 'command', description: 'Clone repository and checkout specific branch', dependsOn: [], executionMode: 'sequential', timeout: 60000, input: { command: 'git', args: [ 'clone', '--branch', '{{branch}}', '{{repository_url}}', './workspace', ], }, metadata: { estimatedDuration: 30000, criticality: 'critical', category: 'source-control', tags: ['git', 'checkout'], }, }, { id: 'install-dependencies', name: 'Install Dependencies', type: 'command', description: 'Install project dependencies', dependsOn: ['checkout-code'], executionMode: 'sequential', timeout: 300000, input: { command: 'npm', args: ['install'], variables: { cwd: './workspace' }, }, metadata: { estimatedDuration: 120000, criticality: 'high', category: 'build', tags: ['npm', 'dependencies'], }, }, { id: 'run-tests', name: 'Run Tests', type: 'command', description: 'Execute test suite', dependsOn: ['install-dependencies'], executionMode: 'sequential', timeout: 300000, input: { command: 'npm', args: ['test'], variables: { cwd: './workspace' }, }, onFailure: [ { type: 'send_notification', config: { message: 'Test suite failed for {{repository_url}}', severity: 'error', channels: ['email', 'slack'], }, }, ], metadata: { estimatedDuration: 180000, criticality: 'critical', category: 'testing', tags: ['test', 'quality'], }, }, { id: 'build-docker-image', name: 'Build Docker Image', type: 'command', description: 'Build Docker image for deployment', dependsOn: ['run-tests'], executionMode: 'sequential', timeout: 600000, input: { command: 'docker', args: [ 'build', '-t', '{{docker_registry}}/{{repository_name}}:{{branch}}-{{timestamp}}', '.', ], variables: { cwd: './workspace', timestamp: '${Date.now()}', }, }, output: { variables: { image_tag: '{{docker_registry}}/{{repository_name}}:{{branch}}-{{timestamp}}', }, }, metadata: { estimatedDuration: 300000, criticality: 'high', category: 'build', tags: ['docker', 'build'], }, }, { id: 'push-image', name: 'Push Docker Image', type: 'command', description: 'Push image to registry', dependsOn: ['build-docker-image'], executionMode: 'sequential', timeout: 300000, input: { command: 'docker', args: ['push', '{{image_tag}}'], }, metadata: { estimatedDuration: 120000, criticality: 'high', category: 'deployment', tags: ['docker', 'registry'], }, }, { id: 'deploy-application', name: 'Deploy Application', type: 'api_call', description: 'Deploy to target environment', dependsOn: ['push-image'], executionMode: 'sequential', timeout: 300000, approval: { configId: 'deployment-approval', context: { environment: '{{deployment_environment}}', image: '{{image_tag}}', }, }, input: { url: '{{deployment_api_url}}/deploy', method: 'POST', headers: { Authorization: 'Bearer {{deployment_token}}', 'Content-Type': 'application/json', }, body: { image: '{{image_tag}}', environment: '{{deployment_environment}}', }, }, output: { variables: { deployment_id: 'data.deployment_id', deployment_url: 'data.url', }, }, onSuccess: [ { type: 'send_notification', config: { message: 'Deployment successful: {{deployment_url}}', severity: 'info', channels: ['slack'], }, }, ], metadata: { estimatedDuration: 180000, criticality: 'critical', category: 'deployment', tags: ['deploy', 'api'], }, }, ], dataFlow: { inputs: [ { name: 'webhook_payload', type: 'object', source: { type: 'variable', config: { name: 'webhook_data' } }, required: true, }, ], outputs: [ { name: 'deployment_result', type: 'object', destination: { type: 'variable', config: { name: 'result' } }, }, ], transformations: [], validations: [], }, errorHandling: { global: { onError: 'notify_and_pause', retryPolicy: { maxAttempts: 2, backoff: 'exponential', initialDelay: 30000, maxDelay: 300000, multiplier: 2, conditions: [], }, notifications: [ { id: 'pipeline-error', name: 'Pipeline Error Alert', channels: [ { type: 'email', config: { recipients: ['devops@company.com'] }, enabled: true, }, ], conditions: [{ event: 'workflow_fail', severity: 'error' }], template: { subject: 'CI/CD Pipeline Failed', body: 'Pipeline failed for {{repository_url}} on branch {{branch}}', format: 'text', }, }, ], }, taskSpecific: {}, }, notifications: [], approvals: [ { id: 'deployment-approval', name: 'Deployment Approval', type: 'conditional', required: true, approvers: [ { type: 'role', identifier: 'release-manager', weight: 1 }, ], timeout: 3600000, // 1 hour conditions: [ { field: 'environment', operator: 'eq', value: 'production' }, ], }, ], timeouts: { workflow: 1800000, // 30 minutes task: 600000, // 10 minutes approval: 3600000, // 1 hour }, retryPolicy: { maxAttempts: 2, backoff: 'exponential', initialDelay: 30000, maxDelay: 300000, multiplier: 2, conditions: [], }, tags: ['cicd', 'deployment', 'automation'], created: new Date(), updated: new Date(), author: 'system', } as Partial<WorkflowDefinition>, parameters: [ { name: 'repository_url', type: 'string', required: true, description: 'Git repository URL to build and deploy', validation: [ { type: 'required', message: 'Repository URL is required' }, { type: 'pattern', value: '^https?://.*\\.git$', message: 'Must be a valid Git repository URL', }, ], }, { name: 'docker_registry', type: 'string', required: true, description: 'Docker registry URL for storing built images', }, { name: 'deployment_environment', type: 'string', required: false, defaultValue: 'staging', description: 'Target deployment environment (staging, production)', }, ], examples: [ { name: 'Node.js Application Deployment', description: 'Deploy a Node.js application to staging', parameters: { repository_url: 'https://github.com/company/app.git', docker_registry: 'registry.company.com', deployment_environment: 'staging', }, }, ], documentation: ` # CI/CD Pipeline Template This template provides a complete continuous integration and deployment pipeline for applications. ## Features - Git repository checkout - Dependency installation - Automated testing - Docker image building and pushing - Deployment with approval gates - Comprehensive error handling and notifications ## Prerequisites - Git access to repository - Docker registry credentials - Deployment API access - Notification channels configured ## Customization You can customize this template by: - Modifying build commands for different tech stacks - Adding additional testing stages - Customizing deployment strategies - Adding security scanning steps `, tags: ['cicd', 'deployment', 'docker', 'git'], author: 'Workflow Template Library', created: new Date(), }; } /** * System Health Check Template */ private createSystemHealthCheckTemplate(): WorkflowTemplate { return { id: 'system-health-check', name: 'System Health Check', description: 'Comprehensive system health monitoring and alerting', category: 'monitoring', version: '1.0.0', definition: { id: '', name: 'System Health Check', description: 'Monitor system resources and services', version: '1.0.0', metadata: { category: 'monitoring', environment: ['production', 'staging'], requiredPermissions: ['system.read', 'service.status'], estimatedDuration: 120000, // 2 minutes resourceRequirements: { cpu: '0.5 cores', memory: '512MB', network: true, }, dependencies: ['system-tools'], outputs: [ { name: 'health_status', type: 'object', description: 'Overall system health', required: true, }, ], }, triggers: [ { id: 'scheduled-check', type: 'schedule', name: 'Periodic Health Check', enabled: true, config: { schedule: { cron: '*/5 * * * *', // Every 5 minutes timezone: 'UTC', }, }, }, ], variables: [ { name: 'cpu_threshold', type: 'number', defaultValue: 80, required: false, description: 'CPU usage alert threshold (%)', }, { name: 'memory_threshold', type: 'number', defaultValue: 85, required: false, description: 'Memory usage alert threshold (%)', }, { name: 'disk_threshold', type: 'number', defaultValue: 90, required: false, description: 'Disk usage alert threshold (%)', }, ], tasks: [ { id: 'check-cpu', name: 'Check CPU Usage', type: 'command', description: 'Monitor CPU utilization', dependsOn: [], executionMode: 'sequential', input: { command: 'top', args: ['-bn1'], variables: { parse_output: true }, }, output: { variables: { cpu_usage: 'parseFloat(data.match(/Cpu\\(s\\):\\s*(\\d+\\.\\d+)%/)[1])', }, }, metadata: { criticality: 'high', category: 'monitoring', tags: ['cpu', 'performance'], }, }, // Additional health check tasks would be defined here ], dataFlow: { inputs: [], outputs: [], transformations: [], validations: [], }, errorHandling: { global: { onError: 'continue', notifications: [], }, taskSpecific: {}, }, notifications: [], approvals: [], timeouts: { workflow: 300000 }, retryPolicy: { maxAttempts: 3, backoff: 'fixed', initialDelay: 10000, conditions: [], }, tags: ['monitoring', 'health', 'system'], created: new Date(), updated: new Date(), author: 'system', } as Partial<WorkflowDefinition>, parameters: [ { name: 'check_interval', type: 'string', required: false, defaultValue: '*/5 * * * *', description: 'Cron expression for check frequency', }, ], examples: [ { name: 'Standard Health Check', description: 'Monitor system every 5 minutes', parameters: { cpu_threshold: 80, memory_threshold: 85, disk_threshold: 90, }, }, ], documentation: 'Automated system health monitoring with configurable thresholds and alerting.', tags: ['monitoring', 'health', 'automation'], author: 'Workflow Template Library', created: new Date(), }; } /** * Data Backup Template */ private createDataBackupTemplate(): WorkflowTemplate { return { id: 'data-backup', name: 'Data Backup Pipeline', description: 'Automated data backup with compression and cloud storage', category: 'data', version: '1.0.0', definition: { id: '', name: 'Data Backup Pipeline', description: 'Backup critical data to cloud storage', version: '1.0.0', metadata: { category: 'data', environment: ['production'], requiredPermissions: ['file.read', 'cloud.write'], estimatedDuration: 1800000, // 30 minutes resourceRequirements: { disk: '20GB', network: true, }, dependencies: ['backup-tools', 'cloud-credentials'], outputs: [], }, triggers: [ { id: 'daily-backup', type: 'schedule', name: 'Daily Backup', enabled: true, config: { schedule: { cron: '0 2 * * *', // Daily at 2 AM timezone: 'UTC', }, }, }, ], variables: [ { name: 'backup_paths', type: 'array', required: true, description: 'Paths to backup', }, { name: 'cloud_bucket', type: 'string', required: true, description: 'Cloud storage bucket', }, { name: 'retention_days', type: 'number', defaultValue: 30, required: false, description: 'Backup retention period', }, ], tasks: [], dataFlow: { inputs: [], outputs: [], transformations: [], validations: [], }, errorHandling: { global: { onError: 'fail' }, taskSpecific: {} }, notifications: [], approvals: [], timeouts: {}, retryPolicy: { maxAttempts: 2, backoff: 'fixed', initialDelay: 60000, conditions: [], }, tags: ['backup', 'data', 'cloud'], created: new Date(), updated: new Date(), author: 'system', } as Partial<WorkflowDefinition>, parameters: [ { name: 'backup_paths', type: 'array', required: true, description: 'List of file/directory paths to backup', }, { name: 'cloud_bucket', type: 'string', required: true, description: 'Cloud storage bucket for backups', }, ], examples: [ { name: 'Database Backup', description: 'Daily backup of database files', parameters: { backup_paths: ['/var/lib/mysql', '/var/lib/postgresql'], cloud_bucket: 'company-backups', }, }, ], documentation: 'Automated backup solution with cloud storage integration.', tags: ['backup', 'data', 'automation'], author: 'Workflow Template Library', created: new Date(), }; } // Additional template creation methods would follow similar patterns... private createDockerDeploymentTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createKubernetesDeploymentTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createDataSyncTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createEtlPipelineTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createLogRotationTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createDiskCleanupTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createIncidentResponseTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createSecurityScanTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createAlertEscalationTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createDevEnvSetupTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createTestingPipelineTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createCodeQualityCheckTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createPerformanceMonitoringTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createUptimeMonitoringTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createResourceUsageAlertTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createReportGenerationTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createDataValidationTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } private createFileProcessingTemplate(): WorkflowTemplate { /* Implementation */ return {} as WorkflowTemplate; } /** * Register a workflow template */ registerTemplate(template: WorkflowTemplate): void { this.templates.set(template.id, template); } /** * Get a template by ID */ getTemplate(templateId: string): WorkflowTemplate | undefined { return this.templates.get(templateId); } /** * Get all templates */ getAllTemplates(): WorkflowTemplate[] { return Array.from(this.templates.values()); } /** * Get templates by category */ getTemplatesByCategory(category: string): WorkflowTemplate[] { return Array.from(this.templates.values()).filter( (template) => template.category === category ); } /** * Search templates by tags */ searchTemplatesByTags(tags: string[]): WorkflowTemplate[] { return Array.from(this.templates.values()).filter((template) => tags.some((tag) => template.tags.includes(tag)) ); } /** * Generate workflow definition from template */ generateWorkflowFromTemplate( templateId: string, parameters: Record<string, any>, customizations?: Partial<WorkflowDefinition> ): WorkflowDefinition { const template = this.templates.get(templateId); if (!template) { throw new Error(`Template not found: ${templateId}`); } // Validate parameters this.validateTemplateParameters(template, parameters); // Generate workflow definition const definition = this.interpolateTemplate( template.definition, parameters ); // Apply customizations if (customizations) { Object.assign(definition, customizations); } // Set required fields definition.id = `${templateId}-${Date.now()}`; definition.name = definition.name || template.name; definition.description = definition.description || template.description; definition.version = definition.version || template.version; definition.created = new Date(); definition.updated = new Date(); return definition as WorkflowDefinition; } /** * Validate template parameters */ private validateTemplateParameters( template: WorkflowTemplate, parameters: Record<string, any> ): void { for (const param of template.parameters) { const value = parameters[param.name]; if (param.required && (value === undefined || value === null)) { throw new Error(`Required parameter missing: ${param.name}`); } if (value !== undefined && param.validation) { for (const rule of param.validation) { if (!this.validateParameterValue(value, rule)) { throw new Error( `Parameter validation failed for ${param.name}: ${rule.message || 'Validation error'}` ); } } } } } /** * Validate parameter value against rule */ private validateParameterValue(value: any, rule: any): boolean { switch (rule.type) { case 'required': return value !== undefined && value !== null && value !== ''; case 'type': return typeof value === rule.value; case 'pattern': return typeof value === 'string' && new RegExp(rule.value).test(value); case 'range': return ( typeof value === 'number' && value >= rule.value[0] && value <= rule.value[1] ); default: return true; } } /** * Interpolate template with parameters */ private interpolateTemplate( template: Partial<WorkflowDefinition>, parameters: Record<string, any> ): Partial<WorkflowDefinition> { const templateStr = JSON.stringify(template); const interpolated = templateStr.replace(/\{\{(\w+)\}\}/g, (match, key) => { return parameters[key] !== undefined ? JSON.stringify(parameters[key]) : match; }); return JSON.parse(interpolated); } /** * Export template as JSON */ exportTemplate(templateId: string): string { const template = this.templates.get(templateId); if (!template) { throw new Error(`Template not found: ${templateId}`); } return JSON.stringify(template, null, 2); } /** * Import template from JSON */ importTemplate(templateJson: string): void { try { const template = JSON.parse(templateJson) as WorkflowTemplate; this.registerTemplate(template); } catch (error: any) { throw new Error(`Failed to import template: ${error.message}`); } } /** * Get template categories */ getCategories(): string[] { const categories = new Set<string>(); for (const template of this.templates.values()) { categories.add(template.category); } return Array.from(categories); } /** * Get all template tags */ getAllTags(): string[] { const tags = new Set<string>(); for (const template of this.templates.values()) { template.tags.forEach((tag) => tags.add(tag)); } return Array.from(tags); } }