snow-flow 2.0.2 → 2.0.3

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

@@ -1,678 +0,0 @@
-#!/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);
-}