snow-flow 4.6.8 → 4.6.9

package/dist/utils/enhanced-script-executor.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Enhanced Script Executor
+ * Captures ALL output from ServiceNow background scripts
+ * Consolidates multiple execution methods into one reliable tool
+ */
+import { ServiceNowClient } from './servicenow-client.js';
+interface ScriptExecutionResult {
+    success: boolean;
+    output: string[];
+    errors: string[];
+    logs: {
+        print: string[];
+        info: string[];
+        warn: string[];
+        error: string[];
+        debug: string[];
+    };
+    executionTime: number;
+    executionId: string;
+    scriptResult?: any;
+    error?: string;
+}
+export declare class EnhancedScriptExecutor {
+    private client;
+    private logger;
+    constructor(client: ServiceNowClient);
+    /**
+     * Execute script and capture ALL output including gs.print, gs.info, etc.
+     */
+    executeWithFullOutput(script: string, description?: string): Promise<ScriptExecutionResult>;
+}
+export {};
+//# sourceMappingURL=enhanced-script-executor.d.ts.map

package/dist/utils/enhanced-script-executor.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * Enhanced Script Executor
+ * Captures ALL output from ServiceNow background scripts
+ * Consolidates multiple execution methods into one reliable tool
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnhancedScriptExecutor = void 0;
+const logger_js_1 = require("./logger.js");
+class EnhancedScriptExecutor {
+    constructor(client) {
+        this.client = client;
+        this.logger = new logger_js_1.Logger('EnhancedScriptExecutor');
+    }
+    /**
+     * Execute script and capture ALL output including gs.print, gs.info, etc.
+     */
+    async executeWithFullOutput(script, description) {
+        const startTime = Date.now();
+        const executionId = `snow_exec_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        this.logger.info(`Executing script with full output capture - ID: ${executionId}`);
+        try {
+            // Create enhanced wrapper script that captures EVERYTHING
+            const enhancedScript = `
+        // Enhanced output capture system
+        var snowFlowOutput = {
+          print: [],
+          info: [],
+          warn: [],
+          error: [],
+          debug: [],
+          general: [],
+          scriptResult: null,
+          executionId: '${executionId}',
+          startTime: new GlideDateTime().getValue()
+        };
+        
+        // Store original functions
+        var origPrint = gs.print;
+        var origInfo = gs.info;
+        var origWarn = gs.warn;
+        var origError = gs.error;
+        var origDebug = gs.debug;
+        
+        // Override gs functions to capture output
+        gs.print = function(message) {
+          snowFlowOutput.print.push(String(message));
+          snowFlowOutput.general.push('[PRINT] ' + String(message));
+          return origPrint.call(this, message);
+        };
+        
+        gs.info = function(message) {
+          snowFlowOutput.info.push(String(message));
+          snowFlowOutput.general.push('[INFO] ' + String(message));
+          return origInfo.call(this, message);
+        };
+        
+        gs.warn = function(message) {
+          snowFlowOutput.warn.push(String(message));
+          snowFlowOutput.general.push('[WARN] ' + String(message));
+          return origWarn.call(this, message);
+        };
+        
+        gs.error = function(message) {
+          snowFlowOutput.error.push(String(message));
+          snowFlowOutput.general.push('[ERROR] ' + String(message));
+          return origError.call(this, message);
+        };
+        
+        gs.debug = function(message) {
+          snowFlowOutput.debug.push(String(message));
+          snowFlowOutput.general.push('[DEBUG] ' + String(message));
+          return origDebug.call(this, message);
+        };
+        
+        // Execute user script and capture result
+        try {
+          gs.info('=== SCRIPT EXECUTION START ===');
+          
+          // User's script executed here
+          var userScriptResult = (function() {
+            ${script}
+          })();
+          
+          snowFlowOutput.scriptResult = userScriptResult;
+          gs.info('=== SCRIPT EXECUTION SUCCESS ===');
+          
+        } catch(userError) {
+          gs.error('=== SCRIPT EXECUTION ERROR ===');
+          gs.error('Error: ' + userError.toString());
+          if (userError.stack) {
+            gs.error('Stack: ' + userError.stack);
+          }
+          snowFlowOutput.scriptResult = { error: userError.toString(), stack: userError.stack };
+        }
+        
+        // Restore original functions
+        gs.print = origPrint;
+        gs.info = origInfo;
+        gs.warn = origWarn;
+        gs.error = origError;
+        gs.debug = origDebug;
+        
+        // Store output in sys_properties for retrieval
+        var outputJson = JSON.stringify(snowFlowOutput);
+        gs.setProperty('snow_flow.script_output.' + snowFlowOutput.executionId, outputJson);
+        
+        // Final summary
+        gs.info('Snow-Flow: Script execution complete, output stored in sys_properties');
+        gs.info('Snow-Flow: Execution ID = ' + snowFlowOutput.executionId);
+        gs.info('Snow-Flow: Total output lines = ' + snowFlowOutput.general.length);
+      `;
+            // Execute the enhanced script
+            const executeResponse = await this.client.executeScript(enhancedScript);
+            if (!executeResponse.success) {
+                throw new Error(`Script execution failed: ${executeResponse.error}`);
+            }
+            // Wait a bit for execution to complete
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            // Retrieve the captured output from sys_properties
+            const outputProperty = `snow_flow.script_output.${executionId}`;
+            const outputResponse = await this.client.getProperty(outputProperty);
+            let capturedOutput = {
+                print: [],
+                info: [],
+                warn: [],
+                error: [],
+                debug: [],
+                general: [],
+                scriptResult: null
+            };
+            if (outputResponse.success && outputResponse.value) {
+                try {
+                    capturedOutput = JSON.parse(outputResponse.value);
+                }
+                catch (parseError) {
+                    this.logger.warn('Failed to parse captured output, using basic result');
+                }
+                // Clean up the property
+                await this.client.deleteProperty(outputProperty);
+            }
+            const executionTime = Date.now() - startTime;
+            const result = {
+                success: true,
+                output: capturedOutput.general || [],
+                errors: capturedOutput.error || [],
+                logs: {
+                    print: capturedOutput.print || [],
+                    info: capturedOutput.info || [],
+                    warn: capturedOutput.warn || [],
+                    error: capturedOutput.error || [],
+                    debug: capturedOutput.debug || []
+                },
+                executionTime,
+                executionId,
+                scriptResult: capturedOutput.scriptResult
+            };
+            this.logger.info(`Script execution completed with ${result.output.length} output lines`);
+            return result;
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            this.logger.error(`Script execution failed: ${error.message}`);
+            return {
+                success: false,
+                output: [],
+                errors: [error.message],
+                logs: {
+                    print: [],
+                    info: [],
+                    warn: [],
+                    error: [error.message],
+                    debug: []
+                },
+                executionTime,
+                executionId,
+                error: error.message
+            };
+        }
+    }
+}
+exports.EnhancedScriptExecutor = EnhancedScriptExecutor;
+//# sourceMappingURL=enhanced-script-executor.js.map

package/dist/utils/unified-script-executor.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Unified Script Executor
+ * Single reliable tool to replace all script execution methods
+ * Captures COMPLETE output from ServiceNow scripts
+ */
+import { ServiceNowClient } from './servicenow-client.js';
+export interface UnifiedScriptResult {
+    success: boolean;
+    output: string[];
+    scriptResult: any;
+    executionId: string;
+    executionTime: number;
+    logs: {
+        print: string[];
+        info: string[];
+        warn: string[];
+        error: string[];
+    };
+    summary: string;
+    error?: string;
+}
+export declare class UnifiedScriptExecutor {
+    private client;
+    private logger;
+    constructor(client: ServiceNowClient);
+    /**
+     * Execute script with complete output capture
+     * Replaces: snow_execute_script_with_output, snow_execute_script_sync, snow_execute_background_script
+     */
+    executeScript(script: string, description?: string): Promise<UnifiedScriptResult>;
+}
+export declare function createUnifiedScriptTool(): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            script: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=unified-script-executor.d.ts.map

package/dist/utils/unified-script-executor.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Unified Script Executor
+ * Single reliable tool to replace all script execution methods
+ * Captures COMPLETE output from ServiceNow scripts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnifiedScriptExecutor = void 0;
+exports.createUnifiedScriptTool = createUnifiedScriptTool;
+const logger_js_1 = require("./logger.js");
+class UnifiedScriptExecutor {
+    constructor(client) {
+        this.client = client;
+        this.logger = new logger_js_1.Logger('UnifiedScriptExecutor');
+    }
+    /**
+     * Execute script with complete output capture
+     * Replaces: snow_execute_script_with_output, snow_execute_script_sync, snow_execute_background_script
+     */
+    async executeScript(script, description) {
+        const startTime = Date.now();
+        const executionId = `unified_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        this.logger.info(`Executing script with unified capture - ID: ${executionId}`);
+        try {
+            // Enhanced script that captures EVERYTHING
+            const captureScript = `
+        // Snow-Flow Enhanced Output Capture System
+        var snowFlowCapture = {
+          print: [],
+          info: [],
+          warn: [],
+          error: [],
+          output: [],
+          scriptResult: null,
+          executionId: '${executionId}',
+          success: true,
+          startTime: new GlideDateTime().getDisplayValue()
+        };
+        
+        // Store original gs methods
+        var origPrint = gs.print;
+        var origInfo = gs.info; 
+        var origWarn = gs.warn;
+        var origError = gs.error;
+        
+        // Enhanced capture functions
+        gs.print = function(msg) {
+          var message = String(msg);
+          snowFlowCapture.print.push(message);
+          snowFlowCapture.output.push('[PRINT] ' + message);
+          return origPrint(msg);
+        };
+        
+        gs.info = function(msg) {
+          var message = String(msg);
+          snowFlowCapture.info.push(message);
+          snowFlowCapture.output.push('[INFO] ' + message);
+          return origInfo(msg);
+        };
+        
+        gs.warn = function(msg) {
+          var message = String(msg);
+          snowFlowCapture.warn.push(message);
+          snowFlowCapture.output.push('[WARN] ' + message);
+          return origWarn(msg);
+        };
+        
+        gs.error = function(msg) {
+          var message = String(msg);
+          snowFlowCapture.error.push(message);
+          snowFlowCapture.output.push('[ERROR] ' + message);
+          return origError(msg);
+        };
+        
+        // Execute user script
+        try {
+          gs.info('=== SNOW-FLOW UNIFIED EXECUTION START ===');
+          
+          var result = (function() {
+            ${script}
+          })();
+          
+          snowFlowCapture.scriptResult = result;
+          gs.info('=== SNOW-FLOW EXECUTION SUCCESS ===');
+          gs.info('Script Result: ' + (typeof result === 'object' ? JSON.stringify(result) : String(result)));
+          
+        } catch(scriptError) {
+          snowFlowCapture.success = false;
+          gs.error('=== SNOW-FLOW EXECUTION ERROR ===');
+          gs.error('Error: ' + scriptError.toString());
+          snowFlowCapture.scriptResult = { error: scriptError.toString() };
+        }
+        
+        // Restore original functions
+        gs.print = origPrint;
+        gs.info = origInfo;
+        gs.warn = origWarn;
+        gs.error = origError;
+        
+        // Store result in temporary property
+        gs.setProperty('snow_flow.unified_output.' + snowFlowCapture.executionId, JSON.stringify(snowFlowCapture));
+        
+        gs.info('Snow-Flow: Unified execution complete, ID = ' + snowFlowCapture.executionId);
+      `;
+            // Execute the script
+            const executeResponse = await this.client.executeScript(captureScript);
+            if (!executeResponse.success) {
+                throw new Error(`Script execution failed: ${executeResponse.error}`);
+            }
+            // Wait for completion
+            await new Promise(resolve => setTimeout(resolve, 3000));
+            // Retrieve captured output
+            const outputProperty = `snow_flow.unified_output.${executionId}`;
+            const outputResponse = await this.client.getProperty(outputProperty);
+            let capturedData = {
+                print: [],
+                info: [],
+                warn: [],
+                error: [],
+                output: [],
+                scriptResult: null,
+                success: false
+            };
+            if (outputResponse.success && outputResponse.value) {
+                try {
+                    capturedData = JSON.parse(outputResponse.value);
+                    // Clean up
+                    await this.client.deleteProperty(outputProperty);
+                }
+                catch (parseError) {
+                    this.logger.warn('Parse error:', parseError);
+                }
+            }
+            const executionTime = Date.now() - startTime;
+            return {
+                success: capturedData.success,
+                output: capturedData.output || [],
+                scriptResult: capturedData.scriptResult,
+                executionId,
+                executionTime,
+                logs: {
+                    print: capturedData.print || [],
+                    info: capturedData.info || [],
+                    warn: capturedData.warn || [],
+                    error: capturedData.error || []
+                },
+                summary: `✅ Execution complete: ${capturedData.output?.length || 0} output lines, ${capturedData.error?.length || 0} errors`,
+                error: capturedData.success ? undefined : 'Script execution failed'
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            return {
+                success: false,
+                output: [],
+                scriptResult: null,
+                executionId,
+                executionTime,
+                logs: { print: [], info: [], warn: [], error: [error.message] },
+                summary: `❌ Execution failed: ${error.message}`,
+                error: error.message
+            };
+        }
+    }
+}
+exports.UnifiedScriptExecutor = UnifiedScriptExecutor;
+// Export as MCP tool helper
+function createUnifiedScriptTool() {
+    return {
+        name: 'snow_execute_script_unified',
+        description: '🚀 UNIFIED: Execute script with complete output capture (replaces all other script tools). ⚠️ ES5 ONLY!',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                script: { type: 'string', description: '🚨 ES5 ONLY! JavaScript code (var, function(){}, string concatenation)' },
+                description: { type: 'string', description: 'What this script does' }
+            },
+            required: ['script']
+        }
+    };
+}
+//# sourceMappingURL=unified-script-executor.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "4.6.8",
-  "description": "RESTORED CLAUDE CODE VERSION PINNING - v4.6.8 restores automatic Claude Code 1.0.95 installation to swarm command that was lost during refactoring. Now properly integrated in TypeScript source with bulletproof MCP persistence and clean repository structure.",
+  "version": "4.6.9",
+  "description": "ENHANCED SCRIPT OUTPUT CAPTURE - v4.6.9 adds UnifiedScriptExecutor to capture complete script output including gs.print, gs.info, gs.warn, gs.error and script results. Solves the 'not getting actual output' problem with comprehensive output capture system.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {