snow-flow 4.6.9 → 5.0.0

package/dist/mcp/servicenow-mcp-unified/tools/automation/snow_execute_script_with_output.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * snow_execute_script_with_output - Execute background scripts
+ *
+ * Execute server-side JavaScript in ServiceNow background scripts with
+ * full output capture (gs.print, gs.info, gs.warn, gs.error).
+ *
+ * ⚠️ CRITICAL: ALL SCRIPTS MUST BE ES5 ONLY!
+ * ServiceNow runs on Rhino engine - no const/let/arrow functions/template literals.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_execute_script_with_output',
+    description: 'Execute server-side JavaScript with output capture (ES5 only - no const/let/arrow functions)',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            script: {
+                type: 'string',
+                description: 'JavaScript code to execute (MUST be ES5 - no const/let/arrow functions/template literals)'
+            },
+            scope: {
+                type: 'string',
+                description: 'Scope to execute in (global or application scope)',
+                default: 'global',
+                enum: ['global', 'rhino']
+            },
+            validate_es5: {
+                type: 'boolean',
+                description: 'Validate ES5 syntax before execution',
+                default: true
+            }
+        },
+        required: ['script']
+    }
+};
+async function execute(args, context) {
+    const { script, scope = 'global', validate_es5 = true } = args;
+    try {
+        // ES5 validation
+        if (validate_es5) {
+            const es5Validation = validateES5(script);
+            if (!es5Validation.valid) {
+                throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.ES5_SYNTAX_ERROR, 'Script contains non-ES5 syntax', {
+                    retryable: false,
+                    details: {
+                        violations: es5Validation.violations,
+                        message: 'ServiceNow uses Rhino engine - ES6+ syntax will fail'
+                    }
+                });
+            }
+        }
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Wrap script to capture all output
+        const wrappedScript = `
+var __output = [];
+var __originalPrint = gs.print;
+var __originalInfo = gs.info;
+var __originalWarn = gs.warn;
+var __originalError = gs.error;
+
+gs.print = function(msg) { __output.push({level: 'print', message: String(msg)}); };
+gs.info = function(msg) { __output.push({level: 'info', message: String(msg)}); __originalInfo(msg); };
+gs.warn = function(msg) { __output.push({level: 'warn', message: String(msg)}); __originalWarn(msg); };
+gs.error = function(msg) { __output.push({level: 'error', message: String(msg)}); __originalError(msg); };
+
+try {
+  ${script}
+  __output.push({level: 'success', message: 'Script executed successfully'});
+} catch (e) {
+  __output.push({level: 'error', message: 'ERROR: ' + e.message});
+  __output.push({level: 'error', message: 'Stack: ' + e.stack});
+}
+
+gs.print = __originalPrint;
+gs.info = __originalInfo;
+gs.warn = __originalWarn;
+gs.error = __originalError;
+
+JSON.stringify(__output);
+`;
+        // Execute via background script API
+        const response = await client.post('/api/now/table/sys_script_execution', {
+            script: wrappedScript,
+            scope: scope === 'rhino' ? 'rhino.global' : 'global'
+        });
+        // Parse output
+        let output = [];
+        let executionResult = response.data.result;
+        try {
+            // The result might be in different formats depending on ServiceNow version
+            if (executionResult.output) {
+                output = JSON.parse(executionResult.output);
+            }
+            else if (typeof executionResult === 'string') {
+                output = JSON.parse(executionResult);
+            }
+        }
+        catch (e) {
+            output = [{ level: 'info', message: executionResult.toString() }];
+        }
+        // Organize output by level
+        const organized = {
+            print: output.filter(o => o.level === 'print').map(o => o.message),
+            info: output.filter(o => o.level === 'info').map(o => o.message),
+            warn: output.filter(o => o.level === 'warn').map(o => o.message),
+            error: output.filter(o => o.level === 'error').map(o => o.message),
+            success: output.some(o => o.level === 'success')
+        };
+        return (0, error_handler_js_1.createSuccessResult)({
+            success: organized.error.length === 0,
+            output: organized,
+            raw_output: output
+        }, {
+            script_length: script.length,
+            scope,
+            es5_validated: validate_es5
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError
+            ? error
+            : new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.UNKNOWN_ERROR, error.message, { originalError: error }));
+    }
+}
+function validateES5(code) {
+    const violations = [];
+    const patterns = [
+        { regex: /\b(const|let)\s+/g, type: 'const/let', fix: "Use 'var'" },
+        { regex: /\([^)]*\)\s*=>/g, type: 'arrow_function', fix: 'Use function() {}' },
+        { regex: /`[^`]*`/g, type: 'template_literal', fix: 'Use string concatenation' },
+        { regex: /\{[^}]+\}\s*=\s*/g, type: 'destructuring', fix: 'Use explicit properties' },
+        { regex: /for\s*\([^)]*\s+of\s+/g, type: 'for_of', fix: 'Use traditional for loop' },
+        { regex: /class\s+\w+/g, type: 'class', fix: 'Use function constructor' }
+    ];
+    patterns.forEach(({ regex, type, fix }) => {
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+            violations.push({
+                type,
+                line: code.substring(0, match.index).split('\n').length,
+                code: match[0],
+                fix
+            });
+        }
+    });
+    return { valid: violations.length === 0, violations };
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_execute_script_with_output.js.map

package/dist/mcp/servicenow-mcp-unified/tools/automation/snow_get_logs.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_get_logs - Access system logs
+ *
+ * Retrieve ServiceNow system logs with filtering by level, source,
+ * and time range for debugging and monitoring.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_get_logs.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/automation/snow_get_logs.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * snow_get_logs - Access system logs
+ *
+ * Retrieve ServiceNow system logs with filtering by level, source,
+ * and time range for debugging and monitoring.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_get_logs',
+    description: 'Retrieve ServiceNow system logs with filtering by level, source, and time range',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            level: {
+                type: 'string',
+                enum: ['error', 'warn', 'info', 'debug', 'all'],
+                description: 'Log level filter',
+                default: 'all'
+            },
+            source: {
+                type: 'string',
+                description: 'Filter by log source (e.g., widget name, script name)'
+            },
+            limit: {
+                type: 'number',
+                description: 'Maximum number of log entries to return',
+                default: 100,
+                minimum: 1,
+                maximum: 1000
+            },
+            since: {
+                type: 'string',
+                description: 'Get logs since this timestamp (ISO 8601 or relative like "1h", "30m")'
+            },
+            search: {
+                type: 'string',
+                description: 'Search term in log messages'
+            }
+        }
+    }
+};
+async function execute(args, context) {
+    const { level = 'all', source, limit = 100, since, search } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Build query
+        const queryParts = [];
+        // Level filter
+        if (level !== 'all') {
+            queryParts.push(`level=${level}`);
+        }
+        // Source filter
+        if (source) {
+            queryParts.push(`sourceLIKE${source}`);
+        }
+        // Time range filter
+        if (since) {
+            const sinceTimestamp = parseRelativeTime(since);
+            queryParts.push(`sys_created_on>${sinceTimestamp}`);
+        }
+        // Search filter
+        if (search) {
+            queryParts.push(`messageLIKE${search}`);
+        }
+        const query = queryParts.join('^');
+        // Get logs from syslog table
+        const response = await client.get('/api/now/table/syslog', {
+            params: {
+                sysparm_query: query + '^ORDERBYDESCsys_created_on',
+                sysparm_limit: limit,
+                sysparm_fields: 'sys_created_on,level,source,message,sys_id'
+            }
+        });
+        const logs = response.data.result.map((log) => ({
+            timestamp: log.sys_created_on,
+            level: log.level,
+            source: log.source,
+            message: log.message,
+            sys_id: log.sys_id
+        }));
+        // Categorize by level
+        const byLevel = {
+            error: logs.filter((l) => l.level === 'error').length,
+            warn: logs.filter((l) => l.level === 'warn').length,
+            info: logs.filter((l) => l.level === 'info').length,
+            debug: logs.filter((l) => l.level === 'debug').length
+        };
+        return (0, error_handler_js_1.createSuccessResult)({
+            logs,
+            count: logs.length,
+            by_level: byLevel,
+            filters: { level, source, since, search }
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+function parseRelativeTime(relative) {
+    const now = new Date();
+    const match = relative.match(/^(\d+)([mhd])$/);
+    if (!match) {
+        // Assume it's an absolute timestamp
+        return relative;
+    }
+    const value = parseInt(match[1]);
+    const unit = match[2];
+    let milliseconds = 0;
+    switch (unit) {
+        case 'm':
+            milliseconds = value * 60 * 1000;
+            break;
+        case 'h':
+            milliseconds = value * 60 * 60 * 1000;
+            break;
+        case 'd':
+            milliseconds = value * 24 * 60 * 60 * 1000;
+            break;
+    }
+    const since = new Date(now.getTime() - milliseconds);
+    return since.toISOString();
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_get_logs.js.map

package/dist/mcp/servicenow-mcp-unified/tools/automation/snow_get_script_output.d.ts

@@ -0,0 +1,11 @@
+/**
+ * snow_get_script_output - Retrieve script output from previous execution
+ *
+ * Retrieves the output from a previously executed script using its execution ID.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_get_script_output.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/automation/snow_get_script_output.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * snow_get_script_output - Retrieve script output from previous execution
+ *
+ * Retrieves the output from a previously executed script using its execution ID.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_get_script_output',
+    description: 'Retrieve output from previously executed script using execution ID',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            execution_id: {
+                type: 'string',
+                description: 'Execution ID from previous script run'
+            },
+            cleanup: {
+                type: 'boolean',
+                description: 'Clean up temporary output after retrieval',
+                default: true
+            }
+        },
+        required: ['execution_id']
+    }
+};
+async function execute(args, context) {
+    const { execution_id, cleanup = true } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Try to find the output in sys_properties
+        const outputResponse = await client.get(`/api/now/table/sys_properties?sysparm_query=nameLIKEsnow_flow.script_output.${execution_id}&sysparm_limit=1`);
+        if (outputResponse.data.result && outputResponse.data.result.length > 0) {
+            const property = outputResponse.data.result[0];
+            const scriptOutput = JSON.parse(property.value);
+            // Clean up old property if requested
+            if (cleanup) {
+                await client.delete(`/api/now/table/sys_properties/${property.sys_id}`);
+            }
+            return (0, error_handler_js_1.createSuccessResult)({
+                execution_id: scriptOutput.executionId,
+                executed_at: scriptOutput.executedAt,
+                success: scriptOutput.success,
+                output: scriptOutput.output || [],
+                errors: scriptOutput.errors || [],
+                exception: scriptOutput.exception || null
+            }, {
+                operation: 'retrieve_script_output',
+                cleanup_performed: cleanup
+            });
+        }
+        // Try to find in script execution history
+        const historyResponse = await client.get(`/api/now/table/sys_script_execution_history?sysparm_query=script_nameLIKE${execution_id}&sysparm_limit=5`);
+        if (historyResponse.data.result && historyResponse.data.result.length > 0) {
+            const history = historyResponse.data.result[0];
+            return (0, error_handler_js_1.createSuccessResult)({
+                execution_id,
+                executed_at: history.sys_created_on,
+                executed_by: history.sys_created_by,
+                output: history.output || 'No output captured',
+                errors: history.error_message || null,
+                source: 'execution_history'
+            }, {
+                operation: 'retrieve_script_output',
+                source: 'execution_history'
+            });
+        }
+        // No output found
+        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `No output found for execution ID: ${execution_id}`, {
+            retryable: false,
+            details: {
+                possible_reasons: [
+                    'The script is still executing',
+                    'The execution ID is incorrect',
+                    'The output has been cleaned up'
+                ]
+            }
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError
+            ? error
+            : new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.UNKNOWN_ERROR, error.message, { originalError: error }));
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_get_script_output.js.map

package/dist/mcp/servicenow-mcp-unified/tools/automation/snow_property_manager.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_property_manager - Enhanced property management
+ *
+ * Unified tool for getting, setting, and validating system properties with
+ * automatic sensitive value masking.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_property_manager.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/automation/snow_property_manager.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * snow_property_manager - Enhanced property management
+ *
+ * Unified tool for getting, setting, and validating system properties with
+ * automatic sensitive value masking.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_property_manager',
+    description: 'Enhanced property management with get, set, and validation in one tool',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['get', 'set', 'validate'],
+                description: 'Action to perform: get, set, or validate'
+            },
+            name: {
+                type: 'string',
+                description: 'Property name'
+            },
+            value: {
+                type: 'string',
+                description: 'Property value (required for set action)'
+            },
+            mask_sensitive: {
+                type: 'boolean',
+                description: 'Mask sensitive values like API keys',
+                default: true
+            }
+        },
+        required: ['action', 'name']
+    }
+};
+async function execute(args, context) {
+    const { action, name, value, mask_sensitive = true } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        switch (action) {
+            case 'get':
+                return await getProperty(client, name, mask_sensitive);
+            case 'set':
+                if (!value) {
+                    throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.INVALID_REQUEST, 'value is required for set action', { retryable: false });
+                }
+                return await setProperty(client, name, value);
+            case 'validate':
+                return await validateProperty(client, name);
+            default:
+                throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.INVALID_REQUEST, `Invalid action: ${action}`, { retryable: false });
+        }
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError
+            ? error
+            : new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.UNKNOWN_ERROR, error.message, { originalError: error }));
+    }
+}
+async function getProperty(client, name, maskSensitive) {
+    const response = await client.get(`/api/now/table/sys_properties?sysparm_query=name=${name}&sysparm_limit=1`);
+    if (!response.data.result || response.data.result.length === 0) {
+        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `Property not found: ${name}`, { retryable: false });
+    }
+    const property = response.data.result[0];
+    let propertyValue = property.value;
+    // Mask sensitive values
+    if (maskSensitive && isSensitiveProperty(name)) {
+        propertyValue = maskValue(propertyValue);
+    }
+    return (0, error_handler_js_1.createSuccessResult)({
+        name: property.name,
+        value: propertyValue,
+        description: property.description || '',
+        type: property.type || 'string',
+        sys_id: property.sys_id,
+        is_masked: maskSensitive && isSensitiveProperty(name)
+    }, {
+        operation: 'get_property',
+        property_name: name
+    });
+}
+async function setProperty(client, name, value) {
+    // First check if property exists
+    const existingResponse = await client.get(`/api/now/table/sys_properties?sysparm_query=name=${name}&sysparm_limit=1`);
+    let result;
+    if (existingResponse.data.result && existingResponse.data.result.length > 0) {
+        // Update existing property
+        const propertyId = existingResponse.data.result[0].sys_id;
+        const updateResponse = await client.patch(`/api/now/table/sys_properties/${propertyId}`, {
+            value: value
+        });
+        result = updateResponse.data.result;
+    }
+    else {
+        // Create new property
+        const createResponse = await client.post('/api/now/table/sys_properties', {
+            name: name,
+            value: value,
+            type: 'string'
+        });
+        result = createResponse.data.result;
+    }
+    return (0, error_handler_js_1.createSuccessResult)({
+        name: result.name,
+        value: isSensitiveProperty(name) ? maskValue(value) : value,
+        sys_id: result.sys_id,
+        operation: existingResponse.data.result.length > 0 ? 'updated' : 'created'
+    }, {
+        operation: 'set_property',
+        property_name: name
+    });
+}
+async function validateProperty(client, name) {
+    const response = await client.get(`/api/now/table/sys_properties?sysparm_query=name=${name}&sysparm_limit=1`);
+    const exists = response.data.result && response.data.result.length > 0;
+    const property = exists ? response.data.result[0] : null;
+    const validation = {
+        exists,
+        name,
+        is_valid: exists,
+        issues: []
+    };
+    if (exists) {
+        // Validate property structure
+        if (!property.value || property.value === '') {
+            validation.issues.push('Property value is empty');
+            validation.is_valid = false;
+        }
+        if (!property.type) {
+            validation.issues.push('Property type is not defined');
+        }
+    }
+    else {
+        validation.issues.push('Property does not exist');
+    }
+    return (0, error_handler_js_1.createSuccessResult)(validation, {
+        operation: 'validate_property',
+        property_name: name
+    });
+}
+function isSensitiveProperty(name) {
+    const sensitivePatterns = [
+        /password/i,
+        /api[_-]?key/i,
+        /secret/i,
+        /token/i,
+        /credential/i,
+        /private[_-]?key/i
+    ];
+    return sensitivePatterns.some(pattern => pattern.test(name));
+}
+function maskValue(value) {
+    if (!value || value.length <= 4) {
+        return '****';
+    }
+    return value.substring(0, 2) + '****' + value.substring(value.length - 2);
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_property_manager.js.map

package/dist/mcp/servicenow-mcp-unified/tools/automation/snow_rest_message_test_suite.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_rest_message_test_suite - REST message test suite
+ *
+ * Comprehensive testing suite for REST messages including authentication,
+ * endpoints, headers, and response validation.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_rest_message_test_suite.d.ts.map