snow-flow 3.0.8 → 3.0.10

package/dist/utils/mcp-process-manager.backup.d.ts

@@ -1,58 +0,0 @@
-/**
- * MCP Process Manager
- * Prevents excessive MCP server spawning and manages resource limits
- */
-export declare class MCPProcessManager {
-    private static instance;
-    private readonly MAX_MCP_SERVERS;
-    private readonly MAX_MEMORY_MB;
-    private readonly CLEANUP_INTERVAL;
-    private cleanupTimer?;
-    private constructor();
-    static getInstance(): MCPProcessManager;
-    /**
-     * Check if we can spawn a new MCP server
-     */
-    canSpawnServer(): boolean;
-    /**
-     * Get current MCP system status
-     */
-    getSystemStatus(): {
-        processCount: number;
-        memoryUsageMB: number;
-        processes: Array<{
-            pid: number;
-            memory: number;
-            name: string;
-        }>;
-    };
-    /**
-     * Kill duplicate MCP servers (keep only the newest)
-     */
-    killDuplicates(): void;
-    /**
-     * Kill all MCP servers
-     */
-    killAll(): void;
-    /**
-     * Clean up excessive resources
-     */
-    cleanup(): void;
-    /**
-     * Start periodic cleanup
-     */
-    private startPeriodicCleanup;
-    /**
-     * Stop periodic cleanup
-     */
-    stopPeriodicCleanup(): void;
-    /**
-     * Get resource usage summary
-     */
-    getResourceSummary(): string;
-    /**
-     * Get health status
-     */
-    getHealthStatus(): 'healthy' | 'warning' | 'critical';
-}
-//# sourceMappingURL=mcp-process-manager.backup.d.ts.map

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

