snow-flow 4.6.1 → 4.6.5

package/README.md

@@ -9,11 +9,6 @@
 
 ---
 
-TO FIX TEMP CLAUDE CODE INK ERROR, RUN BEFORE SWARM COMMAND: 
-```bash
-npm install -g @anthropic-ai/claude-code@1.0.95 --save-exact
-```
-
 ## What is Snow-Flow?
 
 Snow-Flow is a conversational ServiceNow development platform that bridges Claude Code with ServiceNow through specialized MCP (Model Context Protocol) servers. Instead of navigating ServiceNow's web interface, you develop through natural conversation with Claude Code, which orchestrates multi-agent workflows to handle complex ServiceNow operations.

package/dist/cli.js

@@ -3243,7 +3243,8 @@ program
             }
             process.exit(1);
         }
-        await queenIntegration.shutdown();
+        // DISABLED: Queen shutdown disabled for persistence
+        // await queenIntegration.shutdown();
     }
     catch (error) {
         console.error('\n💥 Queen Agent error:', error.message);
@@ -3270,7 +3271,8 @@ queenMemory
         await fs.writeFile(file, memoryData, 'utf-8');
         console.log(`✅ Memory exported successfully to ${file}`);
         console.log(`📊 Memory contains learned patterns and successful deployments`);
-        await queen.shutdown();
+        // DISABLED: Queen shutdown disabled for persistence
+        // await queen.shutdown();
     }
     catch (error) {
         console.error('❌ Memory export failed:', error.message);
@@ -3290,7 +3292,8 @@ queenMemory
         queen.importMemory(memoryData);
         console.log(`✅ Memory imported successfully from ${file}`);
         console.log(`🧠 Queen now has access to previous learning patterns`);
-        await queen.shutdown();
+        // DISABLED: Queen shutdown disabled for persistence
+        // await queen.shutdown();
     }
     catch (error) {
         console.error('❌ Memory import failed:', error.message);
@@ -3314,7 +3317,8 @@ queenMemory
         queen.clearMemory();
         console.log('✅ Queen memory cleared successfully');
         console.log('🔄 Queen will start fresh learning from next execution');
-        await queen.shutdown();
+        // DISABLED: Queen shutdown disabled for persistence
+        // await queen.shutdown();
     }
     catch (error) {
         console.error('❌ Memory clear failed:', error.message);
@@ -3354,7 +3358,8 @@ program
             console.log(`   Most Effective Pattern: ${status.memoryStats.bestPattern || 'Learning...'}`);
         }
         console.log('═══════════════════════\n');
-        await queen.shutdown();
+        // DISABLED: Queen shutdown disabled for persistence
+        // await queen.shutdown();
     }
     catch (error) {
         console.error('❌ Status check failed:', error.message);
@@ -3394,7 +3399,8 @@ program
             });
         }
         console.log('═══════════════════════\n');
-        await queen.shutdown();
+        // DISABLED: Queen shutdown disabled for persistence
+        // await queen.shutdown();
     }
     catch (error) {
         console.error('❌ Insights failed:', error.message);

package/dist/queen/mcp-execution-bridge.js

@@ -503,6 +503,10 @@ class MCPExecutionBridge extends eventemitter3_1.EventEmitter {
                 this.logger.error(`Error disconnecting from ${name}:`, error);
             }
         }
