snow-flow 2.6.3 → 2.6.5

package/dist/mcp/servicenow-automation-mcp-refactored.js

@@ -1,632 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * servicenow-automation MCP Server - REFACTORED
- * Uses BaseMCPServer to eliminate code duplication
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowAutomationMCP = void 0;
-const base_mcp_server_js_1 = require("./base-mcp-server.js");
-class ServiceNowAutomationMCP extends base_mcp_server_js_1.BaseMCPServer {
-    constructor() {
-        super({
-            name: 'servicenow-automation',
-            version: '2.0.0',
-            description: 'Handles scheduled tasks, events, and automated processes'
-        });
-    }
-    setupTools() {
-        // Tools are defined in getTools() method
-    }
-    getTools() {
-        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']
-                }
-            }
-        ];
-    }
-    async executeTool(name, args) {
-        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
-    async handleSnowCreateScheduledJob(args) {
-        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
-            };
-        }
-    }
-    async handleSnowCreateEventRule(args) {
-        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
-            };
-        }
-    }
-    async handleSnowCreateNotification(args) {
-        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
-            };
-        }
-    }
-    async handleSnowCreateSlaDefinition(args) {
-        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
-            };
-        }
-    }
-    async handleSnowCreateEscalationRule(args) {
-        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
-            };
-        }
-    }
-    async handleSnowCreateWorkflowActivity(args) {
-        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
-            };
-        }
-    }
-    async handleSnowDiscoverSchedules(args) {
-        const startTime = Date.now();
-        try {
-            const schedules = [];
-            // Discover schedules
-            const scheduleResponse = await this.client.searchRecords('cmn_schedule', '', 50);
-            if (scheduleResponse.success && scheduleResponse.data) {
-                schedules.push(...scheduleResponse.data.result.map((schedule) => ({
-                    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
-            };
-        }
-    }
-    async handleSnowDiscoverEvents(args) {
-        const startTime = Date.now();
-        try {
-            const events = [];
-            // 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) => ({
-                    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
-            };
-        }
-    }
-    async handleSnowDiscoverAutomationJobs(args) {
-        const startTime = Date.now();
-        try {
-            const jobs = [];
-            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) => ({
-                    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) => ({
-                    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
-            };
-        }
-    }
-    async handleSnowTestScheduledJob(args) {
-        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;
-            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
-    parseScheduleType(schedule) {
-        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';
-    }
-    parseScheduleTime(schedule) {
-        // 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';
-    }
-}
-exports.ServiceNowAutomationMCP = ServiceNowAutomationMCP;
-// Create and run the server
-if (require.main === module) {
-    const server = new ServiceNowAutomationMCP();
-    server.start().catch(console.error);
-}
-//# sourceMappingURL=servicenow-automation-mcp-refactored.js.map