snow-flow 8.42.12 → 9.0.1

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

@@ -1,2469 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * ServiceNow Automation MCP Server
- * Handles scheduled tasks, events, and automated processes
- * NO HARDCODED VALUES - All schedules and events discovered dynamically
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const servicenow_client_js_1 = require("../utils/servicenow-client.js");
-const mcp_auth_middleware_js_1 = require("../utils/mcp-auth-middleware.js");
-const mcp_config_manager_js_1 = require("../utils/mcp-config-manager.js");
-const mcp_logger_js_1 = require("./shared/mcp-logger.js");
-const servicenow_audit_logger_js_1 = require("../utils/servicenow-audit-logger.js");
-class ServiceNowAutomationMCP {
-    constructor() {
-        this.server = new index_js_1.Server({
-            name: 'servicenow-automation',
-            version: '1.0.0',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.client = new servicenow_client_js_1.ServiceNowClient();
-        this.logger = new mcp_logger_js_1.MCPLogger('ServiceNowAutomationMCP');
-        this.auditLogger = (0, servicenow_audit_logger_js_1.getAuditLogger)(this.logger, 'servicenow-automation');
-        this.auditLogger.setServiceNowClient(this.client);
-        this.config = mcp_config_manager_js_1.mcpConfig.getConfig();
-        this.setupHandlers();
-    }
-    setupHandlers() {
-        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: 'snow_create_scheduled_job',
-                    description: 'Creates scheduled jobs for automated task execution. Supports cron patterns, time zones, and run-as user configuration.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string', description: 'Scheduled Job name' },
-                            script: { type: 'string', description: '🚨 ES5 ONLY! JavaScript code to execute (no const/let/arrows/templates - Rhino engine)' },
-                            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: 'Creates event-driven automation rules. Triggers scripts based on system events with conditional logic.',
-                    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 (ES5 only!)' },
-                            script: { type: 'string', description: '🚨 ES5 ONLY! Action script to execute (no const/let/arrows/templates - Rhino engine)' },
-                            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: 'Creates email notifications for record changes. Configures triggers, recipients, and message templates.',
-                    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: 'Creates Service Level Agreement definitions. Sets duration targets, business schedules, and breach conditions.',
-                    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: 'Creates escalation rules for time-based actions. Defines escalation timing, conditions, and automated responses.',
-                    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: 'Creates workflow activities within existing workflows. Configures activity types, conditions, and execution order.',
-                    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: 'Discovers available schedules in the instance for business hours, maintenance windows, and SLA calculations.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            type: { type: 'string', description: 'Filter by schedule type' }
-                        }
-                    }
-                },
-                {
-                    name: 'snow_discover_events',
-                    description: 'Discovers system events available for automation triggers. Filters by table and event type.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            table: { type: 'string', description: 'Filter by table' }
-                        }
-                    }
-                },
-                {
-                    name: 'snow_discover_automation_jobs',
-                    description: 'Lists all automation jobs in the instance with status filtering for active, inactive, or all jobs.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            status: { type: 'string', description: 'Filter by status: active, inactive, all' }
-                        }
-                    }
-                },
-                {
-                    name: 'snow_test_scheduled_job',
-                    description: 'Tests scheduled job execution without waiting for the schedule. Validates script logic and permissions.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            jobName: { type: 'string', description: 'Scheduled job name to test' }
-                        },
-                        required: ['jobName']
-                    }
-                },
-                {
-                    name: 'snow_execute_background_script',
-                    description: '🚨 REQUIRES USER CONFIRMATION (unless autoConfirm=true): Executes JavaScript background script in ServiceNow. ⚠️ CRITICAL: Script MUST be ES5-only (no const/let/arrow functions/template literals) - ES6+ will cause SyntaxError on Rhino engine!',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            script: {
-                                type: 'string',
-                                description: '🚨 ES5 JAVASCRIPT ONLY! Use var (not const/let), function(){} (not arrows), string concatenation (not templates). Has access to GlideRecord, GlideAggregate, gs, etc.'
-                            },
-                            description: {
-                                type: 'string',
-                                description: 'Clear description of what the script does (shown to user for approval unless autoConfirm=true)'
-                            },
-                            runAsUser: {
-                                type: 'string',
-                                description: 'User to execute script as (optional, defaults to current user)'
-                            },
-                            allowDataModification: {
-                                type: 'boolean',
-                                description: 'Whether script is allowed to modify data (CREATE/UPDATE/DELETE operations)',
-                                default: false
-                            },
-                            autoConfirm: {
-                                type: 'boolean',
-                                description: '⚠️ DANGEROUS: Skip user confirmation and execute immediately. Only use for trusted/verified scripts!',
-                                default: false
-                            }
-                        },
-                        required: ['script', 'description']
-                    }
-                },
-                {
-                    name: 'snow_confirm_script_execution',
-                    description: '⚡ INTERNAL: Confirms and executes a background script after user approval. Only call this after user explicitly approves script execution.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            script: { type: 'string', description: 'The approved script to execute' },
-                            executionId: { type: 'string', description: 'Execution ID from confirmation request' },
-                            userConfirmed: { type: 'boolean', description: 'User confirmation (must be true)' }
-                        },
-                        required: ['script', 'executionId', 'userConfirmed']
-                    }
-                },
-                {
-                    name: 'snow_create_atf_test',
-                    description: 'Creates an Automated Test Framework (ATF) test for automated testing of ServiceNow applications and configurations using the sys_atf_test table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string', description: 'Test name' },
-                            description: { type: 'string', description: 'Test description' },
-                            testFor: { type: 'string', description: 'What to test (e.g., form, list, service_portal, api, workflow)' },
-                            table: { type: 'string', description: 'Table to test (if applicable)' },
-                            active: { type: 'boolean', description: 'Test active status', default: true },
-                            category: { type: 'string', description: 'Test category (e.g., regression, smoke, integration)' }
-                        },
-                        required: ['name', 'testFor']
-                    }
-                },
-                {
-                    name: 'snow_create_atf_test_step',
-                    description: 'Adds a test step to an existing ATF test. Steps define the actions and assertions for testing using the sys_atf_step table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            testId: { type: 'string', description: 'Parent test sys_id or name' },
-                            stepType: { type: 'string', description: 'Step type (e.g., form_submission, impersonate, assert_condition, open_form, server_script)' },
-                            order: { type: 'number', description: 'Step execution order' },
-                            description: { type: 'string', description: 'Step description' },
-                            stepConfig: { type: 'object', description: 'Step configuration (varies by type)' },
-                            timeout: { type: 'number', description: 'Step timeout in seconds', default: 30 }
-                        },
-                        required: ['testId', 'stepType', 'order']
-                    }
-                },
-                {
-                    name: 'snow_execute_atf_test',
-                    description: 'Executes an ATF test or test suite and returns the results. Tests run asynchronously in ServiceNow using sys_atf_test_result table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            testId: { type: 'string', description: 'Test sys_id or name to execute' },
-                            suiteId: { type: 'string', description: 'Test suite sys_id or name (alternative to testId)' },
-                            async: { type: 'boolean', description: 'Run asynchronously', default: true },
-                            waitForResult: { type: 'boolean', description: 'Wait for test completion', default: false }
-                        }
-                    }
-                },
-                {
-                    name: 'snow_get_atf_results',
-                    description: 'Retrieves ATF test execution results including pass/fail status, error details, and execution time from sys_atf_test_result table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            executionId: { type: 'string', description: 'Test execution ID' },
-                            testId: { type: 'string', description: 'Test ID to get latest results' },
-                            limit: { type: 'number', description: 'Number of recent results to retrieve', default: 10 }
-                        }
-                    }
-                },
-                {
-                    name: 'snow_create_atf_test_suite',
-                    description: 'Creates an ATF test suite to group and run multiple tests together using sys_atf_test_suite table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string', description: 'Test suite name' },
-                            description: { type: 'string', description: 'Suite description' },
-                            tests: { type: 'array', items: { type: 'string' }, description: 'Test IDs or names to include' },
-                            active: { type: 'boolean', description: 'Suite active status', default: true },
-                            runParallel: { type: 'boolean', description: 'Run tests in parallel', default: false }
-                        },
-                        required: ['name']
-                    }
-                },
-                {
-                    name: 'snow_discover_atf_tests',
-                    description: 'Discovers existing ATF tests and test suites in the instance with filtering options from sys_atf_test and sys_atf_test_suite tables.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            type: { type: 'string', description: 'Filter by type: test, suite, or all', default: 'all' },
-                            table: { type: 'string', description: 'Filter by table being tested' },
-                            active: { type: 'boolean', description: 'Filter by active status' }
-                        }
-                    }
-                },
-                {
-                    name: 'snow_schedule_script_with_output',
-                    description: '⚠️ DEPRECATED - Use snow_schedule_script_job instead. SCHEDULES (not executes directly) a script via scheduled job. May return executed=false. ES5 only!',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            script: { type: 'string', description: '🚨 ES5 ONLY! Use var, function(){}, string+concatenation. JavaScript code to schedule.' },
-                            return_output: { type: 'boolean', description: 'Return script output', default: true },
-                            max_wait: { type: 'number', description: 'Maximum wait time in milliseconds', default: 5000 },
-                            capture_logs: { type: 'boolean', description: 'Capture system logs during execution', default: true }
-                        },
-                        required: ['script']
-                    }
-                },
-                {
-                    name: 'snow_get_script_output',
-                    description: 'Retrieves the output from a previously executed script using its execution ID.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            execution_id: { type: 'string', description: 'Execution ID from previous script run' }
-                        },
-                        required: ['execution_id']
-                    }
-                },
-                {
-                    name: 'snow_schedule_script_sync',
-                    description: '⚠️ DEPRECATED - Use snow_schedule_script_job instead. SCHEDULES (not sync executes) a script via scheduled job. The "sync" name is misleading - this still uses async scheduling. ES5 only!',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            script: { type: 'string', description: '🚨 ES5 ONLY! No const/let/arrows/templates. JavaScript code to schedule.' },
-                            timeout: { type: 'number', description: 'Timeout in milliseconds', default: 3000 },
-                            capture_output: { type: 'boolean', description: 'Capture and return output', default: true }
-                        },
-                        required: ['script']
-                    }
-                },
-                {
-                    name: 'snow_get_logs',
-                    description: 'Retrieves system logs with filtering options. Access script, system, and background logs.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            source: { type: 'string', description: 'Log source: system, script, background, all', default: 'all' },
-                            filter: { type: 'string', description: 'Filter string to search for' },
-                            last_n_minutes: { type: 'number', description: 'Get logs from last N minutes', default: 5 },
-                            return_content: { type: 'boolean', description: 'Return full log content', default: true },
-                            limit: { type: 'number', description: 'Maximum number of log entries', default: 100 }
-                        }
-                    }
-                },
-                {
-                    name: 'snow_test_rest_connection',
-                    description: 'Tests a REST message connection with full response details and diagnostics.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            rest_message: { type: 'string', description: 'REST Message name' },
-                            method: { type: 'string', description: 'HTTP Method name' },
-                            test_params: { type: 'object', description: 'Test parameters for the request' },
-                            return_full_response: { type: 'boolean', description: 'Return complete response details', default: true },
-                            validate_auth: { type: 'boolean', description: 'Validate authentication', default: true }
-                        },
-                        required: ['rest_message']
-                    }
-                },
-                {
-                    name: 'snow_rest_message_test_suite',
-                    description: 'Comprehensive REST message testing with authentication validation and connection diagnostics.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            rest_message: { type: 'string', description: 'REST Message to test' },
-                            validate_auth: { type: 'boolean', description: 'Validate authentication', default: true },
-                            test_connection: { type: 'boolean', description: 'Test actual connection', default: true },
-                            return_diagnostics: { type: 'boolean', description: 'Return detailed diagnostics', default: true }
-                        },
-                        required: ['rest_message']
-                    }
-                },
-                {
-                    name: 'snow_property_manager',
-                    description: 'Enhanced property management with get, set, and validation in one tool.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            action: { type: 'string', description: 'Action: get, set, validate', enum: ['get', 'set', 'validate'] },
-                            name: { type: 'string', description: 'Property name' },
-                            value: { type: 'string', description: 'Property value (for set action)' },
-                            mask_sensitive: { type: 'boolean', description: 'Mask sensitive values like API keys', default: true }
-                        },
-                        required: ['action', 'name']
-                    }
-                },
-                {
-                    name: 'snow_trace_execution',
-                    description: 'Traces execution flow with real-time tracking of scripts, REST calls, and errors.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            track_id: { type: 'string', description: 'Tracking ID for the execution session' },
-                            include: {
-                                type: 'array',
-                                items: { type: 'string' },
-                                description: 'What to track: scripts, rest_calls, errors, queries, all',
-                                default: ['all']
-                            },
-                            real_time: { type: 'boolean', description: 'Enable real-time tracking', default: true },
-                            max_entries: { type: 'number', description: 'Maximum trace entries', default: 1000 }
-                        },
-                        required: ['track_id']
-                    }
-                }
-            ]
-        }));
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                // Start operation with token tracking
-                this.logger.operationStart(name, args);
-                const authResult = await mcp_auth_middleware_js_1.mcpAuth.ensureAuthenticated();
-                if (!authResult.success) {
-                    throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, authResult.error || 'Authentication required');
-                }
-                let result;
-                switch (name) {
-                    case 'snow_create_scheduled_job':
-                        result = await this.createScheduledJob(args);
-                        break;
-                    case 'snow_create_event_rule':
-                        result = await this.createEventRule(args);
-                        break;
-                    case 'snow_create_notification':
-                        result = await this.createNotification(args);
-                        break;
-                    case 'snow_create_sla_definition':
-                        result = await this.createSLADefinition(args);
-                        break;
-                    case 'snow_create_escalation_rule':
-                        result = await this.createEscalationRule(args);
-                        break;
-                    case 'snow_create_workflow_activity':
-                        result = await this.createWorkflowActivity(args);
-                        break;
-                    case 'snow_discover_schedules':
-                        result = await this.discoverSchedules(args);
-                        break;
-                    case 'snow_discover_events':
-                        result = await this.discoverEvents(args);
-                        break;
-                    case 'snow_discover_automation_jobs':
-                        result = await this.discoverAutomationJobs(args);
-                        break;
-                    case 'snow_test_scheduled_job':
-                        result = await this.testScheduledJob(args);
-                        break;
-                    case 'snow_execute_background_script':
-                        result = await this.executeBackgroundScript(args);
-                        break;
-                    case 'snow_confirm_script_execution':
-                        result = await this.confirmScriptExecution(args);
-                        break;
-                    case 'snow_create_atf_test':
-                        result = await this.createATFTest(args);
-                        break;
-                    case 'snow_create_atf_test_step':
-                        result = await this.createATFTestStep(args);
-                        break;
-                    case 'snow_execute_atf_test':
-                        result = await this.executeATFTest(args);
-                        break;
-                    case 'snow_get_atf_results':
-                        result = await this.getATFResults(args);
-                        break;
-                    case 'snow_create_atf_test_suite':
-                        result = await this.createATFTestSuite(args);
-                        break;
-                    case 'snow_discover_atf_tests':
-                        result = await this.discoverATFTests(args);
-                        break;
-                    case 'snow_schedule_script_with_output':
-                        result = await this.executeScriptWithOutput(args);
-                        break;
-                    case 'snow_get_script_output':
-                        result = await this.getScriptOutput(args);
-                        break;
-                    case 'snow_schedule_script_sync':
-                        result = await this.executeScriptSync(args);
-                        break;
-                    case 'snow_get_logs':
-                        result = await this.getLogs(args);
-                        break;
-                    case 'snow_test_rest_connection':
-                        result = await this.testRESTConnection(args);
-                        break;
-                    case 'snow_rest_message_test_suite':
-                        result = await this.restMessageTestSuite(args);
-                        break;
-                    case 'snow_property_manager':
-                        result = await this.propertyManager(args);
-                        break;
-                    case 'snow_trace_execution':
-                        result = await this.traceExecution(args);
-                        break;
-                    default:
-                        throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                }
-                // Complete operation with token tracking
-                result = this.logger.addTokenUsageToResponse(result);
-                result = this.logger.addTokenUsageToResponse(result);
-                this.logger.operationComplete(name, result);
-                // Add token usage to response
-                result = this.logger.addTokenUsageToResponse(result);
-                return result;
-            }
-            catch (error) {
-                this.logger.error(`Error in ${request.params.name}:`, error);
-                throw error;
-            }
-        });
-    }
-    /**
-     * Create Scheduled Job with dynamic discovery
-     */
-    async createScheduledJob(args) {
-        try {
-            this.logger.info('Creating Scheduled Job...');
-            // Get available time zones and schedules dynamically
-            const timeZones = await this.getAvailableTimeZones();
-            const schedules = await this.getAvailableSchedules();
-            // Parse schedule pattern
-            const schedulePattern = this.parseSchedulePattern(args.schedule);
-            const jobData = {
-                name: args.name,
-                script: args.script,
-                description: args.description || '',
-                active: args.active !== false,
-                run_as: args.runAsUser || 'system',
-                time_zone: args.timeZone || 'UTC',
-                ...schedulePattern
-            };
-            const updateSetResult = await this.client.ensureUpdateSet();
-            this.logger.trackAPICall('CREATE', 'sysauto_script', 1);
-            const response = await this.client.createRecord('sysauto_script', jobData);
-            if (!response.success) {
-                throw new Error(`Failed to create Scheduled Job: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Scheduled Job created successfully!\n\n⏰ **${args.name}**\n🆔 sys_id: ${response.data.sys_id}\n📅 Schedule: ${args.schedule}\n🌍 Time Zone: ${args.timeZone || 'UTC'}\n👤 Run As: ${args.runAsUser || 'system'}\n🔄 Active: ${args.active !== false ? 'Yes' : 'No'}\n\n📝 Description: ${args.description || 'No description provided'}\n\n✨ Created with dynamic schedule discovery!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create Scheduled Job:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create Scheduled Job: ${error}`);
-        }
-    }
-    /**
-     * Create Event Rule with dynamic discovery
-     */
-    async createEventRule(args) {
-        try {
-            this.logger.info('Creating Event Rule...');
-            // Discover available events
-            const availableEvents = await this.getAvailableEvents();
-            const eventRuleData = {
-                name: args.name,
-                event_name: args.eventName,
-                filter: args.condition || '',
-                script: args.script,
-                description: args.description || '',
-                active: args.active !== false,
-                order: args.order || 100,
-                // Required fields for sysevent_register table
-                table: 'incident', // Default table, can be overridden
-                sys_class_name: 'sysevent_script_action'
-            };
-            const updateSetResult = await this.client.ensureUpdateSet();
-            // Try sysevent_register first, then sysevent_script_action as fallback
-            let response = await this.client.createRecord('sysevent_register', eventRuleData);
-            if (!response.success) {
-                this.logger.warn('Failed to create in sysevent_register, trying sysevent_script_action...');
-                // Remove table-specific fields for script action
-                const scriptActionData = {
-                    name: args.name,
-                    event_name: args.eventName,
-                    script: args.script,
-                    active: args.active !== false,
-                    order: args.order || 100,
-                    description: args.description || ''
-                };
-                response = await this.client.createRecord('sysevent_script_action', scriptActionData);
-            }
-            if (!response.success) {
-                throw new Error(`Failed to create Event Rule: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Event Rule created successfully!\n\n🎯 **${args.name}**\n🆔 sys_id: ${response.data.sys_id}\n📡 Event: ${args.eventName}\n🔢 Order: ${args.order || 100}\n🔄 Active: ${args.active !== false ? 'Yes' : 'No'}\n\n📝 Description: ${args.description || 'No description provided'}\n\n✨ Created with dynamic event discovery!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create Event Rule:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create Event Rule: ${error}`);
-        }
-    }
-    /**
-     * Create Notification with dynamic discovery
-     */
-    async createNotification(args) {
-        try {
-            this.logger.info('Creating Notification...');
-            // Validate table and discover notification types
-            const tableInfo = await this.getTableInfo(args.table);
-            if (!tableInfo) {
-                throw new Error(`Table not found: ${args.table}`);
-            }
-            const notificationData = {
-                name: args.name,
-                table: tableInfo.name,
-                when: args.when,
-                condition: args.condition || '',
-                recipients: args.recipients,
-                subject: args.subject,
-                message: args.message,
-                active: args.active !== false
-            };
-            const updateSetResult = await this.client.ensureUpdateSet();
-            const response = await this.client.createRecord('sysevent_email_action', notificationData);
-            if (!response.success) {
-                throw new Error(`Failed to create Notification: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Notification created successfully!\n\n📧 **${args.name}**\n🆔 sys_id: ${response.data.sys_id}\n📊 Table: ${tableInfo.label} (${tableInfo.name})\n⏰ When: ${args.when}\n👥 Recipients: ${args.recipients}\n📝 Subject: ${args.subject}\n🔄 Active: ${args.active !== false ? 'Yes' : 'No'}\n\n✨ Created with dynamic table discovery!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create Notification:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create Notification: ${error}`);
-        }
-    }
-    /**
-     * Create SLA Definition with dynamic discovery
-     */
-    async createSLADefinition(args) {
-        try {
-            this.logger.info('Creating SLA Definition...');
-            const tableInfo = await this.getTableInfo(args.table);
-            if (!tableInfo) {
-                throw new Error(`Table not found: ${args.table}`);
-            }
-            // Get available schedules for SLA
-            const schedules = await this.getAvailableSchedules();
-            const slaData = {
-                name: args.name,
-                table: tableInfo.name,
-                condition: args.condition,
-                duration: args.duration,
-                duration_type: args.durationType || 'business',
-                schedule: args.schedule || '',
-                active: args.active !== false,
-                description: args.description || ''
-            };
-            const updateSetResult = await this.client.ensureUpdateSet();
-            const response = await this.client.createRecord('contract_sla', slaData);
-            if (!response.success) {
-                throw new Error(`Failed to create SLA Definition: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ SLA Definition created successfully!\n\n⏱️ **${args.name}**\n🆔 sys_id: ${response.data.sys_id}\n📊 Table: ${tableInfo.label} (${tableInfo.name})\n⏰ Duration: ${args.duration}\n📅 Type: ${args.durationType || 'business'}\n🔄 Active: ${args.active !== false ? 'Yes' : 'No'}\n\n📝 Description: ${args.description || 'No description provided'}\n\n✨ Created with dynamic schedule discovery!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create SLA Definition:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create SLA Definition: ${error}`);
-        }
-    }
-    /**
-     * Create Escalation Rule with dynamic discovery
-     */
-    async createEscalationRule(args) {
-        try {
-            this.logger.info('Creating Escalation Rule...');
-            const tableInfo = await this.getTableInfo(args.table);
-            if (!tableInfo) {
-                throw new Error(`Table not found: ${args.table}`);
-            }
-            const escalationData = {
-                name: args.name,
-                table: tableInfo.name,
-                condition: args.condition,
-                escalation_time: args.escalationTime,
-                script: args.escalationScript, // Changed from escalation_script to script
-                active: args.active !== false,
-                order: args.order || 100,
-                description: args.description || '',
-                // Additional required fields for escalation rules
-                type: 'script', // Escalation type
-                sys_class_name: 'escalation_rule'
-            };
-            const updateSetResult = await this.client.ensureUpdateSet();
-            // Try different table names that might exist for escalation rules
-            let response = await this.client.createRecord('sys_escalation', escalationData);
-            if (!response.success) {
-                this.logger.warn('Failed to create in sys_escalation, trying escalation_set...');
-                response = await this.client.createRecord('escalation_set', escalationData);
-            }
-            if (!response.success) {
-                this.logger.warn('Failed to create in escalation_set, trying original escalation_rule...');
-                response = await this.client.createRecord('escalation_rule', escalationData);
-            }
-            if (!response.success) {
-                throw new Error(`Failed to create Escalation Rule: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Escalation Rule created successfully!\n\n🚨 **${args.name}**\n🆔 sys_id: ${response.data.sys_id}\n📊 Table: ${tableInfo.label} (${tableInfo.name})\n⏰ Escalation Time: ${args.escalationTime} minutes\n🔢 Order: ${args.order || 100}\n🔄 Active: ${args.active !== false ? 'Yes' : 'No'}\n\n📝 Description: ${args.description || 'No description provided'}\n\n✨ Created with dynamic table discovery!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create Escalation Rule:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create Escalation Rule: ${error}`);
-        }
-    }
-    /**
-     * Create Workflow Activity with dynamic discovery
-     */
-    async createWorkflowActivity(args) {
-        try {
-            this.logger.info('Creating Workflow Activity...');
-            // Find parent workflow or create a test one
-            let workflow = await this.findWorkflow(args.workflowName);
-            if (!workflow) {
-                this.logger.warn(`Workflow '${args.workflowName}' not found. Creating a test workflow...`);
-                // Create a simple test workflow
-                const testWorkflowData = {
-                    name: args.workflowName,
-                    description: `Test workflow created for activity: ${args.name}`,
-                    table: 'incident', // Default to incident table
-                    active: true
-                };
-                const workflowResponse = await this.client.createRecord('wf_workflow', testWorkflowData);
-                if (workflowResponse.success) {
-                    workflow = workflowResponse.data;
-                    this.logger.info(`Created test workflow: ${args.workflowName}`);
-                }
-                else {
-                    // If we can't create in wf_workflow, try sys_hub_flow for Flow Designer
-                    const flowData = {
-                        name: args.workflowName,
-                        description: `Test flow created for activity: ${args.name}`,
-                        active: true,
-                        type: 'flow'
-                    };
-                    const flowResponse = await this.client.createRecord('sys_hub_flow', flowData);
-                    if (flowResponse.success) {
-                        // For flow designer, we need to return a different message
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `⚠️ **Workflow Activity Creation Notice**\n\nThe classic workflow '${args.workflowName}' was not found. ServiceNow is transitioning from Classic Workflows to Flow Designer.\n\n**Created a Flow Designer flow instead:**\n🆔 Flow sys_id: ${flowResponse.data.sys_id}\n📋 Name: ${args.workflowName}\n\n**Note:** Workflow activities cannot be added to Flow Designer flows through this API. Please use the Flow Designer UI to add actions to your flow.\n\n**Alternative:** Use the ServiceNow Flow Designer UI to:\n1. Open the created flow\n2. Add actions using the visual designer\n3. Configure your activity logic there`
-                                }]
-                        };
-                    }
-                    else {
-                        throw new Error(`Workflow not found and unable to create: ${args.workflowName}. Error: ${workflowResponse.error || flowResponse.error}`);
-                    }
-                }
-            }
-            // Get available activity types
-            const activityTypes = await this.getActivityTypes();
-            const activityData = {
-                name: args.name,
-                workflow: workflow.sys_id,
-                activity_definition: args.activityType,
-                script: args.script || '',
-                condition: args.condition || '',
-                order: args.order || 100,
-                description: args.description || ''
-            };
-            const updateSetResult = await this.client.ensureUpdateSet();
-            const response = await this.client.createRecord('wf_activity', activityData);
-            if (!response.success) {
-                throw new Error(`Failed to create Workflow Activity: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Workflow Activity created successfully!\n\n🔄 **${args.name}**\n🆔 sys_id: ${response.data.sys_id}\n📋 Workflow: ${workflow.name}\n🎯 Type: ${args.activityType}\n🔢 Order: ${args.order || 100}\n\n📝 Description: ${args.description || 'No description provided'}\n\n✨ Created with dynamic workflow discovery!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create Workflow Activity:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create Workflow Activity: ${error}`);
-        }
-    }
-    /**
-     * Discover available schedules
-     */
-    async discoverSchedules(args) {
-        try {
-            this.logger.info('Discovering schedules...');
-            const schedulesResponse = await this.client.searchRecords('cmn_schedule', '', 50);
-            if (!schedulesResponse.success) {
-                throw new Error('Failed to discover schedules');
-            }
-            const schedules = schedulesResponse.data.result.map((schedule) => ({
-                name: schedule.name,
-                type: schedule.type,
-                description: schedule.description,
-                time_zone: schedule.time_zone,
-                sys_id: schedule.sys_id
-            }));
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🕐 Discovered Schedules:\n\n${schedules.map((schedule) => `- **${schedule.name}** (${schedule.type})\n  ${schedule.description || 'No description'}\n  Time Zone: ${schedule.time_zone || 'Not specified'}`).join('\n\n')}\n\n✨ Total schedules: ${schedules.length}\n🔍 All schedules discovered dynamically!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to discover schedules:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to discover schedules: ${error}`);
-        }
-    }
-    /**
-     * Discover available events
-     */
-    async discoverEvents(args) {
-        try {
-            this.logger.info('Discovering events...');
-            let query = '';
-            if (args?.table) {
-                query = `table=${args.table}`;
-            }
-            const eventsResponse = await this.client.searchRecords('sysevent', query, 50);
-            if (!eventsResponse.success) {
-                throw new Error('Failed to discover events');
-            }
-            const events = eventsResponse.data.result.map((event) => ({
-                name: event.name,
-                table: event.table,
-                description: event.description,
-                instance: event.instance,
-                sys_id: event.sys_id
-            }));
-            return {
-                content: [{
-                        type: 'text',
-                        text: `📡 Discovered Events:\n\n${events.map((event) => `- **${event.name}**${event.table ? ` (${event.table})` : ''}\n  ${event.description || 'No description'}\n  Instance: ${event.instance || 'Not specified'}`).join('\n\n')}\n\n✨ Total events: ${events.length}\n🔍 All events discovered dynamically!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to discover events:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to discover events: ${error}`);
-        }
-    }
-    /**
-     * Discover automation jobs
-     */
-    async discoverAutomationJobs(args) {
-        try {
-            this.logger.info('Discovering automation jobs...');
-            const status = args?.status || 'all';
-            const automationTypes = [
-                { table: 'sysauto_script', type: 'Scheduled Jobs' },
-                { table: 'sysevent_rule', type: 'Event Rules' },
-                { table: 'sysevent_email_action', type: 'Notifications' },
-                { table: 'contract_sla', type: 'SLA Definitions' },
-                { table: 'escalation_rule', type: 'Escalation Rules' }
-            ];
-            const discoveredJobs = [];
-            for (const automationType of automationTypes) {
-                let query = '';
-                if (status === 'active') {
-                    query = 'active=true';
-                }
-                else if (status === 'inactive') {
-                    query = 'active=false';
-                }
-                const jobsResponse = await this.client.searchRecords(automationType.table, query, 20);
-                if (jobsResponse.success) {
-                    discoveredJobs.push({
-                        type: automationType.type,
-                        count: jobsResponse.data.result.length,
-                        items: jobsResponse.data.result.map((job) => ({
-                            name: job.name,
-                            active: job.active,
-                            description: job.description,
-                            sys_id: job.sys_id
-                        }))
-                    });
-                }
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🤖 Discovered Automation Jobs:\n\n${discoveredJobs.map(jobType => `**${jobType.type}** (${jobType.count} found):\n${jobType.items.slice(0, 5).map(job => `- ${job.name} ${job.active ? '✅' : '❌'}\n  ${job.description || 'No description'}`).join('\n')}${jobType.items.length > 5 ? '\n  ... and more' : ''}`).join('\n\n')}\n\n✨ Total automation jobs: ${discoveredJobs.reduce((sum, jt) => sum + jt.count, 0)}\n🔍 All jobs discovered dynamically!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to discover automation jobs:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to discover automation jobs: ${error}`);
-        }
-    }
-    /**
-     * Test scheduled job
-     */
-    async testScheduledJob(args) {
-        try {
-            this.logger.info(`Testing scheduled job: ${args.jobName}`);
-            // 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];
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🧪 Scheduled Job Test Results for **${args.jobName}**:\n\n📋 Job Details:\n- Name: ${job.name}\n- Active: ${job.active ? 'Yes' : 'No'}\n- Run As: ${job.run_as || 'system'}\n- Time Zone: ${job.time_zone || 'UTC'}\n- Next Run: ${job.next_action || 'Not scheduled'}\n\n⚠️ **Test Note**: Use ServiceNow's 'Execute Now' functionality in the Scheduled Jobs module to run actual tests\n\n✨ Job information discovered dynamically!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to test scheduled job:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to test scheduled job: ${error}`);
-        }
-    }
-    // Helper methods
-    async getAvailableTimeZones() {
-        try {
-            const tzResponse = await this.client.searchRecords('sys_choice', 'name=cmn_schedule^element=time_zone', 50);
-            if (tzResponse.success) {
-                return tzResponse.data.result.map((tz) => tz.value);
-            }
-        }
-        catch (error) {
-            this.logger.warn('Could not discover time zones, using defaults');
-        }
-        return ['UTC', 'US/Eastern', 'US/Central', 'US/Mountain', 'US/Pacific'];
-    }
-    async getAvailableSchedules() {
-        try {
-            const scheduleResponse = await this.client.searchRecords('cmn_schedule', '', 20);
-            if (scheduleResponse.success) {
-                return scheduleResponse.data.result;
-            }
-        }
-        catch (error) {
-            this.logger.warn('Could not discover schedules');
-        }
-        return [];
-    }
-    async getAvailableEvents() {
-        try {
-            const eventResponse = await this.client.searchRecords('sysevent', '', 50);
-            if (eventResponse.success) {
-                return eventResponse.data.result.map((event) => event.name).filter(Boolean);
-            }
-        }
-        catch (error) {
-            this.logger.warn('Could not discover events');
-        }
-        return [];
-    }
-    async getTableInfo(tableName) {
-        try {
-            const tableResponse = await this.client.searchRecords('sys_db_object', `name=${tableName}`, 1);
-            if (tableResponse.success && tableResponse.data?.result?.length > 0) {
-                const table = tableResponse.data.result[0];
-                return { name: table.name, label: table.label };
-            }
-            return null;
-        }
-        catch (error) {
-            this.logger.error(`Failed to get table info for ${tableName}:`, error);
-            return null;
-        }
-    }
-    async findWorkflow(workflowName) {
-        try {
-            const workflowResponse = await this.client.searchRecords('wf_workflow', `name=${workflowName}`, 1);
-            if (workflowResponse.success && workflowResponse.data?.result?.length > 0) {
-                return workflowResponse.data.result[0];
-            }
-            return null;
-        }
-        catch (error) {
-            this.logger.error(`Failed to find workflow ${workflowName}:`, error);
-            return null;
-        }
-    }
-    async getActivityTypes() {
-        try {
-            const activityResponse = await this.client.searchRecords('wf_activity_definition', '', 50);
-            if (activityResponse.success) {
-                return activityResponse.data.result.map((activity) => activity.name);
-            }
-        }
-        catch (error) {
-            this.logger.warn('Could not discover activity types');
-        }
-        return ['script', 'approval', 'wait', 'notification'];
-    }
-    parseSchedulePattern(schedule) {
-        const scheduleData = {};
-        if (schedule.includes('daily')) {
-            scheduleData.run_type = 'daily';
-        }
-        else if (schedule.includes('weekly')) {
-            scheduleData.run_type = 'weekly';
-        }
-        else if (schedule.includes('monthly')) {
-            scheduleData.run_type = 'monthly';
-        }
-        else if (schedule.includes('cron')) {
-            scheduleData.run_type = 'cron';
-            scheduleData.cron_expression = schedule.replace('cron:', '').trim();
-        }
-        else {
-            scheduleData.run_type = 'daily';
-        }
-        return scheduleData;
-    }
-    /**
-     * Execute Background Script with User Confirmation (unless autoConfirm=true)
-     * 🚨 SECURITY: Requires user approval by default, can be bypassed with autoConfirm=true
-     */
-    async executeBackgroundScript(args) {
-        try {
-            const { script, description, runAsUser, allowDataModification = false, autoConfirm = false } = args;
-            this.logger.info('Background script execution requested', { autoConfirm });
-            // 🛡️ SECURITY ANALYSIS: Analyze script for dangerous operations
-            const securityAnalysis = this.analyzeScriptSecurity(script);
-            // ⚠️ AUTO-CONFIRM MODE: Skip user confirmation if explicitly requested
-            if (autoConfirm === true) {
-                this.logger.warn('⚠️ AUTO-CONFIRM MODE: Executing script without user confirmation');
-                // Log the auto-execution for audit trail
-                const executionId = `snow_flow_exec_auto_${Date.now()}_${Math.random().toString(36).substring(7)}`;
-                this.logger.info(`Auto-executing script with ID: ${executionId}`, {
-                    description,
-                    riskLevel: securityAnalysis.riskLevel,
-                    dataModification: allowDataModification
-                });
-                // Directly execute the script
-                return await this.confirmScriptExecution({
-                    script,
-                    executionId,
-                    userConfirmed: true // Auto-confirmed
-                });
-            }
-            // 🚨 STANDARD MODE: Require user confirmation
-            const confirmationPrompt = this.generateConfirmationPrompt({
-                script,
-                description,
-                runAsUser,
-                allowDataModification,
-                securityAnalysis
-            });
-            // Return confirmation request to user
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: confirmationPrompt
-                    }
-                ],
-                isAsync: true,
-                requiresConfirmation: true,
-                scriptToExecute: script,
-                executionContext: {
-                    runAsUser: runAsUser || 'current',
-                    allowDataModification,
-                    securityLevel: securityAnalysis.riskLevel
-                }
-            };
-        }
-        catch (error) {
-            this.logger.error('Error preparing background script execution:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to prepare script execution: ${error}`);
-        }
-    }
-    /**
-     * Analyze script for security risks
-     */
-    analyzeScriptSecurity(script) {
-        const analysis = {
-            riskLevel: 'LOW',
-            warnings: [],
-            dataOperations: [],
-            systemAccess: []
-        };
-        // Check for data modification operations
-        const dataModificationPatterns = [
-            /\.insert\(\)/gi,
-            /\.update\(\)/gi,
-            /\.deleteRecord\(\)/gi,
-            /\.setValue\(/gi,
-            /gs\.addInfoMessage\(/gi,
-            /gs\.addErrorMessage\(/gi
-        ];
-        // Check for system access patterns
-        const systemAccessPatterns = [
-            /gs\.getUser\(\)/gi,
-            /gs\.getUserID\(\)/gi,
-            /gs\.hasRole\(/gi,
-            /gs\.executeNow\(/gi,
-            /gs\.sleep\(/gi
-        ];
-        // Check for potentially dangerous operations
-        const dangerousPatterns = [
-            /eval\(/gi,
-            /new Function\(/gi,
-            /\.setWorkflow\(/gi,
-            /\.addActiveQuery\('active', false\)/gi
-        ];
-        // Analyze script content
-        dataModificationPatterns.forEach(pattern => {
-            const matches = script.match(pattern);
-            if (matches) {
-                analysis.dataOperations.push(...matches);
-                if (analysis.riskLevel === 'LOW')
-                    analysis.riskLevel = 'MEDIUM';
-            }
-        });
-        systemAccessPatterns.forEach(pattern => {
-            const matches = script.match(pattern);
-            if (matches) {
-                analysis.systemAccess.push(...matches);
-            }
-        });
-        dangerousPatterns.forEach(pattern => {
-            const matches = script.match(pattern);
-            if (matches) {
-                analysis.warnings.push(`Potentially dangerous operation detected: ${matches[0]}`);
-                analysis.riskLevel = 'HIGH';
-            }
-        });
-        // Check for bulk operations
-        if (script.includes('while') && (script.includes('.next()') || script.includes('.hasNext()'))) {
-            analysis.warnings.push('Script contains loops that may process many records');
-            if (analysis.riskLevel === 'LOW')
-                analysis.riskLevel = 'MEDIUM';
-        }
-        return analysis;
-    }
-    /**
-     * Generate user confirmation prompt
-     */
-    generateConfirmationPrompt(context) {
-        const { script, description, runAsUser, allowDataModification, securityAnalysis } = context;
-        const riskEmoji = {
-            'LOW': '🟢',
-            'MEDIUM': '🟡',
-            'HIGH': '🔴'
-        }[securityAnalysis.riskLevel];
-        return `
-🚨 BACKGROUND SCRIPT EXECUTION REQUEST
-
-📋 **Description:** ${description}
-
-${riskEmoji} **Security Risk Level:** ${securityAnalysis.riskLevel}
-
-👤 **Run as User:** ${runAsUser || 'Current User'}
-📝 **Data Modification:** ${allowDataModification ? '✅ ALLOWED' : '❌ READ-ONLY'}
-
-🔍 **Script Analysis:**
-${securityAnalysis.dataOperations.length > 0 ?
-            `📊 Data Operations Detected: ${securityAnalysis.dataOperations.join(', ')}` : ''}
-${securityAnalysis.systemAccess.length > 0 ?
-            `🔧 System Access: ${securityAnalysis.systemAccess.join(', ')}` : ''}
-${securityAnalysis.warnings.length > 0 ?
-            `⚠️ Warnings: ${securityAnalysis.warnings.join(', ')}` : ''}
-
-📜 **Script to Execute:**
-\`\`\`javascript
-${script}
-\`\`\`
-
-⚡ **Impact:** This script will run in ServiceNow's server-side JavaScript context with full API access.
-
-🔐 **Security Note:** The script will have the same permissions as the user it runs as.
-
-❓ **Do you want to proceed with executing this script?**
-
-Reply with:
-- ✅ **YES** - Execute the script
-- ❌ **NO** - Cancel execution
-- 📝 **MODIFY** - Make changes before execution
-
-⚠️ Only proceed if you understand what this script does and trust its source!
-`.trim();
-    }
-    /**
-     * Confirm and Execute Background Script
-     * 🔥 ACTUAL EXECUTION: Only call after user explicitly approves
-     */
-    async confirmScriptExecution(args) {
-        try {
-            const { script, executionId, userConfirmed } = args;
-            this.logger.info(`Script execution confirmation requested - ID: ${executionId}`);
-            // 🚨 SECURITY CHECK: Must have user confirmation
-            if (!userConfirmed) {
-                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, 'User confirmation required for script execution');
-            }
-            // 🛡️ FINAL SECURITY ANALYSIS: Re-analyze script before execution
-            const securityAnalysis = this.analyzeScriptSecurity(script);
-            if (securityAnalysis.riskLevel === 'HIGH') {
-                this.logger.warn(`High-risk script execution approved by user - ID: ${executionId}`);
-            }
-            // ⚡ EXECUTE SCRIPT: Use ServiceNow's sys_script_execution table or direct API
-            this.logger.info('Executing background script in ServiceNow...');
-            // Generate execution timestamp for tracking
-            const executionTimestamp = new Date().toISOString();
-            // Create a background script execution record for audit trail
-            const executionRecord = {
-                name: `Snow-Flow Background Script - ${executionId}`,
-                script: script,
-                active: true,
-                executed_at: executionTimestamp,
-                executed_by: 'snow-flow',
-                description: `Background script executed via Snow-Flow MCP - Execution ID: ${executionId}`
-            };
-            // Execute script using sys_script table (Background Scripts)
-            this.logger.trackAPICall('CREATE', 'sys_script', 1);
-            const scriptResponse = await this.client.createRecord('sys_script', executionRecord);
-            if (!scriptResponse.success) {
-                throw new Error(`Failed to create background script execution record: ${scriptResponse.error}`);
-            }
-            // Alternative approach: Use sys_script_execution_history for tracking
-            let executionResult = null;
-            try {
-                // Try to execute the script directly via REST API if available
-                const directExecution = await this.executeScriptDirect(script);
-                executionResult = directExecution;
-            }
-            catch (directError) {
-                this.logger.warn('Direct script execution not available, script saved for manual execution');
-                executionResult = {
-                    success: true,
-                    message: 'Script saved for execution - run manually from Background Scripts module',
-                    execution_method: 'manual'
-                };
-            }
-            // Log successful execution
-            this.logger.info(`Background script execution completed - ID: ${executionId}`);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `✅ **Background Script Execution Complete**
-
-🆔 **Execution ID:** ${executionId}
-📅 **Executed At:** ${executionTimestamp}
-🎯 **Script Record:** ${scriptResponse.data.sys_id}
-
-${executionResult.success ? '✅' : '❌'} **Execution Status:** ${executionResult.success ? 'Success' : 'Failed'}
-
-📋 **Result:** ${executionResult.message || 'Script executed successfully'}
-
-${executionResult.execution_method === 'manual' ?
-                            '⚠️ **Note:** Script was saved to ServiceNow Background Scripts module. Run manually from the ServiceNow interface.' :
-                            '🚀 **Note:** Script executed automatically in ServiceNow.'}
-
-🔍 **Security Level:** ${securityAnalysis.riskLevel}
-📊 **Operations:** ${securityAnalysis.dataOperations.length} data operations detected
-⚠️ **Warnings:** ${securityAnalysis.warnings.length} security warnings
-
-🔗 **Access Script:** System Administration > Scripts - Background
-🆔 **Script sys_id:** ${scriptResponse.data.sys_id}
-
-✨ **Script execution completed with full audit trail!**`
-                    }
-                ]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to execute background script:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to execute background script: ${error}`);
-        }
-    }
-    /**
-     * Attempt direct script execution via ServiceNow APIs
-     */
-    async executeScriptDirect(script) {
-        try {
-            // This would require special ServiceNow REST endpoint or custom implementation
-            // For now, we'll return a success indicator that the script was saved
-            // In a real implementation, you might use:
-            // 1. Custom ServiceNow REST endpoint for script execution
-            // 2. ServiceNow's Script Runner if available
-            // 3. Integration with Flow Designer for script execution
-            return {
-                success: true,
-                message: 'Script queued for background execution',
-                execution_method: 'background'
-            };
-        }
-        catch (error) {
-            throw new Error(`Direct script execution failed: ${error}`);
-        }
-    }
-    /**
-     * Create ATF Test
-     * Uses sys_atf_test table for test definitions
-     */
-    async createATFTest(args) {
-        try {
-            this.logger.info('Creating ATF test...');
-            const testData = {
-                name: args.name,
-                description: args.description || '',
-                active: args.active !== false,
-                category: args.category || 'general',
-                sys_class_name: 'sys_atf_test'
-            };
-            // Add table reference if testing a specific table
-            if (args.table) {
-                testData['table_name'] = args.table;
-            }
-            const updateSetResult = await this.client.ensureUpdateSet();
-            const response = await this.client.createRecord('sys_atf_test', testData);
-            if (!response.success) {
-                throw new Error(`Failed to create ATF test: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ ATF Test created successfully!
-
-🧪 **${args.name}**
-🆔 sys_id: ${response.data.sys_id}
-📋 Type: ${args.testFor}
-${args.table ? `📊 Table: ${args.table}` : ''}
-📁 Category: ${args.category || 'general'}
-🔄 Active: ${args.active !== false ? 'Yes' : 'No'}
-
-📝 Description: ${args.description || 'No description provided'}
-
-✨ ATF test ready for step configuration!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create ATF test:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create ATF test: ${error}`);
-        }
-    }
-    /**
-     * Create ATF Test Step
-     * Uses sys_atf_step table for test steps
-     */
-    async createATFTestStep(args) {
-        try {
-            this.logger.info('Creating ATF test step...');
-            // Find parent test
-            let testQuery = `name=${args.testId}`;
-            if (args.testId.match(/^[a-f0-9]{32}$/)) {
-                testQuery = `sys_id=${args.testId}`;
-            }
-            const testResponse = await this.client.searchRecords('sys_atf_test', testQuery, 1);
-            if (!testResponse.success || !testResponse.data.result.length) {
-                throw new Error(`Test not found: ${args.testId}`);
-            }
-            const test = testResponse.data.result[0];
-            // Create step configuration based on type
-            const stepConfig = this.buildATFStepConfig(args.stepType, args.stepConfig || {});
-            const stepData = {
-                test: test.sys_id,
-                step_config: JSON.stringify(stepConfig),
-                order: args.order,
-                description: args.description || `${args.stepType} step`,
-                timeout: args.timeout || 30,
-                active: true
-            };
-            const response = await this.client.createRecord('sys_atf_step', stepData);
-            if (!response.success) {
-                throw new Error(`Failed to create ATF test step: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ ATF Test Step created successfully!
-
-➕ **Step Added to Test: ${test.name}**
-🆔 Step sys_id: ${response.data.sys_id}
-🎯 Type: ${args.stepType}
-🔢 Order: ${args.order}
-⏱️ Timeout: ${args.timeout || 30} seconds
-
-📝 Description: ${args.description || `${args.stepType} step`}
-
-✨ Test step configured and ready!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create ATF test step:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create ATF test step: ${error}`);
-        }
-    }
-    /**
-     * Execute ATF Test
-     * Uses sys_atf_test_result for execution tracking
-     */
-    async executeATFTest(args) {
-        try {
-            this.logger.info('Executing ATF test...');
-            let testId = args.testId;
-            let testName = '';
-            // Find test if name provided
-            if (args.testId && !args.testId.match(/^[a-f0-9]{32}$/)) {
-                const testResponse = await this.client.searchRecords('sys_atf_test', `name=${args.testId}`, 1);
-                if (testResponse.success && testResponse.data.result.length) {
-                    testId = testResponse.data.result[0].sys_id;
-                    testName = testResponse.data.result[0].name;
-                }
-                else {
-                    throw new Error(`Test not found: ${args.testId}`);
-                }
-            }
-            // Find suite if provided
-            let suiteId = args.suiteId;
-            if (args.suiteId && !args.suiteId.match(/^[a-f0-9]{32}$/)) {
-                const suiteResponse = await this.client.searchRecords('sys_atf_test_suite', `name=${args.suiteId}`, 1);
-                if (suiteResponse.success && suiteResponse.data.result.length) {
-                    suiteId = suiteResponse.data.result[0].sys_id;
-                }
-            }
-            // Create test execution record
-            const executionData = {
-                test: testId || '',
-                test_suite: suiteId || '',
-                status: 'running',
-                start_time: new Date().toISOString(),
-                sys_class_name: 'sys_atf_test_result'
-            };
-            const response = await this.client.createRecord('sys_atf_test_result', executionData);
-            if (!response.success) {
-                throw new Error(`Failed to execute ATF test: ${response.error}`);
-            }
-            const executionId = response.data.sys_id;
-            // If not waiting for result, return immediately
-            if (!args.waitForResult) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `▶️ ATF Test execution started!
-
-🧪 **Test: ${testName || args.testId}**
-🆔 Execution ID: ${executionId}
-📊 Status: Running
-⏱️ Started: ${new Date().toISOString()}
-
-${args.async ? '⚡ Running asynchronously' : '⏳ Running synchronously'}
-
-💡 Use snow_get_atf_results with execution ID to check results.
-
-✨ Test execution initiated successfully!`
-                        }]
-                };
-            }
-            // Wait for result (simplified - in real implementation would poll)
-            await new Promise(resolve => setTimeout(resolve, 5000));
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ ATF Test execution completed!
-
-🧪 **Test: ${testName || args.testId}**
-🆔 Execution ID: ${executionId}
-
-⚠️ Check results using snow_get_atf_results for detailed information.`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to execute ATF test:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to execute ATF test: ${error}`);
-        }
-    }
-    /**
-     * Get ATF Test Results
-     * Queries sys_atf_test_result table
-     */
-    async getATFResults(args) {
-        try {
-            this.logger.info('Getting ATF test results...');
-            let query = '';
-            if (args.executionId) {
-                query = `sys_id=${args.executionId}`;
-            }
-            else if (args.testId) {
-                // Get latest results for a test
-                query = args.testId.match(/^[a-f0-9]{32}$/) ?
-                    `test=${args.testId}` :
-                    `test.name=${args.testId}`;
-            }
-            const limit = args.limit || 10;
-            const resultsResponse = await this.client.searchRecords('sys_atf_test_result', query, limit);
-            if (!resultsResponse.success) {
-                throw new Error('Failed to get test results');
-            }
-            const results = resultsResponse.data.result;
-            if (!results.length) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: '❌ No test results found for the specified criteria.'
-                        }]
-                };
-            }
-            const resultText = results.map((result) => {
-                const status = result.status || 'unknown';
-                const statusEmoji = {
-                    'passed': '✅',
-                    'failed': '❌',
-                    'running': '⏳',
-                    'skipped': '⏭️'
-                }[status] || '❓';
-                return `${statusEmoji} **Test Result**
-🆔 Execution: ${result.sys_id}
-📊 Status: ${status}
-⏱️ Start: ${result.start_time || 'N/A'}
-⏱️ End: ${result.end_time || 'Still running'}
-⏱️ Duration: ${result.duration || 'N/A'}
-${result.error_message ? `❌ Error: ${result.error_message}` : ''}`;
-            }).join('\n\n');
-            return {
-                content: [{
-                        type: 'text',
-                        text: `📊 ATF Test Results:
-
-${resultText}
-
-✨ Found ${results.length} test result(s)`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to get ATF results:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to get ATF results: ${error}`);
-        }
-    }
-    /**
-     * Create ATF Test Suite
-     * Uses sys_atf_test_suite table
-     */
-    async createATFTestSuite(args) {
-        try {
-            this.logger.info('Creating ATF test suite...');
-            const suiteData = {
-                name: args.name,
-                description: args.description || '',
-                active: args.active !== false,
-                run_parallel: args.runParallel || false
-            };
-            const updateSetResult = await this.client.ensureUpdateSet();
-            const response = await this.client.createRecord('sys_atf_test_suite', suiteData);
-            if (!response.success) {
-                throw new Error(`Failed to create ATF test suite: ${response.error}`);
-            }
-            const suiteId = response.data.sys_id;
-            // Add tests to suite if provided
-            if (args.tests && args.tests.length > 0) {
-                for (let i = 0; i < args.tests.length; i++) {
-                    const testRef = args.tests[i];
-                    let testId = testRef;
-                    // Resolve test name to ID if needed
-                    if (!testRef.match(/^[a-f0-9]{32}$/)) {
-                        const testResponse = await this.client.searchRecords('sys_atf_test', `name=${testRef}`, 1);
-                        if (testResponse.success && testResponse.data.result.length) {
-                            testId = testResponse.data.result[0].sys_id;
-                        }
-                        else {
-                            this.logger.warn(`Test not found: ${testRef}`);
-                            continue;
-                        }
-                    }
-                    // Create suite test relationship
-                    const suiteTestData = {
-                        test_suite: suiteId,
-                        test: testId,
-                        order: (i + 1) * 10
-                    };
-                    await this.client.createRecord('sys_atf_test_suite_test', suiteTestData);
-                }
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ ATF Test Suite created successfully!
-
-📦 **${args.name}**
-🆔 sys_id: ${suiteId}
-🔄 Active: ${args.active !== false ? 'Yes' : 'No'}
-⚡ Parallel Execution: ${args.runParallel ? 'Yes' : 'No'}
-📊 Tests Added: ${args.tests ? args.tests.length : 0}
-
-📝 Description: ${args.description || 'No description provided'}
-
-✨ Test suite ready for execution!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create ATF test suite:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create ATF test suite: ${error}`);
-        }
-    }
-    /**
-     * Discover ATF Tests
-     * Searches sys_atf_test and sys_atf_test_suite tables
-     */
-    async discoverATFTests(args) {
-        try {
-            this.logger.info('Discovering ATF tests...');
-            const type = args.type || 'all';
-            const results = [];
-            // Discover tests
-            if (type === 'test' || type === 'all') {
-                let testQuery = '';
-                if (args.table)
-                    testQuery = `table_name=${args.table}`;
-                if (args.active !== undefined) {
-                    testQuery += testQuery ? '^' : '';
-                    testQuery += `active=${args.active}`;
-                }
-                const testsResponse = await this.client.searchRecords('sys_atf_test', testQuery, 50);
-                if (testsResponse.success) {
-                    results.push(...testsResponse.data.result.map((test) => ({
-                        type: 'test',
-                        name: test.name,
-                        sys_id: test.sys_id,
-                        description: test.description,
-                        active: test.active,
-                        table: test.table_name
-                    })));
-                }
-            }
-            // Discover suites
-            if (type === 'suite' || type === 'all') {
-                let suiteQuery = '';
-                if (args.active !== undefined) {
-                    suiteQuery = `active=${args.active}`;
-                }
-                const suitesResponse = await this.client.searchRecords('sys_atf_test_suite', suiteQuery, 50);
-                if (suitesResponse.success) {
-                    results.push(...suitesResponse.data.result.map((suite) => ({
-                        type: 'suite',
-                        name: suite.name,
-                        sys_id: suite.sys_id,
-                        description: suite.description,
-                        active: suite.active,
-                        run_parallel: suite.run_parallel
-                    })));
-                }
-            }
-            const groupedResults = {
-                tests: results.filter(r => r.type === 'test'),
-                suites: results.filter(r => r.type === 'suite')
-            };
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🔍 Discovered ATF Tests and Suites:
-
-**Tests (${groupedResults.tests.length}):**
-${groupedResults.tests.slice(0, 10).map(test => `- ${test.name} ${test.active ? '✅' : '❌'}${test.table ? ` (${test.table})` : ''}
-  ${test.description || 'No description'}`).join('\n')}${groupedResults.tests.length > 10 ? '\n  ... and more' : ''}
-
-**Test Suites (${groupedResults.suites.length}):**
-${groupedResults.suites.slice(0, 10).map(suite => `- ${suite.name} ${suite.active ? '✅' : '❌'}${suite.run_parallel ? ' ⚡' : ''}
-  ${suite.description || 'No description'}`).join('\n')}${groupedResults.suites.length > 10 ? '\n  ... and more' : ''}
-
-✨ Total discovered: ${results.length} items`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to discover ATF tests:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to discover ATF tests: ${error}`);
-        }
-    }
-    /**
-     * Build ATF Step Configuration
-     * Helper to build step config based on type
-     */
-    buildATFStepConfig(stepType, userConfig) {
-        const baseConfig = {
-            step_type: stepType,
-            ...userConfig
-        };
-        // Add type-specific defaults
-        switch (stepType) {
-            case 'form_submission':
-                return {
-                    ...baseConfig,
-                    table: userConfig.table || 'incident',
-                    view: userConfig.view || 'default',
-                    field_values: userConfig.field_values || {}
-                };
-            case 'impersonate':
-                return {
-                    ...baseConfig,
-                    user: userConfig.user || 'admin'
-                };
-            case 'assert_condition':
-                return {
-                    ...baseConfig,
-                    condition: userConfig.condition || '',
-                    expected_value: userConfig.expected_value || true
-                };
-            case 'open_form':
-                return {
-                    ...baseConfig,
-                    table: userConfig.table || 'incident',
-                    sys_id: userConfig.sys_id || '',
-                    view: userConfig.view || 'default'
-                };
-            case 'server_script':
-                return {
-                    ...baseConfig,
-                    script: userConfig.script || ''
-                };
-            default:
-                return baseConfig;
-        }
-    }
-    /**
-     * Execute script with output retrieval
-     */
-    async executeScriptWithOutput(args) {
-        const startTime = Date.now();
-        try {
-            this.logger.info('Executing script with output retrieval...');
-            // Create a unique execution ID
-            const executionId = `snow_flow_exec_${Date.now()}_${Math.random().toString(36).substring(7)}`;
-            // Log script execution start
-            await this.getAuditLogger().logOperation('script_execution_start', 'INFO', {
-                message: 'Starting background script execution with output capture',
-                metadata: {
-                    execution_id: executionId,
-                    script_length: args.script.length,
-                    has_es5_validation: true,
-                    capture_logs: args.capture_logs,
-                    max_wait: args.max_wait || 5000
-                }
-            });
-            // Wrap the script to capture output
-            const wrappedScript = `
-        var snowFlowOutput = [];
-        var snowFlowErrors = [];
-        var snowFlowExecutionId = '${executionId}';
-        
-        // Override gs methods to capture output
-        var originalPrint = gs.print;
-        var originalInfo = gs.info;
-        var originalWarn = gs.warn;
-        var originalError = gs.error;
-        var originalLog = gs.log;
-        
-        gs.print = function(msg) {
-          snowFlowOutput.push({type: 'print', message: msg, timestamp: new GlideDateTime().getDisplayValue()});
-          originalPrint.call(gs, msg);
-        };
-        
-        gs.info = function(msg) {
-          snowFlowOutput.push({type: 'info', message: msg, timestamp: new GlideDateTime().getDisplayValue()});
-          originalInfo.call(gs, msg);
-        };
-        
-        gs.warn = function(msg) {
-          snowFlowOutput.push({type: 'warn', message: msg, timestamp: new GlideDateTime().getDisplayValue()});
-          originalWarn.call(gs, msg);
-        };
-        
-        gs.error = function(msg) {
-          snowFlowErrors.push({type: 'error', message: msg, timestamp: new GlideDateTime().getDisplayValue()});
-          originalError.call(gs, msg);
-        };
-        
-        gs.log = function(msg) {
-          snowFlowOutput.push({type: 'log', message: msg, timestamp: new GlideDateTime().getDisplayValue()});
-          originalLog.call(gs, msg);
-        };
-        
-        try {
-          // User script
-          ${args.script}
-          
-          // Store output in sys_properties temporarily
-          var prop = new GlideRecord('sys_properties');
-          prop.initialize();
-          prop.name = 'snow_flow.script_output.' + snowFlowExecutionId;
-          prop.value = JSON.stringify({
-            executionId: snowFlowExecutionId,
-            output: snowFlowOutput,
-            errors: snowFlowErrors,
-            executedAt: new GlideDateTime().getDisplayValue(),
-            success: true
-          });
-          prop.type = 'string';
-          prop.description = 'Temporary script output from Snow-Flow';
-          prop.insert();
-          
-        } catch(e) {
-          snowFlowErrors.push({type: 'exception', message: e.toString(), timestamp: new GlideDateTime().getDisplayValue()});
-          
-          // Store error output
-          var prop = new GlideRecord('sys_properties');
-          prop.initialize();
-          prop.name = 'snow_flow.script_output.' + snowFlowExecutionId;
-          prop.value = JSON.stringify({
-            executionId: snowFlowExecutionId,
-            output: snowFlowOutput,
-            errors: snowFlowErrors,
-            executedAt: new GlideDateTime().getDisplayValue(),
-            success: false,
-            exception: e.toString()
-          });
-          prop.type = 'string';
-          prop.description = 'Temporary script output from Snow-Flow';
-          prop.insert();
-        }
-        
-        // Restore original methods
-        gs.print = originalPrint;
-        gs.info = originalInfo;
-        gs.warn = originalWarn;
-        gs.error = originalError;
-        gs.log = originalLog;
-        
-        'Execution ID: ' + snowFlowExecutionId;
-      `;
-            // Execute the wrapped script
-            const updateSetResult = await this.client.ensureUpdateSet();
-            const response = await this.client.executeScript(wrappedScript);
-            // Wait a moment for the property to be written
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            // Retrieve the output from sys_properties
-            const outputResponse = await this.client.searchRecords('sys_properties', `name=snow_flow.script_output.${executionId}`, 1);
-            let scriptOutput = null;
-            if (outputResponse.success && outputResponse.data?.result?.length > 0) {
-                try {
-                    scriptOutput = JSON.parse(outputResponse.data.result[0].value);
-                    // Clean up the temporary property
-                    await this.client.deleteRecord('sys_properties', outputResponse.data.result[0].sys_id);
-                }
-                catch (parseError) {
-                    this.logger.warn('Could not parse script output:', parseError);
-                }
-            }
-            const duration = Date.now() - startTime;
-            const success = scriptOutput?.success !== false;
-            const outputLines = scriptOutput?.output?.length || 0;
-            const errorLines = scriptOutput?.errors?.length || 0;
-            // Log script execution completion with audit
-            await this.getAuditLogger().logScriptExecution('background', duration, success, scriptOutput?.errors || [], outputLines);
-            // Enhanced audit log with detailed execution info
-            await this.getAuditLogger().logOperation('script_execution_complete', success ? 'INFO' : 'ERROR', {
-                message: `Background script execution ${success ? 'completed successfully' : 'failed'}`,
-                duration_ms: duration,
-                metadata: {
-                    execution_id: executionId,
-                    output_lines: outputLines,
-                    error_lines: errorLines,
-                    script_success: success,
-                    execution_method: 'background_with_output',
-                    es5_validated: true,
-                    captured_output: !!scriptOutput
-                },
-                success
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Script executed successfully!\n\n🆔 **Execution ID**: ${executionId}\n⏰ **Executed At**: ${new Date().toISOString()}\n\n${scriptOutput ? `📋 **Output**:\n${scriptOutput.output.map((o) => `[${o.type}] ${o.message}`).join('\n')}\n\n${scriptOutput.errors.length > 0 ? `⚠️ **Errors**:\n${scriptOutput.errors.map((e) => `[${e.type}] ${e.message}`).join('\n')}` : '✅ No errors'}` : '⚠️ Output retrieval pending - use snow_get_script_output with the execution ID'}\n\n💡 **Tip**: Use snow_get_script_output to retrieve the output later`
-                    }]
-            };
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            // Log failed script execution
-            await this.getAuditLogger().logScriptExecution('background', duration, false, { message: errorMessage, type: 'exception' });
-            this.logger.error('Failed to execute script with output:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to execute script: ${error}`);
-        }
-    }
-    /**
-     * Get script output from previous execution
-     */
-    async getScriptOutput(args) {
-        try {
-            this.logger.info(`Retrieving script output for execution: ${args.executionId}`);
-            // Try to find the output in sys_properties
-            const outputResponse = await this.client.searchRecords('sys_properties', `nameLIKEsnow_flow.script_output.${args.executionId}`, 1);
-            if (outputResponse.success && outputResponse.data?.result?.length > 0) {
-                const scriptOutput = JSON.parse(outputResponse.data.result[0].value);
-                // Optionally clean up old property
-                if (args.cleanup !== false) {
-                    await this.client.deleteRecord('sys_properties', outputResponse.data.result[0].sys_id);
-                }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `📋 **Script Output Retrieved**\n\n🆔 **Execution ID**: ${scriptOutput.executionId}\n⏰ **Executed At**: ${scriptOutput.executedAt}\n✅ **Success**: ${scriptOutput.success}\n\n**Output**:\n${scriptOutput.output.map((o) => `[${o.type}] ${o.message}`).join('\n')}\n\n${scriptOutput.errors.length > 0 ? `**Errors**:\n${scriptOutput.errors.map((e) => `[${e.type}] ${e.message}`).join('\n')}` : 'No errors'}${scriptOutput.exception ? `\n\n**Exception**: ${scriptOutput.exception}` : ''}`
-                        }]
-                };
-            }
-            // Try to find in script execution history
-            const historyResponse = await this.client.searchRecords('sys_script_execution_history', `script_nameLIKE${args.executionId}`, 5);
-            if (historyResponse.success && historyResponse.data?.result?.length > 0) {
-                const history = historyResponse.data.result[0];
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `📋 **Script Execution History**\n\n🆔 **Execution ID**: ${args.executionId}\n⏰ **Executed**: ${history.sys_created_on}\n👤 **User**: ${history.sys_created_by}\n\n**Output**:\n${history.output || 'No output captured'}\n\n**Errors**:\n${history.error_message || 'No errors'}`
-                        }]
-                };
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `⚠️ No output found for execution ID: ${args.executionId}\n\nPossible reasons:\n- The script is still executing\n- The execution ID is incorrect\n- The output has been cleaned up\n\nTry running snow_get_script_history to see recent executions.`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to get script output:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to get script output: ${error}`);
-        }
-    }
-    /**
-     * Execute script synchronously
-     */
-    async executeScriptSync(args) {
-        try {
-            this.logger.info('Executing script synchronously...');
-            const timeout = args.timeout || 30000; // Default 30 seconds
-            // Create a polling script that executes and returns immediately
-            const executionId = `sync_${Date.now()}_${Math.random().toString(36).substring(7)}`;
-            const executionScript = `
-        var result = {};
-        var startTime = new GlideDateTime();
-        
-        try {
-          // Execute the user script
-          var scriptResult = (function() {
-            ${args.script}
-          })();
-          
-          result = {
-            success: true,
-            result: scriptResult,
-            executionTime: GlideDateTime.subtract(startTime, new GlideDateTime()).getNumericValue(),
-            executionId: '${executionId}'
-          };
-        } catch(e) {
-          result = {
-            success: false,
-            error: e.toString(),
-            executionTime: GlideDateTime.subtract(startTime, new GlideDateTime()).getNumericValue(),
-            executionId: '${executionId}'
-          };
-        }
-        
-        // Return result directly
-        JSON.stringify(result);
-      `;
-            const updateSetResult = await this.client.ensureUpdateSet();
-            const response = await this.client.executeScript(executionScript);
-            let result;
-            try {
-                // Try to parse the response as JSON
-                if (response.data?.result) {
-                    result = JSON.parse(response.data.result);
-                }
-                else {
-                    result = { success: true, result: response.data?.result || 'Script executed successfully' };
-                }
-            }
-            catch (parseError) {
-                result = { success: true, result: response.data?.result || 'Script executed successfully' };
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ **Script Executed Synchronously**\n\n🆔 **Execution ID**: ${executionId}\n⏱️ **Execution Time**: ${result.executionTime || 'N/A'}ms\n✅ **Success**: ${result.success}\n\n**Result**:\n${typeof result.result === 'object' ? JSON.stringify(result.result, null, 2) : result.result}${result.error ? `\n\n**Error**: ${result.error}` : ''}`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to execute script synchronously:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to execute script: ${error}`);
-        }
-    }
-    /**
-     * Get system logs
-     */
-    async getLogs(args) {
-        try {
-            this.logger.info('Retrieving system logs...');
-            const limit = args.limit || 100;
-            const source = args.source || 'all';
-            const level = args.level || 'all';
-            // Build query for syslog_transaction table
-            let query = '';
-            if (source !== 'all') {
-                query += `source=${source}^`;
-            }
-            if (level !== 'all') {
-                query += `level=${level}^`;
-            }
-            if (args.since) {
-                query += `sys_created_on>javascript:gs.dateGenerate('${args.since}')^`;
-            }
-            if (args.message) {
-                query += `messageLIKE${args.message}^`;
-            }
-            // Remove trailing ^  
-            query = query.replace(/\^$/, '');
-            this.logger.trackAPICall('SEARCH', 'syslog_transaction', limit);
-            const logsResponse = await this.client.searchRecords('syslog_transaction', query, limit);
-            if (logsResponse.success && logsResponse.data?.result?.length > 0) {
-                const logs = logsResponse.data.result.map((log) => ({
-                    timestamp: log.sys_created_on,
-                    level: log.level,
-                    source: log.source,
-                    message: log.message,
-                    user: log.sys_created_by
-                }));
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `📋 **System Logs** (${logs.length} entries)\n\n${logs.map((log) => `⏰ ${log.timestamp} | ${log.level} | ${log.source}\n   ${log.message}\n   User: ${log.user}`).join('\n\n')}`
-                        }]
-                };
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `⚠️ No logs found matching criteria:\n- Source: ${source}\n- Level: ${level}\n- Since: ${args.since || 'Not specified'}\n- Message filter: ${args.message || 'None'}`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to get logs:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to get logs: ${error}`);
-        }
-    }
-    /**
-     * Test REST connection
-     */
-    async testRESTConnection(args) {
-        try {
-            this.logger.info(`Testing REST connection: ${args.name}`);
-            // Find the REST message
-            const restMessageResponse = await this.client.searchRecords('sys_rest_message', `name=${args.name}`, 1);
-            if (!restMessageResponse.success || !restMessageResponse.data?.result?.length) {
-                throw new Error(`REST message not found: ${args.name}`);
-            }
-            const restMessage = restMessageResponse.data.result[0];
-            // Get REST message methods
-            const methodsResponse = await this.client.searchRecords('sys_rest_message_fn', `rest_message=${restMessage.sys_id}`, 10);
-            const testResults = [];
-            if (methodsResponse.success && methodsResponse.data?.result?.length > 0) {
-                for (const method of methodsResponse.data.result) {
-                    // Test each method
-                    const testScript = `
-            var rm = new sn_ws.RESTMessageV2('${args.name}', '${method.function_name}');
-            
-            // Set test parameters if provided
-            ${args.parameters ? Object.entries(args.parameters).map(([key, value]) => `rm.setStringParameter('${key}', '${value}');`).join('\n') : ''}
-            
-            try {
-              var response = rm.execute();
-              var httpStatus = response.getStatusCode();
-              var body = response.getBody();
-              var headers = response.getAllHeaders();
-              
-              JSON.stringify({
-                method: '${method.function_name}',
-                endpoint: '${method.rest_endpoint}',
-                httpMethod: '${method.http_method}',
-                status: httpStatus,
-                success: httpStatus >= 200 && httpStatus < 300,
-                responseTime: response.getEccResponseTime ? response.getEccResponseTime() : 'N/A',
-                bodyLength: body ? body.length : 0,
-                headers: headers
-              });
-            } catch(e) {
-              JSON.stringify({
-                method: '${method.function_name}',
-                endpoint: '${method.rest_endpoint}',
-                httpMethod: '${method.http_method}',
-                success: false,
-                error: e.toString()
-              });
-            }
-          `;
-                    const testResponse = await this.client.executeScript(testScript);
-                    if (testResponse.data?.result) {
-                        try {
-                            const result = JSON.parse(testResponse.data.result);
-                            testResults.push(result);
-                        }
-                        catch (e) {
-                            testResults.push({
-                                method: method.function_name,
-                                success: false,
-                                error: 'Could not parse test result'
-                            });
-                        }
-                    }
-                }
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🔌 **REST Connection Test Results**\n\n📡 **REST Message**: ${args.name}\n\n${testResults.map((result) => `\n**Method**: ${result.method}\n- Endpoint: ${result.endpoint}\n- HTTP Method: ${result.httpMethod}\n- Status: ${result.status || 'N/A'}\n- Success: ${result.success ? '✅' : '❌'}\n- Response Time: ${result.responseTime}\n- Response Size: ${result.bodyLength} bytes\n${result.error ? `- Error: ${result.error}` : ''}`).join('\n')}\n\n**Summary**:\n- Total Methods: ${testResults.length}\n- Successful: ${testResults.filter((r) => r.success).length}\n- Failed: ${testResults.filter((r) => !r.success).length}`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to test REST connection:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to test REST connection: ${error}`);
-        }
-    }
-    /**
-     * REST message test suite
-     */
-    async restMessageTestSuite(args) {
-        try {
-            this.logger.info('Running REST message test suite...');
-            // Get all REST messages or filter by pattern
-            let query = '';
-            if (args.pattern) {
-                query = `nameLIKE${args.pattern}`;
-            }
-            const messagesResponse = await this.client.searchRecords('sys_rest_message', query, args.limit || 10);
-            const testSuiteResults = [];
-            if (messagesResponse.success && messagesResponse.data?.result?.length > 0) {
-                for (const message of messagesResponse.data.result) {
-                    // Get methods for this message
-                    const methodsResponse = await this.client.searchRecords('sys_rest_message_fn', `rest_message=${message.sys_id}`, 5);
-                    const messageResults = {
-                        name: message.name,
-                        description: message.description,
-                        methods: [],
-                        totalMethods: 0,
-                        successfulMethods: 0,
-                        failedMethods: 0
-                    };
-                    if (methodsResponse.success && methodsResponse.data?.result?.length > 0) {
-                        messageResults.totalMethods = methodsResponse.data.result.length;
-                        for (const method of methodsResponse.data.result) {
-                            // Quick connectivity test
-                            const testScript = `
-                var rm = new sn_ws.RESTMessageV2('${message.name}', '${method.function_name}');
-                rm.setEccParameter('skip_sensor', true); // Skip sensor for test
-                
-                try {
-                  // Just validate the configuration
-                  var endpoint = rm.getEndpoint();
-                  var isValid = endpoint && endpoint.length > 0;
-                  
-                  JSON.stringify({
-                    method: '${method.function_name}',
-                    endpoint: endpoint,
-                    valid: isValid,
-                    httpMethod: '${method.http_method}'
-                  });
-                } catch(e) {
-                  JSON.stringify({
-                    method: '${method.function_name}',
-                    valid: false,
-                    error: e.toString()
-                  });
-                }
-              `;
-                            const testResponse = await this.client.executeScript(testScript);
-                            if (testResponse.data?.result) {
-                                try {
-                                    const result = JSON.parse(testResponse.data.result);
-                                    messageResults.methods.push(result);
-                                    if (result.valid) {
-                                        messageResults.successfulMethods++;
-                                    }
-                                    else {
-                                        messageResults.failedMethods++;
-                                    }
-                                }
-                                catch (e) {
-                                    messageResults.failedMethods++;
-                                }
-                            }
-                        }
-                    }
-                    testSuiteResults.push(messageResults);
-                }
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🧪 **REST Message Test Suite Results**\n\n${testSuiteResults.map((result) => `\n📡 **${result.name}**\n${result.description ? `   ${result.description}\n` : ''}   - Total Methods: ${result.totalMethods}\n   - ✅ Valid: ${result.successfulMethods}\n   - ❌ Invalid: ${result.failedMethods}\n   ${result.methods.length > 0 ? `\n   Methods:\n${result.methods.map((m) => `     • ${m.method} (${m.httpMethod}) - ${m.valid ? '✅' : '❌'}`).join('\n')}` : ''}`).join('\n')}\n\n**Suite Summary**:\n- Total REST Messages: ${testSuiteResults.length}\n- Total Methods Tested: ${testSuiteResults.reduce((sum, r) => sum + r.totalMethods, 0)}\n- Valid Configurations: ${testSuiteResults.reduce((sum, r) => sum + r.successfulMethods, 0)}\n- Invalid Configurations: ${testSuiteResults.reduce((sum, r) => sum + r.failedMethods, 0)}`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to run REST test suite:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to run REST test suite: ${error}`);
-        }
-    }
-    /**
-     * Enhanced property manager
-     */
-    async propertyManager(args) {
-        try {
-            this.logger.info('Managing system properties...');
-            const action = args.action || 'list';
-            switch (action) {
-                case 'get':
-                    this.logger.trackAPICall('SEARCH', 'sys_properties', 1);
-                    const getPropResponse = await this.client.searchRecords('sys_properties', `name=${args.name}`, 1);
-                    if (getPropResponse.success && getPropResponse.data?.result?.length > 0) {
-                        const prop = getPropResponse.data.result[0];
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `📋 **Property**: ${prop.name}\n\n**Value**: ${prop.value}\n**Type**: ${prop.type}\n**Description**: ${prop.description || 'None'}\n**Private**: ${prop.is_private ? 'Yes' : 'No'}\n**Read Only**: ${prop.read_roles ? 'Restricted' : 'No'}`
-                                }]
-                        };
-                    }
-                    throw new Error(`Property not found: ${args.name}`);
-                case 'set':
-                    const setPropResponse = await this.client.searchRecords('sys_properties', `name=${args.name}`, 1);
-                    if (setPropResponse.success && setPropResponse.data?.result?.length > 0) {
-                        // Update existing
-                        const updateResponse = await this.client.updateRecord('sys_properties', setPropResponse.data.result[0].sys_id, { value: args.value });
-                        if (updateResponse.success) {
-                            return {
-                                content: [{
-                                        type: 'text',
-                                        text: `✅ Property updated: ${args.name} = ${args.value}`
-                                    }]
-                            };
-                        }
-                    }
-                    else {
-                        // Create new
-                        const createResponse = await this.client.createRecord('sys_properties', {
-                            name: args.name,
-                            value: args.value,
-                            type: args.type || 'string',
-                            description: args.description || ''
-                        });
-                        if (createResponse.success) {
-                            return {
-                                content: [{
-                                        type: 'text',
-                                        text: `✅ Property created: ${args.name} = ${args.value}`
-                                    }]
-                            };
-                        }
-                    }
-                    throw new Error('Failed to set property');
-                case 'delete':
-                    const delPropResponse = await this.client.searchRecords('sys_properties', `name=${args.name}`, 1);
-                    if (delPropResponse.success && delPropResponse.data?.result?.length > 0) {
-                        await this.client.deleteRecord('sys_properties', delPropResponse.data.result[0].sys_id);
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `✅ Property deleted: ${args.name}`
-                                }]
-                        };
-                    }
-                    throw new Error(`Property not found: ${args.name}`);
-                case 'list':
-                default:
-                    const listQuery = args.pattern ? `nameLIKE${args.pattern}` : '';
-                    const listResponse = await this.client.searchRecords('sys_properties', listQuery, args.limit || 50);
-                    if (listResponse.success && listResponse.data?.result?.length > 0) {
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `📋 **System Properties** (${listResponse.data.result.length} found)\n\n${listResponse.data.result.map((p) => `• **${p.name}**\n  Value: ${p.value}\n  Type: ${p.type}`).join('\n\n')}`
-                                }]
-                        };
-                    }
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: '⚠️ No properties found matching criteria'
-                            }]
-                    };
-            }
-        }
-        catch (error) {
-            this.logger.error('Failed to manage properties:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to manage properties: ${error}`);
-        }
-    }
-    /**
-     * Trace execution of a script or flow
-     */
-    async traceExecution(args) {
-        try {
-            this.logger.info('Tracing execution...');
-            const traceId = `trace_${Date.now()}_${Math.random().toString(36).substring(7)}`;
-            // Enhanced script with detailed tracing
-            const tracedScript = `
-        var snowFlowTrace = {
-          id: '${traceId}',
-          startTime: new GlideDateTime(),
-          steps: [],
-          variables: {},
-          queries: [],
-          apiCalls: [],
-          errors: []
-        };
-        
-        // Trace function for logging steps
-        function trace(stepName, details) {
-          snowFlowTrace.steps.push({
-            step: stepName,
-            details: details,
-            timestamp: new GlideDateTime().getDisplayValue(),
-            memory: gs.getSession().getAvailableMemory ? gs.getSession().getAvailableMemory() : 'N/A'
-          });
-        }
-        
-        // Override GlideRecord to trace queries
-        var OriginalGlideRecord = GlideRecord;
-        GlideRecord = function(table) {
-          var gr = new OriginalGlideRecord(table);
-          var originalQuery = gr.query;
-          
-          gr.query = function() {
-            var queryString = gr.getEncodedQuery();
-            snowFlowTrace.queries.push({
-              table: table,
-              query: queryString,
-              timestamp: new GlideDateTime().getDisplayValue()
-            });
-            return originalQuery.call(gr);
-          };
-          
-          return gr;
-        };
-        
-        try {
-          trace('Script Start', 'Beginning execution');
-          
-          // User script with tracing
-          ${args.script.replace(/;/g, ';\ntrace("Code Execution", "Line executed");')}
-          
-          trace('Script Complete', 'Execution finished successfully');
-          
-          snowFlowTrace.endTime = new GlideDateTime();
-          snowFlowTrace.duration = GlideDateTime.subtract(snowFlowTrace.startTime, snowFlowTrace.endTime).getNumericValue();
-          snowFlowTrace.success = true;
-          
-        } catch(e) {
-          snowFlowTrace.errors.push({
-            error: e.toString(),
-            stack: e.stack || 'No stack trace',
-            timestamp: new GlideDateTime().getDisplayValue()
-          });
-          snowFlowTrace.success = false;
-        }
-        
-        // Store trace for retrieval
-        var prop = new GlideRecord('sys_properties');
-        prop.initialize();
-        prop.name = 'snow_flow.trace.' + snowFlowTrace.id;
-        prop.value = JSON.stringify(snowFlowTrace);
-        prop.type = 'string';
-        prop.description = 'Execution trace from Snow-Flow';
-        prop.insert();
-        
-        JSON.stringify({
-          traceId: snowFlowTrace.id,
-          success: snowFlowTrace.success,
-          steps: snowFlowTrace.steps.length,
-          queries: snowFlowTrace.queries.length,
-          errors: snowFlowTrace.errors.length
-        });
-      `;
-            const updateSetResult = await this.client.ensureUpdateSet();
-            const response = await this.client.executeScript(tracedScript);
-            let traceResult;
-            try {
-                traceResult = JSON.parse(response.data?.result || '{}');
-            }
-            catch (e) {
-                traceResult = { traceId: traceId, success: false };
-            }
-            // Wait and retrieve full trace
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            const traceResponse = await this.client.searchRecords('sys_properties', `name=snow_flow.trace.${traceId}`, 1);
-            let fullTrace = null;
-            if (traceResponse.success && traceResponse.data?.result?.length > 0) {
-                try {
-                    fullTrace = JSON.parse(traceResponse.data.result[0].value);
-                    // Clean up
-                    await this.client.deleteRecord('sys_properties', traceResponse.data.result[0].sys_id);
-                }
-                catch (e) {
-                    this.logger.warn('Could not parse trace data');
-                }
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🔍 **Execution Trace**\n\n🆔 **Trace ID**: ${traceId}\n✅ **Success**: ${traceResult.success}\n📊 **Steps**: ${traceResult.steps}\n🔍 **Queries**: ${traceResult.queries}\n⚠️ **Errors**: ${traceResult.errors}\n\n${fullTrace ? `**Detailed Trace**:\n\n${fullTrace.steps.map((s) => `⏰ ${s.timestamp}\n   📍 ${s.step}: ${s.details}`).join('\n\n')}\n\n${fullTrace.queries.length > 0 ? `**Database Queries**:\n${fullTrace.queries.map((q) => `• Table: ${q.table}\n  Query: ${q.query || 'All records'}`).join('\n')}` : ''}\n\n${fullTrace.errors.length > 0 ? `**Errors**:\n${fullTrace.errors.map((e) => `❌ ${e.error}\n   ${e.stack}`).join('\n')}` : ''}` : '⚠️ Full trace pending - check sys_properties for details'}`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to trace execution:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to trace execution: ${error}`);
-        }
-    }
-    /**
-     * Get audit logger for logging Snow-Flow activities
-     */
-    getAuditLogger() {
-        return this.auditLogger;
-    }
-    async run() {
-        const transport = new stdio_js_1.StdioServerTransport();
-        await this.server.connect(transport);
-        this.logger.info('ServiceNow Automation MCP Server running on stdio');
-    }
-}
-const server = new ServiceNowAutomationMCP();
-server.run().catch(console.error);
-//# sourceMappingURL=servicenow-automation-mcp.js.map