snow-flow 1.4.49 → 2.0.0

package/src/mcp/servicenow-automation-mcp-refactored.ts

@@ -0,0 +1,678 @@
+#!/usr/bin/env node
+/**
+ * servicenow-automation MCP Server - REFACTORED
+ * Uses BaseMCPServer to eliminate code duplication
+ */
+
+import { BaseMCPServer, ToolResult } from './base-mcp-server.js';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+
+export class ServiceNowAutomationMCP extends BaseMCPServer {
+  constructor() {
+    super({
+      name: 'servicenow-automation',
+      version: '2.0.0',
+      description: 'Handles scheduled tasks, events, and automated processes'
+    });
+  }
+
+  protected setupTools(): void {
+    // Tools are defined in getTools() method
+  }
+
+  protected getTools(): Tool[] {
+    return [
+      {
+        name: 'snow_create_scheduled_job',
+        description: 'Create Scheduled Job with dynamic schedule discovery - NO hardcoded values',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Scheduled Job name' },
+            script: { type: 'string', description: 'JavaScript code to execute' },
+            description: { type: 'string', description: 'Job description' },
+            schedule: { type: 'string', description: 'Schedule pattern (daily, weekly, monthly, or cron)' },
+            active: { type: 'boolean', description: 'Job active status' },
+            runAsUser: { type: 'string', description: 'User to run job as' },
+            timeZone: { type: 'string', description: 'Time zone for execution' }
+          },
+          required: ['name', 'script', 'schedule']
+        }
+      },
+      {
+        name: 'snow_create_event_rule',
+        description: 'Create Event Rule with dynamic event discovery - NO hardcoded values',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Event Rule name' },
+            eventName: { type: 'string', description: 'Event name to listen for' },
+            condition: { type: 'string', description: 'Event condition script' },
+            script: { type: 'string', description: 'Action script to execute' },
+            description: { type: 'string', description: 'Rule description' },
+            active: { type: 'boolean', description: 'Rule active status' },
+            order: { type: 'number', description: 'Execution order' }
+          },
+          required: ['name', 'eventName', 'script']
+        }
+      },
+      {
+        name: 'snow_create_notification',
+        description: 'Create Notification with dynamic template discovery - NO hardcoded values',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Notification name' },
+            table: { type: 'string', description: 'Table to monitor' },
+            when: { type: 'string', description: 'When to send (inserted, updated, deleted)' },
+            condition: { type: 'string', description: 'Condition script' },
+            recipients: { type: 'string', description: 'Recipient specification' },
+            subject: { type: 'string', description: 'Email subject' },
+            message: { type: 'string', description: 'Email message body' },
+            active: { type: 'boolean', description: 'Notification active status' }
+          },
+          required: ['name', 'table', 'when', 'recipients', 'subject', 'message']
+        }
+      },
+      {
+        name: 'snow_create_sla_definition',
+        description: 'Create SLA Definition with dynamic field discovery - NO hardcoded values',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'SLA Definition name' },
+            table: { type: 'string', description: 'Table to apply SLA to' },
+            condition: { type: 'string', description: 'SLA condition script' },
+            duration: { type: 'string', description: 'Duration specification' },
+            durationType: { type: 'string', description: 'Duration type (business, calendar)' },
+            schedule: { type: 'string', description: 'Schedule to use' },
+            active: { type: 'boolean', description: 'SLA active status' },
+            description: { type: 'string', description: 'SLA description' }
+          },
+          required: ['name', 'table', 'condition', 'duration']
+        }
+      },
+      {
+        name: 'snow_create_escalation_rule',
+        description: 'Create Escalation Rule with dynamic escalation discovery - NO hardcoded values',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Escalation Rule name' },
+            table: { type: 'string', description: 'Table to monitor' },
+            condition: { type: 'string', description: 'Escalation condition' },
+            escalationTime: { type: 'number', description: 'Escalation time in minutes' },
+            escalationScript: { type: 'string', description: 'Escalation action script' },
+            active: { type: 'boolean', description: 'Rule active status' },
+            order: { type: 'number', description: 'Execution order' },
+            description: { type: 'string', description: 'Rule description' }
+          },
+          required: ['name', 'table', 'condition', 'escalationTime', 'escalationScript']
+        }
+      },
+      {
+        name: 'snow_create_workflow_activity',
+        description: 'Create Workflow Activity with dynamic workflow discovery - NO hardcoded values',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Activity name' },
+            workflowName: { type: 'string', description: 'Parent workflow name' },
+            activityType: { type: 'string', description: 'Activity type' },
+            script: { type: 'string', description: 'Activity script' },
+            condition: { type: 'string', description: 'Activity condition' },
+            order: { type: 'number', description: 'Activity order' },
+            description: { type: 'string', description: 'Activity description' }
+          },
+          required: ['name', 'workflowName', 'activityType']
+        }
+      },
+      {
+        name: 'snow_discover_schedules',
+        description: 'Discover all available schedules dynamically',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            type: { type: 'string', description: 'Filter by schedule type' }
+          }
+        }
+      },
+      {
+        name: 'snow_discover_events',
+        description: 'Discover all available events dynamically',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            table: { type: 'string', description: 'Filter by table' }
+          }
+        }
+      },
+      {
+        name: 'snow_discover_automation_jobs',
+        description: 'Discover all automation jobs dynamically',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            status: { type: 'string', description: 'Filter by status: active, inactive, all' }
+          }
+        }
+      },
+      {
+        name: 'snow_test_scheduled_job',
+        description: 'Test scheduled job execution',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            jobName: { type: 'string', description: 'Scheduled job name to test' }
+          },
+          required: ['jobName']
+        }
+      }
+    ];
+  }
+
+  protected async executeTool(name: string, args: any): Promise<ToolResult> {
+    const startTime = Date.now();
+
+    switch (name) {
+      case 'snow_create_scheduled_job':
+        return await this.handleSnowCreateScheduledJob(args);
+      case 'snow_create_event_rule':
+        return await this.handleSnowCreateEventRule(args);
+      case 'snow_create_notification':
+        return await this.handleSnowCreateNotification(args);
+      case 'snow_create_sla_definition':
+        return await this.handleSnowCreateSlaDefinition(args);
+      case 'snow_create_escalation_rule':
+        return await this.handleSnowCreateEscalationRule(args);
+      case 'snow_create_workflow_activity':
+        return await this.handleSnowCreateWorkflowActivity(args);
+      case 'snow_discover_schedules':
+        return await this.handleSnowDiscoverSchedules(args);
+      case 'snow_discover_events':
+        return await this.handleSnowDiscoverEvents(args);
+      case 'snow_discover_automation_jobs':
+        return await this.handleSnowDiscoverAutomationJobs(args);
+      case 'snow_test_scheduled_job':
+        return await this.handleSnowTestScheduledJob(args);
+      default:
+        return {
+          success: false,
+          error: `Unknown tool: ${name}`
+        };
+    }
+  }
+
+  // Tool handlers
+  private async handleSnowCreateScheduledJob(args: any): Promise<ToolResult> {
+    const startTime = Date.now();
+    try {
+      const jobData = {
+        name: args.name,
+        script: args.script,
+        description: args.description || '',
+        run_type: this.parseScheduleType(args.schedule),
+        run_time: this.parseScheduleTime(args.schedule),
+        active: args.active !== false,
+        run_as: args.runAsUser || 'system',
+        time_zone: args.timeZone || 'UTC'
+      };
+
+      const result = await this.client.createRecord('sysauto_script', jobData);
+      
+      return {
+        success: result.success,
+        result: result.result,
+        error: result.success ? undefined : 'Failed to create scheduled job',
+        executionTime: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to create scheduled job',
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+
+  private async handleSnowCreateEventRule(args: any): Promise<ToolResult> {
+    const startTime = Date.now();
+    try {
+      const ruleData = {
+        name: args.name,
+        event_name: args.eventName,
+        condition: args.condition || '',
+        script: args.script,
+        description: args.description || '',
+        active: args.active !== false,
+        order: args.order || 100
+      };
+
+      const result = await this.client.createRecord('sysevent_script', ruleData);
+      
+      return {
+        success: result.success,
+        result: result.result,
+        error: result.success ? undefined : 'Failed to create event rule',
+        executionTime: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to create event rule',
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+
+  private async handleSnowCreateNotification(args: any): Promise<ToolResult> {
+    const startTime = Date.now();
+    try {
+      const notificationData = {
+        name: args.name,
+        collection: args.table,
+        when: args.when,
+        condition: args.condition || '',
+        recipients: args.recipients,
+        subject: args.subject,
+        message_html: args.message,
+        active: args.active !== false
+      };
+
+      const result = await this.client.createRecord('sysevent_email_action', notificationData);
+      
+      return {
+        success: result.success,
+        result: result.result,
+        error: result.success ? undefined : 'Failed to create notification',
+        executionTime: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to create notification',
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+
+  private async handleSnowCreateSlaDefinition(args: any): Promise<ToolResult> {
+    const startTime = Date.now();
+    try {
+      const slaData = {
+        name: args.name,
+        collection: args.table,
+        start_condition: args.condition,
+        duration: args.duration,
+        duration_type: args.durationType || 'business',
+        schedule: args.schedule || '',
+        active: args.active !== false,
+        short_description: args.description || ''
+      };
+
+      const result = await this.client.createRecord('contract_sla', slaData);
+      
+      return {
+        success: result.success,
+        result: result.result,
+        error: result.success ? undefined : 'Failed to create SLA definition',
+        executionTime: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to create SLA definition',
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+
+  private async handleSnowCreateEscalationRule(args: any): Promise<ToolResult> {
+    const startTime = Date.now();
+    try {
+      const escalationData = {
+        name: args.name,
+        table: args.table,
+        condition: args.condition,
+        escalation_time: args.escalationTime,
+        script: args.escalationScript,
+        active: args.active !== false,
+        order: args.order || 100,
+        description: args.description || ''
+      };
+
+      // Note: ServiceNow might use different tables for escalations
+      const result = await this.client.createRecord('sys_trigger', escalationData);
+      
+      return {
+        success: result.success,
+        result: result.result,
+        error: result.success ? undefined : 'Failed to create escalation rule',
+        executionTime: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to create escalation rule',
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+
+  private async handleSnowCreateWorkflowActivity(args: any): Promise<ToolResult> {
+    const startTime = Date.now();
+    try {
+      // First find the parent workflow
+      const workflowResponse = await this.client.searchRecords(
+        'wf_workflow',
+        `name=${args.workflowName}`,
+        1
+      );
+
+      if (!workflowResponse.success || !workflowResponse.data?.result?.length) {
+        throw new Error(`Workflow not found: ${args.workflowName}`);
+      }
+
+      const workflowId = workflowResponse.data.result[0].sys_id;
+
+      const activityData = {
+        workflow_version: workflowId,
+        name: args.name,
+        activity_type: args.activityType,
+        script: args.script || '',
+        condition: args.condition || '',
+        order: args.order || 100,
+        description: args.description || ''
+      };
+
+      const result = await this.client.createRecord('wf_activity', activityData);
+      
+      return {
+        success: result.success,
+        result: result.result,
+        error: result.success ? undefined : 'Failed to create workflow activity',
+        executionTime: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to create workflow activity',
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+
+  private async handleSnowDiscoverSchedules(args: any): Promise<ToolResult> {
+    const startTime = Date.now();
+    try {
+      const schedules: any[] = [];
+
+      // Discover schedules
+      const scheduleResponse = await this.client.searchRecords('cmn_schedule', '', 50);
+      if (scheduleResponse.success && scheduleResponse.data) {
+        schedules.push(...scheduleResponse.data.result.map((schedule: any) => ({
+          name: schedule.name,
+          type: schedule.type,
+          time_zone: schedule.time_zone,
+          description: schedule.description
+        })));
+      }
+
+      return {
+        success: true,
+        result: { schedules },
+        executionTime: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to discover schedules',
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+
+  private async handleSnowDiscoverEvents(args: any): Promise<ToolResult> {
+    const startTime = Date.now();
+    try {
+      const events: any[] = [];
+
+      // Build query based on table filter
+      let query = '';
+      if (args.table) {
+        query = `table=${args.table}`;
+      }
+
+      // Discover event definitions
+      const eventResponse = await this.client.searchRecords('sysevent', query, 50);
+      if (eventResponse.success && eventResponse.data) {
+        events.push(...eventResponse.data.result.map((event: any) => ({
+          name: event.name,
+          table: event.table,
+          description: event.description,
+          parm1_label: event.parm1,
+          parm2_label: event.parm2
+        })));
+      }
+
+      return {
+        success: true,
+        result: { events },
+        executionTime: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to discover events',
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+
+  private async handleSnowDiscoverAutomationJobs(args: any): Promise<ToolResult> {
+    const startTime = Date.now();
+    try {
+      const jobs: any[] = [];
+      const status = args?.status || 'all';
+
+      // Build query based on status filter
+      let query = '';
+      if (status === 'active') {
+        query = 'active=true';
+      } else if (status === 'inactive') {
+        query = 'active=false';
+      }
+
+      // Discover scheduled jobs
+      const scheduledResponse = await this.client.searchRecords('sysauto_script', query, 50);
+      if (scheduledResponse.success && scheduledResponse.data) {
+        jobs.push(...scheduledResponse.data.result.map((job: any) => ({
+          type: 'scheduled_job',
+          name: job.name,
+          active: job.active,
+          run_type: job.run_type,
+          last_run: job.last_run_time
+        })));
+      }
+
+      // Discover event scripts
+      const eventResponse = await this.client.searchRecords('sysevent_script', query, 50);
+      if (eventResponse.success && eventResponse.data) {
+        jobs.push(...eventResponse.data.result.map((job: any) => ({
+          type: 'event_script',
+          name: job.name,
+          active: job.active,
+          event_name: job.event_name
+        })));
+      }
+
+      return {
+        success: true,
+        result: { jobs },
+        executionTime: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to discover automation jobs',
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+
+  private async handleSnowTestScheduledJob(args: any): Promise<ToolResult> {
+    const startTime = Date.now();
+    try {
+      // Find the scheduled job
+      const jobResponse = await this.client.searchRecords(
+        'sysauto_script',
+        `name=${args.jobName}`,
+        1
+      );
+
+      if (!jobResponse.success || !jobResponse.data?.result?.length) {
+        throw new Error(`Scheduled job not found: ${args.jobName}`);
+      }
+
+      const job = jobResponse.data.result[0];
+
+      // Execute the scheduled job and monitor its execution
+      const executionStartTime = Date.now();
+      let testResult: any;
+      
+      try {
+        // Trigger the scheduled job execution
+        this.logger.info('Triggering scheduled job execution', { 
+          jobName: job.name, 
+          jobId: job.sys_id 
+        });
+        
+        // Method 1: Try to execute via sys_trigger endpoint
+        const triggerResponse = await this.client.post('/api/now/table/sys_trigger', {
+          script: `gs.eventQueue('sysauto.script.execute', null, '${job.sys_id}', '');`,
+          name: `Test execution of ${job.name}`,
+          next_action: new Date(Date.now() + 5000).toISOString() // Execute in 5 seconds
+        });
+
+        if (triggerResponse.result) {
+          this.logger.info('Job execution trigger created', { 
+            triggerId: triggerResponse.result.sys_id 
+          });
+          
+          // Wait a brief moment for execution to begin
+          await new Promise(resolve => setTimeout(resolve, 2000));
+          
+          // Check for recent execution history
+          const executionHistoryResponse = await this.client.get(
+            `/api/now/table/sys_execution_tracker?sysparm_query=source=${job.sys_id}^ORDERBYDESCsys_created_on&sysparm_limit=1`
+          );
+          
+          const realExecutionTime = Date.now() - executionStartTime;
+          
+          if (executionHistoryResponse.result && executionHistoryResponse.result.length > 0) {
+            const execution = executionHistoryResponse.result[0];
+            testResult = {
+              job_name: job.name,
+              job_id: job.sys_id,
+              test_status: 'executed',
+              execution_time: realExecutionTime,
+              trigger_id: triggerResponse.result.sys_id,
+              execution_tracker_id: execution.sys_id,
+              execution_state: execution.state,
+              execution_progress: execution.completion_percentage || 0,
+              message: `Job execution initiated successfully. Trigger created: ${triggerResponse.result.sys_id}`,
+              details: {
+                job_active: job.active,
+                job_script: job.script ? 'Present' : 'Missing',
+                job_condition: job.condition_script || 'None',
+                execution_history_found: true
+              }
+            };
+          } else {
+            testResult = {
+              job_name: job.name,
+              job_id: job.sys_id,
+              test_status: 'triggered',
+              execution_time: realExecutionTime,
+              trigger_id: triggerResponse.result.sys_id,
+              message: `Job execution trigger created successfully. Check sys_execution_tracker for progress.`,
+              details: {
+                job_active: job.active,
+                job_script: job.script ? 'Present' : 'Missing',
+                job_condition: job.condition_script || 'None',
+                execution_history_found: false
+              }
+            };
+          }
+          
+        } else {
+          throw new Error('Failed to create execution trigger');
+        }
+        
+      } catch (executionError) {
+        // If direct execution fails, perform validation instead
+        this.logger.warn('Job execution failed, performing validation instead', {
+          jobName: job.name,
+          error: executionError instanceof Error ? executionError.message : String(executionError)
+        });
+        
+        const realExecutionTime = Date.now() - executionStartTime;
+        
+        testResult = {
+          job_name: job.name,
+          job_id: job.sys_id,
+          test_status: 'validated',
+          execution_time: realExecutionTime,
+          message: `Job validation completed. Execution failed: ${executionError instanceof Error ? executionError.message : String(executionError)}`,
+          details: {
+            job_active: job.active,
+            job_script: job.script ? 'Present' : 'Missing',
+            job_condition: job.condition_script || 'None',
+            job_run_as: job.run_as || 'system',
+            job_schedule: job.run_period || 'Not scheduled',
+            validation_performed: true,
+            execution_attempted: true,
+            execution_error: executionError instanceof Error ? executionError.message : String(executionError)
+          }
+        };
+      }
+
+      return {
+        success: true,
+        result: testResult,
+        executionTime: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to test scheduled job',
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+
+  // Helper methods
+  private parseScheduleType(schedule: string): string {
+    const scheduleLower = schedule.toLowerCase();
+    if (scheduleLower.includes('daily')) return 'daily';
+    if (scheduleLower.includes('weekly')) return 'weekly';
+    if (scheduleLower.includes('monthly')) return 'monthly';
+    if (scheduleLower.includes('cron')) return 'cron';
+    return 'periodically';
+  }
+
+  private parseScheduleTime(schedule: string): string {
+    // Simple parsing - in real implementation would be more sophisticated
+    const timeMatch = schedule.match(/(\d{1,2}):(\d{2})/);
+    if (timeMatch) {
+      return `${timeMatch[1]}:${timeMatch[2]}:00`;
+    }
+    return '00:00:00';
+  }
+}
+
+// Create and run the server
+if (require.main === module) {
+  const server = new ServiceNowAutomationMCP();
+  server.start().catch(console.error);
+}