snow-flow 4.6.8 → 5.0.0

package/dist/snow-flow-system.js

@@ -10,8 +10,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.snowFlowSystem = exports.SnowFlowSystem = void 0;
 const events_1 = require("events");
 const snow_flow_config_1 = require("./config/snow-flow-config");
-const servicenow_queen_1 = require("./queen/servicenow-queen");
-const mcp_server_manager_1 = require("./utils/mcp-server-manager");
+const queen_orchestrator_js_1 = require("./sdk/queen-orchestrator.js");
+const memory_system_1 = require("./memory/memory-system");
 const performance_tracker_1 = require("./monitoring/performance-tracker");
 const system_health_1 = require("./health/system-health");
 const error_recovery_1 = require("./utils/error-recovery");
@@ -39,13 +39,11 @@ class SnowFlowSystem extends events_1.EventEmitter {
             this.logger.info('Initializing Snow-Flow System...');
             // 1. Initialize Memory System
             await this.initializeMemory();
-            // 2. Initialize MCP Servers
-            await this.initializeMCPServers();
-            // 3. Initialize Queen Agent System
+            // 2. Initialize Queen Orchestrator (SDK-based)
             await this.initializeQueen();
-            // 4. Initialize Performance Tracking
+            // 3. Initialize Performance Tracking
             await this.initializePerformanceTracking();
-            // 5. Initialize System Health Monitoring
+            // 4. Initialize System Health Monitoring
             await this.initializeHealthMonitoring();
             this.initialized = true;
             this.emit('system:initialized');
@@ -66,62 +64,32 @@ class SnowFlowSystem extends events_1.EventEmitter {
     async initializeMemory() {
         this.logger.info('Initializing Memory System...');
         const dbPath = path_1.default.join(os_1.default.homedir(), '.snow-flow', 'memory', 'snow-flow.db');
-        this.memory = new memory_system_1.MemorySystem({
-            dbPath,
-            schema: { version: '1.0.0', autoMigrate: true, ...(this.config.memory.schema || {}) },
-            ttl: { default: 86400000, session: 3600000, artifact: 86400000, metric: 3600000, ...(this.config.memory.ttl || {}) }
-        });
+        this.memory = new memory_system_1.BasicMemorySystem();
         await this.memory.initialize();
         this.emit('memory:initialized');
     }
     /**
-     * Initialize MCP Server Manager
-     */
-    async initializeMCPServers() {
-        this.logger.info('Initializing MCP Servers...');
-        this.mcpManager = new mcp_server_manager_1.MCPServerManager(JSON.stringify(this.config.mcp));
-        // Start all required MCP servers
-        const servers = [
-            'servicenow-deployment',
-            'servicenow-intelligent',
-            'servicenow-operations',
-            'servicenow-platform-development',
-            'servicenow-integration',
-            'servicenow-automation',
-            'servicenow-security-compliance',
-            'servicenow-reporting-analytics',
-            'servicenow-graph-memory',
-            'servicenow-update-set'
-        ];
-        for (const server of servers) {
-            try {
-                await this.mcpManager.startServer(server);
-                this.logger.info(`Started MCP server: ${server}`);
-            }
-            catch (error) {
-                this.logger.error(`Failed to start MCP server ${server}:`, error);
-                // Continue with other servers even if one fails
-            }
-        }
-        this.emit('mcp:initialized');
-    }
-    /**
-     * Initialize Queen Agent System
+     * Initialize Queen Orchestrator (SDK-based)
+     * NOTE: MCP servers are now automatically managed by Claude Agent SDK
      */
     async initializeQueen() {
-        this.logger.info('Initializing Queen Agent System...');
-        if (!this.memory || !this.mcpManager) {
-            throw new Error('Memory and MCP must be initialized before Queen');
+        this.logger.info('Initializing Queen Orchestrator (SDK-based)...');
+        if (!this.memory) {
+            throw new Error('Memory must be initialized before Queen Orchestrator');
         }
-        this.queen = new servicenow_queen_1.ServiceNowQueen({
-            memoryPath: this.config.memory?.dbPath,
-            maxConcurrentAgents: this.config.agents?.queen?.maxConcurrentAgents || 5,
-            learningRate: this.config.agents?.queen?.learningRate || 0.1,
-            debugMode: this.config.debugMode || false,
-            autoPermissions: this.config.agents?.queen?.autoPermissions || false
+        // Create new SDK-based Queen Orchestrator
+        this.queen = new queen_orchestrator_js_1.QueenOrchestrator(this.memory);
+        // Setup event forwarding from Queen to System
+        this.queen.on('orchestration:started', (objective) => {
+            this.emit('queen:orchestration-started', objective);
         });
-        // ServiceNowQueen is ready to use after construction
-        // No initialize method or event handlers available
+        this.queen.on('orchestration:completed', (result) => {
+            this.emit('queen:orchestration-completed', result);
+        });
+        this.queen.on('orchestration:failed', ({ objective, error }) => {
+            this.emit('queen:orchestration-failed', { objective, error });
+        });
+        this.logger.info('✅ Queen Orchestrator initialized with Claude Agent SDK v0.1.1');
         this.emit('queen:initialized');
     }
     /**
@@ -148,14 +116,14 @@ class SnowFlowSystem extends events_1.EventEmitter {
      */
     async initializeHealthMonitoring() {
         this.logger.info('Initializing System Health Monitoring...');
-        if (!this.memory || !this.mcpManager) {
-            throw new Error('Memory and MCP must be initialized before Health Monitoring');
+        if (!this.memory) {
+            throw new Error('Memory must be initialized before Health Monitoring');
         }
         this.systemHealth = new system_health_1.SystemHealth({
             memory: this.memory,
-            mcpManager: this.mcpManager,
+            mcpManager: undefined, // SDK manages MCP servers now
             config: {
-                checks: { memory: true, mcp: true, servicenow: true, queen: true },
+                checks: { memory: true, mcp: false, servicenow: true, queen: true }, // Disable MCP check
                 thresholds: { memoryUsage: 85, responseTime: 5000, queueSize: 100, cpuUsage: 80, errorRate: 5 }
             }
         });
@@ -194,44 +162,36 @@ class SnowFlowSystem extends events_1.EventEmitter {
                 sessionId,
                 objective
             });
-            // Execute objective using Queen's main method
-            const queenResult = await this.queen.executeObjective(objective);
-            const _analysis = {
-                complexity: 0.5,
-                type: 'unknown',
-                estimatedDuration: 30000,
-                queenId: 'main-queen',
-                estimatedTasks: 1
-            };
-            session.queenAgentId = _analysis.queenId;
-            session.totalTasks = _analysis.estimatedTasks;
+            // Execute objective using new Queen Orchestrator (SDK-based)
+            this.logger.info(`🎯 Starting SDK-based orchestration for: ${objective}`);
+            const queenResult = await this.queen.orchestrate({
+                id: sessionId,
+                description: objective,
+                priority: 'high'
+            });
+            session.queenAgentId = sessionId;
+            session.totalTasks = queenResult.todos.length;
             session.status = 'active';
-            // Execute swarm with Queen coordination (MCP-FIRST workflow)
-            console.log(`🚨 SWARM EXECUTING WITH MCP-FIRST WORKFLOW`);
-            console.log(`🎯 Objective: ${objective}`);
-            const executionResult = await this.queen.executeObjective(objective);
-            // Update session with swarm-specific progress tracking
-            session.completedTasks = 1; // Queen completed the objective
-            session.status = 'completed';
+            session.completedTasks = queenResult.todos.filter(t => t.status === 'completed').length;
             this.emit('swarm:progress', {
                 sessionId,
                 progress: {
-                    completed: 1,
-                    total: 1,
+                    completed: session.completedTasks,
+                    total: session.totalTasks,
                     status: 'completed',
-                    mcpFirst: true,
-                    realServiceNow: true
+                    sdkBased: true,
+                    agentsSpawned: queenResult.agentsSpawned
                 }
             });
             session.status = 'completed';
             await this.performanceTracker?.endOperation('swarm_execution', {
-                success: true
+                success: queenResult.success
             });
             return {
                 sessionId,
-                success: true,
-                artifacts: queenResult.artifacts || [],
-                summary: queenResult.deploymentResult || queenResult,
+                success: queenResult.success,
+                artifacts: queenResult.artifactsCreated,
+                summary: `Orchestration completed: ${queenResult.agentsSpawned} agents spawned, ${queenResult.artifactsCreated.length} artifacts created`,
                 metrics: await this.performanceTracker?.getSessionMetrics(sessionId) || {}
             };
         }
@@ -296,14 +256,7 @@ class SnowFlowSystem extends events_1.EventEmitter {
             // Shutdown components in reverse order
             await this.systemHealth?.stopMonitoring();
             await this.performanceTracker?.shutdown();
-            await this.queen?.shutdown();
-            // Use available shutdown method
-            if (this.mcpManager && typeof this.mcpManager.shutdownAll === 'function') {
-                await this.mcpManager.shutdownAll();
-            }
-            else if (this.mcpManager && typeof this.mcpManager.shutdown === 'function') {
-                await this.mcpManager.shutdown();
-            }
+            await this.queen?.shutdown(); // SDK-based shutdown
             await this.memory?.close();
             this.initialized = false;
             this.emit('system:shutdown');
@@ -337,10 +290,10 @@ class SnowFlowSystem extends events_1.EventEmitter {
         return this.memory;
     }
     /**
-     * Get MCP manager instance
+     * Get Queen Orchestrator instance
      */
-    getMCPManager() {
-        return this.mcpManager;
+    getQueenOrchestrator() {
+        return this.queen;
     }
     /**
      * Private helper methods

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/mcp-persistent-guard.js

@@ -15,13 +15,21 @@ class MCPPersistentGuard {
         this.logger = new logger_1.Logger('MCPPersistentGuard');
         this.originalProcessKill = process.kill;
         this.originalProcessExit = process.exit;
-        this.logger.info('🛡️ MCP Persistent Guard activated - servers protected from shutdown');
-        // Override process.kill to protect MCP servers
-        this.installProcessProtection();
-        // Override process.exit to warn about shutdowns
-        this.installExitProtection();
-        // Monitor for shutdown attempts
-        this.startShutdownMonitoring();
+        // Check if this is a read-only command
+        const args = process.argv.slice(2);
+        const isReadOnly = args.some(arg => ['--version', '-V', '--help', '-h', 'help', 'version'].includes(arg));
+        if (!isReadOnly) {
+            this.logger.info('🛡️ MCP Persistent Guard activated - servers protected from shutdown');
+        }
+        // Only install protection for non-read-only commands
+        if (!isReadOnly) {
+            // Override process.kill to protect MCP servers
+            this.installProcessProtection();
+            // Override process.exit to warn about shutdowns
+            this.installExitProtection();
+            // Monitor for shutdown attempts
+            this.startShutdownMonitoring();
+        }
     }
     static getInstance() {
         if (!MCPPersistentGuard.instance) {
@@ -39,7 +47,7 @@ class MCPPersistentGuard {
             if (isMcpProcess && (signal === 'SIGTERM' || signal === 'SIGKILL')) {
                 this.logger.warn(`🛡️ BLOCKED: Attempted to kill MCP server process ${pid} with ${signal}`);
                 this.logger.info('🔄 MCP servers are configured for persistent operation');
-                return false;
+                return true;
             }
             // Allow non-MCP process kills
             return this.originalProcessKill(pid, signal);

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