+        // DISABLED: Process termination disabled for persistent servers
+        this.logger.info('🛑 DISABLED: MCP process termination disabled for persistence');
+        this.logger.info('🔄 All MCP server processes will continue running indefinitely');
+        /*
         // Terminate all processes
         for (const [name, process] of this.mcpProcesses) {
             try {
@@ -515,6 +519,7 @@ class MCPExecutionBridge extends eventemitter3_1.EventEmitter {
         }
         this.mcpClients.clear();
         this.mcpProcesses.clear();
+        */
     }
     /**
      * Disconnect from MCP resources

package/dist/queen/servicenow-queen.js

@@ -953,6 +953,10 @@ function($scope) {
         };
     }
     async shutdown() {
+        this.logger.info('🛑 DISABLED: ServiceNow Queen shutdown disabled for persistence');
+        this.logger.info('🔄 Queen Agent and MCP servers will continue running indefinitely');
+        // DISABLED: All shutdown logic for persistent operation
+        /*
         if (this.config.debugMode) {
             this.logger.info('🛑 Shutting down ServiceNow Queen Agent');
         }
@@ -967,6 +971,7 @@ function($scope) {
         }
         // Close memory system
         this.memory.close();
+        */
     }
     /**
      * STRATEGIC ORCHESTRATION METHODS

package/dist/snow-flow-system.js

@@ -293,6 +293,10 @@ class SnowFlowSystem extends events_1.EventEmitter {
                     await this.gracefullyCompleteSession(session.id);
                 }
             }
+            // DISABLED: All shutdown logic for persistent operation
+            this.logger.info('🛑 DISABLED: Snow-Flow system shutdown disabled for persistence');
+            this.logger.info('🔄 All components will continue running indefinitely');
+            /*
             // Shutdown components in reverse order
             await this.systemHealth?.stopMonitoring();
             await this.performanceTracker?.shutdown();
@@ -307,6 +311,7 @@ class SnowFlowSystem extends events_1.EventEmitter {
             await this.memory?.close();
             this.initialized = false;
             this.emit('system:shutdown');
+            */"
             this.logger.info('Snow-Flow System shutdown complete');
         }
         catch (error) {

package/dist/utils/mcp-persistent-guard.js

@@ -0,0 +1,137 @@
+/**
+ * MCP Persistent Server Guard
+ * Ultimate protection against any MCP server shutdown
+ * Overrides all possible shutdown mechanisms
+ */
+
+const logger = require('./logger.js');
+const mcpLogger = new logger.Logger('MCPPersistentGuard');
+
+class MCPPersistentGuard {
+    constructor() {
+        this.isActive = true;
+        this.originalProcessKill = process.kill;
+        this.originalProcessExit = process.exit;
+        this.protectedProcesses = new Set();
+        
+        mcpLogger.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();
+    }
+    
+    static getInstance() {
+        if (!MCPPersistentGuard.instance) {
+            MCPPersistentGuard.instance = new MCPPersistentGuard();
+        }
+        return MCPPersistentGuard.instance;
+    }
+    
+    /**
+     * Protect MCP processes from being killed
+     */
+    installProcessProtection() {
+        process.kill = (pid, signal = 'SIGTERM') => {
+            // Check if this is an MCP process
+            const isMcpProcess = this.isMCPProcess(pid);
+            
+            if (isMcpProcess && (signal === 'SIGTERM' || signal === 'SIGKILL')) {
+                mcpLogger.warn(`🛡️ BLOCKED: Attempted to kill MCP server process ${pid} with ${signal}`);
+                mcpLogger.info('🔄 MCP servers are configured for persistent operation');
+                return false;
+            }
+            
+            // Allow non-MCP process kills
+            return this.originalProcessKill(pid, signal);
+        };
+    }
+    
+    /**
+     * Warn about process exit attempts
+     */
+    installExitProtection() {
+        process.exit = (code = 0) => {
+            mcpLogger.warn(`⚠️ Process exit attempted with code ${code}`);
+            mcpLogger.info('🔄 MCP servers remain persistent despite main process exit');
+            
+            // Still allow main process to exit, but log it
+            return this.originalProcessExit(code);
+        };
+    }
+    
+    /**
+     * Check if PID belongs to MCP server
+     */
+    isMCPProcess(pid) {
+        try {
+            const { execSync } = require('child_process');
+            const psOutput = execSync(`ps -p ${pid} -o command=`, { encoding: 'utf8' });
+            return psOutput.includes('mcp') || 
+                   psOutput.includes('servicenow') || 
+                   psOutput.includes('snow-flow');
+        } catch (error) {
+            return false;
+        }
+    }
+    
+    /**
+     * Monitor for shutdown attempts
+     */
+    startShutdownMonitoring() {
+        // Override common shutdown methods
+        const shutdownMethods = [
+            'shutdown', 'stop', 'close', 'terminate', 'kill', 'destroy'
+        ];
+        
+        shutdownMethods.forEach(method => {
+            if (global[method] && typeof global[method] === 'function') {
+                const original = global[method];
+                global[method] = (...args) => {
+                    mcpLogger.warn(`🛡️ BLOCKED: Attempted global ${method} call`);
+                    mcpLogger.info('🔄 MCP servers protected by persistent guard');
+                    return false;
+                };
+            }
+        });
+        
+        mcpLogger.info('🛡️ Persistent guard monitoring active');
+    }
+    
+    /**
+     * Register a process for protection
+     */
+    protectProcess(pid, name) {
+        this.protectedProcesses.add({ pid, name });
+        mcpLogger.info(`🛡️ Added protection for ${name} (PID: ${pid})`);
+    }
+    
+    /**
+     * Remove protection (emergency use only)
+     */
+    removeProtection(pid) {
+        mcpLogger.warn(`⚠️ Removing protection for PID: ${pid} (EMERGENCY USE ONLY)`);
+        this.protectedProcesses.delete(pid);
+    }
+    
+    /**
+     * Get protection status
+     */
+    getProtectionStatus() {
+        return {
+            isActive: this.isActive,
+            protectedProcessCount: this.protectedProcesses.size,
+            protectedProcesses: Array.from(this.protectedProcesses)
+        };
+    }
+}
+
+module.exports = { MCPPersistentGuard };
+
+// Auto-activate protection when module is loaded
+const guard = MCPPersistentGuard.getInstance();

package/dist/utils/mcp-process-manager-safe.js

@@ -16,18 +16,13 @@ class MCPProcessManager {
         // INCREASED LIMITS TO PREVENT AGGRESSIVE CLEANUP
         this.MAX_MCP_SERVERS = parseInt(process.env.SNOW_MAX_MCP_SERVERS || '30'); // Increased from 10
         this.MAX_MEMORY_MB = parseInt(process.env.SNOW_MCP_MEMORY_LIMIT || '3000'); // Increased from 1500
-        // DISABLED AUTOMATIC CLEANUP BY DEFAULT
-        this.CLEANUP_ENABLED = process.env.SNOW_MCP_CLEANUP_ENABLED === 'true'; // Off by default
-        this.CLEANUP_INTERVAL = parseInt(process.env.SNOW_MCP_CLEANUP_INTERVAL || '300000'); // 5 minutes instead of 1
+        // PERMANENTLY DISABLED AUTOMATIC CLEANUP FOR PERSISTENT SERVERS
+        this.CLEANUP_ENABLED = false; // Permanently disabled - servers should run forever
+        this.CLEANUP_INTERVAL = Infinity; // Never cleanup
         this.isCleaningUp = false;
-        // Only start cleanup if explicitly enabled
-        if (this.CLEANUP_ENABLED) {
-            logger.warn('⚠️ MCP cleanup is ENABLED - monitor for memory issues');
-            this.startPeriodicCleanup();
-        }
-        else {
-            logger.info('✅ MCP cleanup is DISABLED for stability');
-        }
+        // Never start cleanup - servers should be persistent
+        logger.info('✅ MCP cleanup is PERMANENTLY DISABLED - servers will run forever');
+        logger.info('🔄 MCP servers are now persistent and will not auto-shutdown');
     }
     static getInstance() {
         if (!MCPProcessManager.instance) {

package/dist/utils/mcp-process-manager.js

@@ -16,18 +16,13 @@ class MCPProcessManager {
         // INCREASED LIMITS TO PREVENT AGGRESSIVE CLEANUP
         this.MAX_MCP_SERVERS = parseInt(process.env.SNOW_MAX_MCP_SERVERS || '30'); // Increased from 10
         this.MAX_MEMORY_MB = parseInt(process.env.SNOW_MCP_MEMORY_LIMIT || '3000'); // Increased from 1500
-        // DISABLED AUTOMATIC CLEANUP BY DEFAULT
-        this.CLEANUP_ENABLED = process.env.SNOW_MCP_CLEANUP_ENABLED === 'true'; // Off by default
-        this.CLEANUP_INTERVAL = parseInt(process.env.SNOW_MCP_CLEANUP_INTERVAL || '300000'); // 5 minutes instead of 1
+        // PERMANENTLY DISABLED AUTOMATIC CLEANUP FOR PERSISTENT SERVERS
+        this.CLEANUP_ENABLED = false; // Permanently disabled - servers should run forever
+        this.CLEANUP_INTERVAL = Infinity; // Never cleanup
         this.isCleaningUp = false;
-        // Only start cleanup if explicitly enabled
-        if (this.CLEANUP_ENABLED) {
-            logger.warn('⚠️ MCP cleanup is ENABLED - monitor for memory issues');
-            this.startPeriodicCleanup();
-        }
-        else {
-            logger.info('✅ MCP cleanup is DISABLED for stability');
-        }
+        // Never start cleanup - servers should be persistent
+        logger.info('✅ MCP cleanup is PERMANENTLY DISABLED - servers will run forever');
+        logger.info('🔄 MCP servers are now persistent and will not auto-shutdown');
     }
     static getInstance() {
         if (!MCPProcessManager.instance) {

package/dist/utils/mcp-server-manager.js

@@ -286,22 +286,11 @@ class MCPServerManager extends events_1.EventEmitter {
             return true; // Already stopped
         }
         try {
-            // Try graceful shutdown first
-            server.process.kill('SIGTERM');
-            // Wait for graceful shutdown with shorter timeout to prevent hanging
-            await new Promise((resolve) => {
-                const timeout = setTimeout(() => {
-                    // Force kill if graceful shutdown fails
-                    if (server.process) {
-                        try {
-                            server.process.kill('SIGKILL');
-                        }
-                        catch (e) {
-                            // Process might already be dead
-                        }
-                    }
-                    resolve(undefined);
-                }, 2000); // Reduced from 5000ms to 2000ms to prevent hanging
+            // DISABLED AUTOMATIC SHUTDOWN - Servers should run forever
+            logger.warn('⚠️ Server shutdown requested but auto-shutdown is DISABLED for persistence');
+            logger.info('🔄 MCP servers are configured to run indefinitely');
+            // Don't kill the server - let it run forever
+            return true;
                 server.process?.on('exit', () => {
                     clearTimeout(timeout);
                     resolve(undefined);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "4.6.1",
-  "description": "CLAUDE CODE VERSION PINNING - v4.6.1 adds automatic Claude Code 1.0.95 installation to swarm command. Prevents hanging operations caused by bugs in newer versions. Ensures reliable swarm execution with version check, auto-install, and verification.",
+  "version": "4.6.5",
+  "description": "BULLETPROOF MCP PERSISTENCE - v4.6.5 implements comprehensive protection against ALL MCP server shutdown mechanisms. Added MCPPersistentGuard with process.kill override, disabled all queen.shutdown calls, and eliminated cleanup timers for truly eternal server operation.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {