snow-flow 2.9.9 → 2.10.0

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

@@ -14,6 +14,7 @@ const events_1 = require("events");
 const os_1 = __importDefault(require("os"));
 const unified_auth_store_js_1 = require("./unified-auth-store.js");
 const mcp_singleton_lock_js_1 = require("./mcp-singleton-lock.js");
+const mcp_singleton_enforcer_js_1 = require("./mcp-singleton-enforcer.js");
 const mcp_process_manager_js_1 = require("./mcp-process-manager.js");
 class MCPServerManager extends events_1.EventEmitter {
     constructor(configPath) {
@@ -298,10 +299,12 @@ class MCPServerManager extends events_1.EventEmitter {
      * Start all configured MCP servers
      */
     async startAllServers() {
-        // 🔒 SINGLETON CHECK - Prevent duplicate instances
-        const singletonLock = (0, mcp_singleton_lock_js_1.getMCPSingletonLock)();
-        if (!singletonLock.acquire()) {
-            throw new Error('❌ MCP servers already running. Cannot start duplicate instances.');
+        // 🔒 ENFORCE SINGLETON - Kill any existing and acquire lock
+        mcp_singleton_enforcer_js_1.MCPSingletonEnforcer.enforce();
+        // Health check before starting
+        const health = await mcp_singleton_enforcer_js_1.MCPSingletonEnforcer.checkHealth();
+        if (!health.healthy) {
+            console.warn('⚠️ MCP health issues detected:', health.issues);
         }
         // Clean up any existing duplicates first
         const processManager = mcp_process_manager_js_1.MCPProcessManager.getInstance();

package/dist/utils/mcp-singleton-enforcer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * MCP Singleton Enforcer
+ * Ensures only ONE set of MCP servers can run at a time
+ * v2.10.0 - Critical fix for duplicate MCP servers causing timeouts
+ */
+export declare class MCPSingletonEnforcer {
+    private static enforced;
+    /**
+     * Kill ALL existing MCP processes before starting new ones
+     * This is a nuclear option but necessary to prevent timeouts
+     */
+    static killAllMCPProcesses(): number;
+    /**
+     * Enforce singleton before any MCP operation
+     * This should be called before starting ANY MCP server
+     */
+    static enforce(): boolean;
+    /**
+     * Setup cleanup handlers
+     */
+    private static setupCleanup;
+    /**
+     * Check if MCP servers are healthy
+     */
+    static checkHealth(): Promise<{
+        healthy: boolean;
+        issues: string[];
+    }>;
+}
+//# sourceMappingURL=mcp-singleton-enforcer.d.ts.map

package/dist/utils/mcp-singleton-enforcer.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * MCP Singleton Enforcer
+ * Ensures only ONE set of MCP servers can run at a time
+ * v2.10.0 - Critical fix for duplicate MCP servers causing timeouts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPSingletonEnforcer = void 0;
+const logger_js_1 = require("./logger.js");
+const child_process_1 = require("child_process");
+const mcp_singleton_lock_js_1 = require("./mcp-singleton-lock.js");
+const logger = new logger_js_1.Logger('MCPSingletonEnforcer');
+class MCPSingletonEnforcer {
+    /**
+     * Kill ALL existing MCP processes before starting new ones
+     * This is a nuclear option but necessary to prevent timeouts
+     */
+    static killAllMCPProcesses() {
+        try {
+            // Count existing processes
+            const countCmd = "ps aux | grep -E 'mcp.*\\.js' | grep -v grep | wc -l";
+            const count = parseInt((0, child_process_1.execSync)(countCmd, { encoding: 'utf8' }).trim());
+            if (count > 0) {
+                logger.warn(`🔪 Found ${count} existing MCP processes, killing them all...`);
+                // Kill all MCP processes
+                try {
+                    (0, child_process_1.execSync)("pkill -f 'mcp.*\\.js'", { encoding: 'utf8' });
+                    logger.info('✅ Killed all existing MCP processes');
+                }
+                catch (e) {
+                    // pkill returns non-zero if no processes found, which is fine
+                }
+                // Also kill by specific patterns
+                const patterns = [
+                    'snow-flow-mcp',
+                    'servicenow-.*-mcp',
+                    'mcp/.*\\.js'
+                ];
+                for (const pattern of patterns) {
+                    try {
+                        (0, child_process_1.execSync)(`pkill -f '${pattern}'`, { encoding: 'utf8' });
+                    }
+                    catch (e) {
+                        // Ignore errors, process might not exist
+                    }
+                }
+                // Wait a moment for processes to die
+                (0, child_process_1.execSync)('sleep 1', { encoding: 'utf8' });
+                // Verify they're gone
+                const remaining = parseInt((0, child_process_1.execSync)(countCmd, { encoding: 'utf8' }).trim());
+                if (remaining > 0) {
+                    logger.warn(`⚠️ ${remaining} MCP processes still running after kill`);
+                    // Force kill with -9
+                    try {
+                        (0, child_process_1.execSync)("pkill -9 -f 'mcp.*\\.js'", { encoding: 'utf8' });
+                        logger.info('✅ Force killed remaining MCP processes');
+                    }
+                    catch (e) {
+                        // Ignore
+                    }
+                }
+                return count;
+            }
+            return 0;
+        }
+        catch (error) {
+            logger.error('Error checking/killing MCP processes:', error.message);
+            return 0;
+        }
+    }
+    /**
+     * Enforce singleton before any MCP operation
+     * This should be called before starting ANY MCP server
+     */
+    static enforce() {
+        if (this.enforced) {
+            logger.debug('Singleton already enforced in this session');
+            return true;
+        }
+        // Check if strict mode is enabled
+        const strictMode = process.env.SNOW_MCP_SINGLETON_STRICT === 'true';
+        if (strictMode) {
+            logger.info('🔒 Strict singleton mode enabled');
+            // Kill any existing processes first
+            const killed = this.killAllMCPProcesses();
+            if (killed > 0) {
+                logger.info(`🧹 Cleaned up ${killed} stale MCP processes`);
+            }
+        }
+        // Try to acquire singleton lock
+        const lock = (0, mcp_singleton_lock_js_1.getMCPSingletonLock)();
+        if (!lock.acquire()) {
+            if (strictMode) {
+                // In strict mode, force release and try again
+                logger.warn('⚠️ Lock exists, forcing release in strict mode...');
+                mcp_singleton_lock_js_2.MCPSingletonLock.forceRelease();
+                // Try once more
+                if (!lock.acquire()) {
+                    throw new Error('Cannot acquire MCP singleton lock even after force release');
+                }
+                logger.info('✅ Acquired lock after force release');
+            }
+            else {
+                throw new Error('MCP servers already running. Use SNOW_MCP_SINGLETON_STRICT=true to force');
+            }
+        }
+        this.enforced = true;
+        logger.info('✅ MCP singleton enforced successfully');
+        // Set up cleanup on exit
+        this.setupCleanup(lock);
+        return true;
+    }
+    /**
+     * Setup cleanup handlers
+     */
+    static setupCleanup(lock) {
+        const cleanup = () => {
+            if (this.enforced) {
+                logger.info('🧹 Cleaning up MCP singleton...');
+                lock.release();
+                this.enforced = false;
+                // Kill all MCP processes on exit
+                this.killAllMCPProcesses();
+            }
+        };
+        process.once('exit', cleanup);
+        process.once('SIGINT', () => {
+            cleanup();
+            process.exit(0);
+        });
+        process.once('SIGTERM', () => {
+            cleanup();
+            process.exit(0);
+        });
+    }
+    /**
+     * Check if MCP servers are healthy
+     */
+    static async checkHealth() {
+        const issues = [];
+        try {
+            // Check process count
+            const countCmd = "ps aux | grep -E 'mcp.*\\.js' | grep -v grep | wc -l";
+            const count = parseInt((0, child_process_1.execSync)(countCmd, { encoding: 'utf8' }).trim());
+            if (count === 0) {
+                issues.push('No MCP servers running');
+            }
+            else if (count > 15) {
+                issues.push(`Too many MCP servers running: ${count}`);
+            }
+            // Check memory usage
+            const memCmd = "ps aux | grep -E 'mcp.*\\.js' | grep -v grep | awk '{sum+=$6} END {print sum/1024}'";
+            const memMB = parseFloat((0, child_process_1.execSync)(memCmd, { encoding: 'utf8' }).trim() || '0');
+            if (memMB > 3000) {
+                issues.push(`High memory usage: ${memMB.toFixed(0)}MB`);
+            }
+            // Check for zombie processes
+            const zombieCmd = "ps aux | grep -E 'mcp.*\\.js.*<defunct>' | grep -v grep | wc -l";
+            const zombies = parseInt((0, child_process_1.execSync)(zombieCmd, { encoding: 'utf8' }).trim());
+            if (zombies > 0) {
+                issues.push(`Found ${zombies} zombie MCP processes`);
+            }
+        }
+        catch (error) {
+            issues.push(`Health check error: ${error.message}`);
+        }
+        return {
+            healthy: issues.length === 0,
+            issues
+        };
+    }
+}
+exports.MCPSingletonEnforcer = MCPSingletonEnforcer;
+MCPSingletonEnforcer.enforced = false;
+// Import the singleton lock class
+const mcp_singleton_lock_js_2 = require("./mcp-singleton-lock.js");
+//# sourceMappingURL=mcp-singleton-enforcer.js.map

package/dist/utils/mcp-timeout-fix.d.ts

@@ -0,0 +1,44 @@
+/**
+ * MCP Timeout Fix
+ * Addresses timeout issues with MCP operations, especially memory_usage
+ * v2.10.0 - Critical fix for hanging MCP operations
+ */
+export interface TimeoutConfig {
+    startup: number;
+    operation: number;
+    deployment: number;
+    memory: number;
+    global: number;
+}
+export declare class MCPTimeoutManager {
+    private static instance;
+    private config;
+    private constructor();
+    static getInstance(): MCPTimeoutManager;
+    /**
+     * Get timeout for specific operation type
+     */
+    getTimeout(operationType: 'startup' | 'operation' | 'deployment' | 'memory' | 'global'): number;
+    /**
+     * Execute an operation with timeout protection
+     */
+    executeWithTimeout<T>(operation: Promise<T>, timeoutMs: number, operationName: string): Promise<T>;
+    /**
+     * Create a timeout-protected wrapper for MCP operations
+     */
+    wrapMCPOperation<T>(operation: () => Promise<T>, operationType?: 'startup' | 'operation' | 'deployment' | 'memory' | 'global', customTimeout?: number): Promise<T>;
+    /**
+     * Special handling for memory operations which tend to hang
+     */
+    executeMemoryOperation<T>(operation: () => Promise<T>): Promise<T>;
+    /**
+     * Get recommended timeout settings for slow instances
+     */
+    getSlowInstanceRecommendations(): Record<string, string>;
+    /**
+     * Apply timeout override if configured
+     */
+    applyOverride(): void;
+}
+export declare const mcpTimeoutManager: MCPTimeoutManager;
+//# sourceMappingURL=mcp-timeout-fix.d.ts.map

package/dist/utils/mcp-timeout-fix.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * MCP Timeout Fix
+ * Addresses timeout issues with MCP operations, especially memory_usage
+ * v2.10.0 - Critical fix for hanging MCP operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpTimeoutManager = exports.MCPTimeoutManager = void 0;
+const logger_js_1 = require("./logger.js");
+const logger = new logger_js_1.Logger('MCPTimeoutFix');
+class MCPTimeoutManager {
+    constructor() {
+        // Load timeout values from environment with increased defaults
+        this.config = {
+            startup: parseInt(process.env.SNOW_MCP_STARTUP_TIMEOUT || '120000'), // 2 minutes
+            operation: parseInt(process.env.SNOW_MCP_OPERATION_TIMEOUT || '300000'), // 5 minutes
+            deployment: parseInt(process.env.MCP_DEPLOYMENT_TIMEOUT || '720000'), // 12 minutes
+            memory: parseInt(process.env.SNOW_MCP_MEMORY_TIMEOUT || '60000'), // 1 minute for memory ops
+            global: parseInt(process.env.SNOW_API_TIMEOUT || '180000') // 3 minutes global
+        };
+        logger.info('🕐 MCP Timeout Configuration:', {
+            startup: `${this.config.startup / 1000}s`,
+            operation: `${this.config.operation / 1000}s`,
+            deployment: `${this.config.deployment / 1000}s`,
+            memory: `${this.config.memory / 1000}s`,
+            global: `${this.config.global / 1000}s`
+        });
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new MCPTimeoutManager();
+        }
+        return this.instance;
+    }
+    /**
+     * Get timeout for specific operation type
+     */
+    getTimeout(operationType) {
+        return this.config[operationType];
+    }
+    /**
+     * Execute an operation with timeout protection
+     */
+    async executeWithTimeout(operation, timeoutMs, operationName) {
+        return new Promise((resolve, reject) => {
+            let timeoutHandle;
+            let completed = false;
+            // Set up timeout
+            timeoutHandle = setTimeout(() => {
+                if (!completed) {
+                    completed = true;
+                    logger.error(`⏱️ Operation '${operationName}' timed out after ${timeoutMs / 1000}s`);
+                    reject(new Error(`Operation '${operationName}' timed out after ${timeoutMs / 1000} seconds`));
+                }
+            }, timeoutMs);
+            // Execute operation
+            operation
+                .then(result => {
+                if (!completed) {
+                    completed = true;
+                    clearTimeout(timeoutHandle);
+                    resolve(result);
+                }
+            })
+                .catch(error => {
+                if (!completed) {
+                    completed = true;
+                    clearTimeout(timeoutHandle);
+                    reject(error);
+                }
+            });
+        });
+    }
+    /**
+     * Create a timeout-protected wrapper for MCP operations
+     */
+    wrapMCPOperation(operation, operationType = 'operation', customTimeout) {
+        const timeout = customTimeout || this.getTimeout(operationType);
+        const operationName = `MCP ${operationType}`;
+        logger.debug(`⏱️ Starting ${operationName} with ${timeout / 1000}s timeout`);
+        return this.executeWithTimeout(operation(), timeout, operationName);
+    }
+    /**
+     * Special handling for memory operations which tend to hang
+     */
+    async executeMemoryOperation(operation) {
+        const maxRetries = 3;
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                logger.debug(`🧠 Memory operation attempt ${attempt}/${maxRetries}`);
+                // Use shorter timeout for memory operations
+                const result = await this.wrapMCPOperation(operation, 'memory', this.config.memory);
+                logger.debug(`✅ Memory operation succeeded on attempt ${attempt}`);
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                logger.warn(`⚠️ Memory operation attempt ${attempt} failed:`, error.message);
+                if (attempt < maxRetries) {
+                    // Wait before retrying
+                    const delay = attempt * 1000; // Progressive delay
+                    logger.debug(`⏳ Waiting ${delay}ms before retry...`);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        throw new Error(`Memory operation failed after ${maxRetries} attempts: ${lastError?.message}`);
+    }
+    /**
+     * Get recommended timeout settings for slow instances
+     */
+    getSlowInstanceRecommendations() {
+        return {
+            SNOW_API_TIMEOUT: '300000', // 5 minutes
+            SNOW_MCP_STARTUP_TIMEOUT: '180000', // 3 minutes
+            SNOW_MCP_OPERATION_TIMEOUT: '600000', // 10 minutes
+            MCP_DEPLOYMENT_TIMEOUT: '900000', // 15 minutes
+            SNOW_MCP_MEMORY_TIMEOUT: '120000', // 2 minutes
+            SNOW_MAX_CONCURRENT_REQUESTS: '5',
+            SNOW_BATCH_DELAY: '500'
+        };
+    }
+    /**
+     * Apply timeout override if configured
+     */
+    applyOverride() {
+        const override = process.env.SNOW_TIMEOUT_OVERRIDE;
+        if (override) {
+            const overrideMs = parseInt(override);
+            if (!isNaN(overrideMs)) {
+                logger.warn(`⚠️ Applying global timeout override: ${overrideMs / 1000}s`);
+                this.config = {
+                    startup: overrideMs,
+                    operation: overrideMs,
+                    deployment: overrideMs,
+                    memory: Math.min(overrideMs, 120000), // Cap memory ops at 2 minutes
+                    global: overrideMs
+                };
+            }
+        }
+    }
+}
+exports.MCPTimeoutManager = MCPTimeoutManager;
+// Export singleton instance
+exports.mcpTimeoutManager = MCPTimeoutManager.getInstance();
+//# sourceMappingURL=mcp-timeout-fix.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "2.9.9",
+  "version": "2.10.0",
   "description": "Snow-Flow: ServiceNow Advanced Intelligence Platform - 100+ real MCP tools with AI-powered swarm orchestration and neural networks. Dynamic task categorization using AI. Machine learning for incident classification, change risk prediction, and anomaly detection. Zero Mock Data, 100% Real API Integration.",
   "main": "dist/index.js",
   "type": "commonjs",