@@ -1,220 +0,0 @@
-"use strict";
-/**
- * MCP Process Manager
- * Prevents excessive MCP server spawning and manages resource limits
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCPProcessManager = void 0;
-const child_process_1 = require("child_process");
-const logger_js_1 = require("./logger.js");
-const logger = new logger_js_1.Logger('MCPProcessManager');
-class MCPProcessManager {
-    constructor() {
-        this.MAX_MCP_SERVERS = parseInt(process.env.SNOW_MAX_MCP_SERVERS || '10');
-        this.MAX_MEMORY_MB = parseInt(process.env.SNOW_MCP_MEMORY_LIMIT || '1500');
-        this.CLEANUP_INTERVAL = 60000; // 1 minute
-        // Start periodic cleanup
-        this.startPeriodicCleanup();
-    }
-    static getInstance() {
-        if (!MCPProcessManager.instance) {
-            MCPProcessManager.instance = new MCPProcessManager();
-        }
-        return MCPProcessManager.instance;
-    }
-    /**
-     * Check if we can spawn a new MCP server
-     */
-    canSpawnServer() {
-        const status = this.getSystemStatus();
-        if (status.processCount >= this.MAX_MCP_SERVERS) {
-            logger.warn(`❌ Cannot spawn: Already at max servers (${status.processCount}/${this.MAX_MCP_SERVERS})`);
-            return false;
-        }
-        if (status.memoryUsageMB > this.MAX_MEMORY_MB) {
-            logger.warn(`❌ Cannot spawn: Memory limit exceeded (${status.memoryUsageMB}MB > ${this.MAX_MEMORY_MB}MB)`);
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Get current MCP system status
-     */
-    getSystemStatus() {
-        try {
-            // Count MCP processes
-            const psOutput = (0, child_process_1.execSync)('ps aux | grep -E "mcp|servicenow.*mcp" | grep -v grep', {
-                encoding: 'utf8'
-            }).trim();
-            if (!psOutput) {
-                return {
-                    processCount: 0,
-                    memoryUsageMB: 0,
-                    processes: []
-                };
-            }
-            const lines = psOutput.split('\n');
-            const processes = [];
-            let totalMemory = 0;
-            for (const line of lines) {
-                const parts = line.split(/\s+/);
-                if (parts.length > 10) {
-                    const pid = parseInt(parts[1]);
-                    const memory = Math.round(parseInt(parts[5]) / 1024); // Convert KB to MB
-                    const name = parts.slice(10).join(' ');
-                    processes.push({ pid, memory, name });
-                    totalMemory += memory;
-                }
-            }
-            return {
-                processCount: processes.length,
-                memoryUsageMB: totalMemory,
-                processes
-            };
-        }
-        catch (error) {
-            // No MCP processes found
-            return {
-                processCount: 0,
-                memoryUsageMB: 0,
-                processes: []
-            };
-        }
-    }
-    /**
-     * Kill duplicate MCP servers (keep only the newest)
-     */
-    killDuplicates() {
-        const status = this.getSystemStatus();
-        // Group processes by server type
-        const serverGroups = new Map();
-        for (const proc of status.processes) {
-            // Extract server type from process name
-            const match = proc.name.match(/servicenow-([^-]+)-mcp\.js/);
-            if (match) {
-                const serverType = match[1];
-                if (!serverGroups.has(serverType)) {
-                    serverGroups.set(serverType, []);
-                }
-                serverGroups.get(serverType).push({
-                    pid: proc.pid,
-                    memory: proc.memory
-                });
-            }
-        }
-        // Kill duplicates (keep the first one)
-        for (const [serverType, procs] of serverGroups) {
-            if (procs.length > 1) {
-                logger.warn(`Found ${procs.length} instances of ${serverType}-mcp, killing duplicates...`);
-                // Sort by PID (older PIDs first) and keep the first one
-                procs.sort((a, b) => a.pid - b.pid);
-                for (let i = 1; i < procs.length; i++) {
-                    try {
-                        process.kill(procs[i].pid, 'SIGTERM');
-                        logger.info(`Killed duplicate ${serverType}-mcp (PID: ${procs[i].pid})`);
-                    }
-                    catch (error) {
-                        // Process might already be dead
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Kill all MCP servers
-     */
-    killAll() {
-        try {
-            (0, child_process_1.execSync)('pkill -f mcp', { encoding: 'utf8' });
-            logger.info('✅ Killed all MCP processes');
-        }
-        catch (error) {
-            // pkill returns non-zero if no processes found
-        }
-    }
-    /**
-     * Clean up excessive resources
-     */
-    cleanup() {
-        const status = this.getSystemStatus();
-        if (status.processCount > this.MAX_MCP_SERVERS) {
-            logger.warn(`🧹 Cleaning up excessive MCP servers (${status.processCount} > ${this.MAX_MCP_SERVERS})`);
-            this.killDuplicates();
-        }
-        if (status.memoryUsageMB > this.MAX_MEMORY_MB) {
-            logger.warn(`🧹 Memory usage too high (${status.memoryUsageMB}MB), killing oldest processes...`);
-            // Sort by memory usage and kill the highest consumers
-            const sorted = status.processes.sort((a, b) => b.memory - a.memory);
-            let memoryFreed = 0;
-            for (const proc of sorted) {
-                if (status.memoryUsageMB - memoryFreed <= this.MAX_MEMORY_MB * 0.8) {
-                    break; // Stop when we're at 80% of limit
-                }
-                try {
-                    process.kill(proc.pid, 'SIGTERM');
-                    memoryFreed += proc.memory;
-                    logger.info(`Killed high-memory process (PID: ${proc.pid}, ${proc.memory}MB)`);
-                }
-                catch (error) {
-                    // Process might already be dead
-                }
-            }
-        }
-    }
-    /**
-     * Start periodic cleanup
-     */
-    startPeriodicCleanup() {
-        // Clear existing timer
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-        }
-        // Run cleanup periodically
-        this.cleanupTimer = setInterval(() => {
-            const status = this.getSystemStatus();
-            if (status.processCount > this.MAX_MCP_SERVERS * 0.8 ||
-                status.memoryUsageMB > this.MAX_MEMORY_MB * 0.8) {
-                logger.info('🔄 Running periodic MCP cleanup...');
-                this.cleanup();
-            }
-        }, this.CLEANUP_INTERVAL);
-        // Don't block process exit
-        this.cleanupTimer.unref();
-    }
-    /**
-     * Stop periodic cleanup
-     */
-    stopPeriodicCleanup() {
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-            this.cleanupTimer = undefined;
-        }
-    }
-    /**
-     * Get resource usage summary
-     */
-    getResourceSummary() {
-        const status = this.getSystemStatus();
-        return `MCP Resources:
-  Processes: ${status.processCount}/${this.MAX_MCP_SERVERS} (${Math.round(status.processCount / this.MAX_MCP_SERVERS * 100)}%)
-  Memory: ${status.memoryUsageMB}MB/${this.MAX_MEMORY_MB}MB (${Math.round(status.memoryUsageMB / this.MAX_MEMORY_MB * 100)}%)
-  Status: ${this.getHealthStatus()}`;
-    }
-    /**
-     * Get health status
-     */
-    getHealthStatus() {
-        const status = this.getSystemStatus();
-        const processPercent = status.processCount / this.MAX_MCP_SERVERS;
-        const memoryPercent = status.memoryUsageMB / this.MAX_MEMORY_MB;
-        if (processPercent > 0.9 || memoryPercent > 0.9) {
-            return 'critical';
-        }
-        if (processPercent > 0.7 || memoryPercent > 0.7) {
-            return 'warning';
-        }
-        return 'healthy';
-    }
-}
-exports.MCPProcessManager = MCPProcessManager;
-//# sourceMappingURL=mcp-process-manager.backup.js.map

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

@@ -1,36 +0,0 @@
-/**
- * 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;
-    private static killTimer;
-    private static readonly MAX_PROCESSES;
-    /**
-     * Emergency cleanup - use when system is completely stuck
-     */
-    static emergencyCleanup(): void;
-    /**
-     * Kill ALL existing MCP processes FORCEFULLY
-     * 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

@@ -1,201 +0,0 @@
-"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 {
-    /**
-     * Emergency cleanup - use when system is completely stuck
-     */
-    static emergencyCleanup() {
-        logger.warn('🚨 EMERGENCY MCP CLEANUP INITIATED');
-        this.killAllMCPProcesses();
-        // Force release any locks
-        try {
-            const lock = (0, mcp_singleton_lock_js_1.getMCPSingletonLock)();
-            if (lock.isAcquired()) {
-                lock.release();
-            }
-            mcp_singleton_lock_js_2.MCPSingletonLock.forceRelease();
-        }
-        catch (e) {
-            // Ignore lock errors during emergency cleanup
-        }
-        this.enforced = false;
-        // Re-enforce with strict mode
-        process.env.SNOW_MCP_SINGLETON_STRICT = 'true';
-        this.enforce();
-    }
-    /**
-     * Kill ALL existing MCP processes FORCEFULLY
-     * 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 AGGRESSIVELY with -9
-                try {
-                    (0, child_process_1.execSync)("pkill -9 -f 'mcp.*\\.js'", { encoding: 'utf8' });
-                    logger.info('✅ Force 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;
-MCPSingletonEnforcer.killTimer = null;
-MCPSingletonEnforcer.MAX_PROCESSES = 5;
-// 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

@@ -1,53 +0,0 @@
-/**
- * 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
-     * WORKAROUND: Use file-based fallback when MCP memory operations fail
-     */
-    executeMemoryOperation<T>(operation: () => Promise<T>, fallbackToFile?: boolean): Promise<T>;
-    /**
-     * WORKAROUND: Kill hanging MCP operations
-     */
-    killHangingOperation(operationId: string): Promise<void>;
-    /**
-     * Get recommended timeout settings for slow instances
-     */
-    getSlowInstanceRecommendations(): Record<string, string>;
-    /**
-     * WORKAROUND: Emergency timeout reduction for stuck systems
-     */
-    applyEmergencyTimeouts(): void;
-    /**
-     * Apply timeout override if configured
-     */
-    applyOverride(): void;
-}
-export declare const mcpTimeoutManager: MCPTimeoutManager;
-//# sourceMappingURL=mcp-timeout-fix.d.ts.map