snow-flow 4.6.7 → 4.6.9

package/dist/cli.js

@@ -73,6 +73,67 @@ program
 (0, auth_js_1.registerAuthCommands)(program);
 // Register session inspection commands
 (0, session_js_1.registerSessionCommands)(program);
+// Claude Code version management - ensure 1.0.95 is installed
+async function ensureClaudeCodeVersion() {
+    try {
+        cliLogger.info('🔧 Checking Claude Code version compatibility...');
+        // Check if Claude Code is installed and get version
+        const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        const checkVersionResult = execSync('claude --version 2>/dev/null || echo "not_installed"', {
+            encoding: 'utf8',
+            timeout: 10000
+        }).trim();
+        const currentVersion = checkVersionResult.includes('not_installed') ? null :
+            checkVersionResult.match(/(\d+\.\d+\.\d+)/)?.[1];
+        cliLogger.info(`🔍 Current Claude Code version: ${currentVersion || 'not installed'}`);
+        // Target version that works correctly
+        const targetVersion = '1.0.95';
+        if (currentVersion !== targetVersion) {
+            cliLogger.info(`⚠️  Version mismatch detected. Installing Claude Code ${targetVersion}...`);
+            cliLogger.info('📥 This prevents bugs in newer versions that cause hanging operations');
+            try {
+                // Install the specific version
+                cliLogger.info('🔄 Running: npm install -g @anthropic-ai/claude-code@1.0.95');
+                execSync('npm install -g @anthropic-ai/claude-code@1.0.95', {
+                    stdio: 'inherit',
+                    timeout: 120000 // 2 minutes timeout
+                });
+                // Verify installation
+                const verifyResult = execSync('claude --version', {
+                    encoding: 'utf8',
+                    timeout: 10000
+                }).trim();
+                const installedVersion = verifyResult.match(/(\d+\.\d+\.\d+)/)?.[1];
+                if (installedVersion === targetVersion) {
+                    cliLogger.info(`✅ Claude Code ${targetVersion} installed successfully!`);
+                }
+                else {
+                    cliLogger.warn(`⚠️  Installation completed but version verification shows: ${installedVersion}`);
+                }
+            }
+            catch (installError) {
+                cliLogger.error('❌ Failed to install Claude Code 1.0.95');
+                cliLogger.error('Please install manually: npm install -g @anthropic-ai/claude-code@1.0.95');
+                throw new Error(`Claude Code installation failed: ${installError.message}`);
+            }
+        }
+        else {
+            cliLogger.info(`✅ Claude Code ${targetVersion} is already installed`);
+        }
+        cliLogger.info('🚀 Claude Code version check completed successfully');
+    }
+    catch (error) {
+        cliLogger.error('❌ Claude Code version check failed:', error.message);
+        // Provide fallback guidance
+        cliLogger.info('');
+        cliLogger.info('🔧 Manual installation instructions:');
+        cliLogger.info('   npm install -g @anthropic-ai/claude-code@1.0.95');
+        cliLogger.info('');
+        cliLogger.info('⚠️  Note: Version 1.0.95 is required to avoid hanging operations in swarm mode');
+        // Don't fail completely, but warn user
+        cliLogger.warn('⚠️  Continuing with potentially incompatible Claude Code version');
+    }
+}
 // Flow deprecation handler - check for flow-related commands
 function checkFlowDeprecation(command, objective) {
     const flowKeywords = ['flow', 'create-flow', 'xml-flow', 'flow-designer'];
@@ -156,6 +217,8 @@ program
     .action(async (objective, options) => {
     // Check for flow deprecation first
     checkFlowDeprecation('swarm', objective);
+    // Ensure Claude Code version 1.0.95 is installed before proceeding
+    await ensureClaudeCodeVersion();
     // Set debug levels based on options
     if (options.debugAll) {
         process.env.DEBUG = '*';

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.7",
-  "description": "CLEAN SOURCE REPOSITORY - v4.6.7 removes all built dist/ files from git for proper source code transparency. Only TypeScript source code tracked in git, dist/ built during NPM publish via prepublishOnly. Maintains bulletproof MCP persistence features.",
+  "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": {