snow-flow 2.9.5 → 2.9.7

package/dist/mcp/servicenow-machine-learning-mcp.js

@@ -1375,13 +1375,19 @@ class ServiceNowMachineLearningMCP {
         // Create tokenizer
         const tokenizer = new Map();
         let tokenIndex = 1;
-        // Get unique categories
-        const categories = [...new Set(incidents.map(i => i.category))];
+        // Get unique categories with fallback
+        let categories = [...new Set(incidents.map(i => i.category).filter(c => c))];
+        // CRITICAL FIX: Ensure we have at least 2 categories to prevent shape (1,1) error
+        if (categories.length < 2) {
+            categories = [...categories, 'other', 'uncategorized'];
+            this.logger.warn(`Only ${categories.length - 2} unique categories found, added fallback categories`);
+        }
+        this.logger.info(`Training with ${categories.length} categories: ${categories.join(', ')}`);
         // Tokenize all text
         const sequences = [];
         for (const incident of incidents) {
-            const text = `${incident.short_description} ${incident.description}`.toLowerCase();
-            const words = text.split(/\s+/);
+            const text = `${incident.short_description || ''} ${incident.description || ''}`.toLowerCase();
+            const words = text.split(/\s+/).filter(w => w.length > 0);
             const sequence = [];
             for (const word of words) {
                 if (!tokenizer.has(word)) {
@@ -1401,9 +1407,27 @@ class ServiceNowMachineLearningMCP {
                 return [...seq, ...new Array(maxLength - seq.length).fill(0)];
             }
         });
+        // Create category indices with improved error handling
+        const categoryIndices = incidents.map(incident => {
+            const category = incident.category || 'uncategorized';
+            const index = categories.indexOf(category);
+            if (index >= 0) {
+                return index;
+            }
+            else {
+                // Fallback to 'other' or first category
+                const otherIndex = categories.indexOf('other');
+                return otherIndex >= 0 ? otherIndex : 0;
+            }
+        });
+        // Validate before creating tensors
+        if (categories.length < 2) {
+            throw new Error(`Insufficient categories for classification: ${categories.length}. Need at least 2 categories.`);
+        }
         // Create features and labels
         const features = tf.tensor2d(paddedSequences);
-        const labels = tf.oneHot(tf.tensor1d(incidents.map(i => categories.indexOf(i.category)), 'int32'), categories.length);
+        const labels = tf.oneHot(tf.tensor1d(categoryIndices, 'int32'), categories.length);
+        this.logger.info(`Prepared training data: features [${paddedSequences.length}, ${maxLength}], labels [${incidents.length}, ${categories.length}]`);
         return { features, labels, tokenizer, categories };
     }
     tokenizeText(text, tokenizer, maxLength) {
@@ -1866,18 +1890,43 @@ class ServiceNowMachineLearningMCP {
     processBatchWithHashing(incidents, categories, hasher) {
         const sequences = [];
         const labels = [];
+        // CRITICAL FIX: Ensure we have at least 2 categories to prevent shape (1,1) error
+        const validCategories = [...categories];
+        if (validCategories.length < 2) {
+            validCategories.push('other', 'uncategorized'); // Add fallback categories
+        }
+        this.logger.info(`Processing batch with ${incidents.length} incidents and ${validCategories.length} categories`);
         for (const incident of incidents) {
-            const text = `${incident.short_description} ${incident.description}`;
+            const text = `${incident.short_description || ''} ${incident.description || ''}`;
             const sequence = hasher(text);
             sequences.push(sequence);
-            // One-hot encode category
-            const categoryIndex = categories.indexOf(incident.category);
-            const label = new Array(categories.length).fill(0);
+            // One-hot encode category with improved error handling
+            const category = incident.category || 'uncategorized';
+            const categoryIndex = validCategories.indexOf(category);
+            const label = new Array(validCategories.length).fill(0);
             if (categoryIndex >= 0) {
                 label[categoryIndex] = 1;
             }
+            else {
+                // Fallback to 'other' category if not found
+                const otherIndex = validCategories.indexOf('other');
+                if (otherIndex >= 0) {
+                    label[otherIndex] = 1;
+                }
+                else {
+                    label[0] = 1; // Use first category as fallback
+                }
+            }
             labels.push(label);
         }
+        // Validate shapes before creating tensors
+        if (sequences.length === 0 || labels.length === 0) {
+            throw new Error('No valid data for training - empty sequences or labels');
+        }
+        if (labels[0].length < 2) {
+            throw new Error(`Insufficient categories for classification: ${labels[0].length}. Need at least 2 categories.`);
+        }
+        this.logger.info(`Creating tensors: features [${sequences.length}, ${sequences[0]?.length}], labels [${labels.length}, ${labels[0]?.length}]`);
         return {
             features: tf.tensor2d(sequences),
             labels: tf.tensor2d(labels)
@@ -1967,10 +2016,18 @@ class ServiceNowMachineLearningMCP {
         const validVocabularySize = Math.max(1000, maxVocabularySize || 5000);
         this.logger.info(`Using vocabulary size: ${validVocabularySize} for data preparation`);
         const hasher = this.createFeatureHasher(validVocabularySize);
-        const categories = [...new Set(incidents.map(i => i.category))].filter(c => c); // Filter out empty categories
-        if (categories.length === 0) {
-            categories.push('uncategorized'); // Ensure at least one category
+        let categories = [...new Set(incidents.map(i => i.category))].filter(c => c); // Filter out empty categories
+        // CRITICAL FIX: Ensure we have at least 2 categories to prevent shape (1,1) error
+        if (categories.length < 2) {
+            if (categories.length === 0) {
+                categories = ['uncategorized', 'other'];
+            }
+            else {
+                categories.push('other');
+            }
+            this.logger.warn(`Insufficient categories found, using fallback categories: ${categories.join(', ')}`);
         }
+        this.logger.info(`Processing with ${categories.length} categories: ${categories.join(', ')}`);
         const sequences = [];
         const labels = [];
         for (const incident of incidents) {
@@ -1985,13 +2042,23 @@ class ServiceNowMachineLearningMCP {
                 return idx;
             });
             sequences.push(validatedSequence);
-            // One-hot encode category
+            // One-hot encode category with improved error handling
             const category = incident.category || 'uncategorized';
             const categoryIndex = categories.indexOf(category);
             const label = new Array(categories.length).fill(0);
             if (categoryIndex >= 0) {
                 label[categoryIndex] = 1;
             }
+            else {
+                // Fallback to 'other' category if not found
+                const otherIndex = categories.indexOf('other');
+                if (otherIndex >= 0) {
+                    label[otherIndex] = 1;
+                }
+                else {
+                    label[0] = 1; // Use first category as final fallback
+                }
+            }
             labels.push(label);
         }
         // Validate sequences before creating tensors

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

@@ -0,0 +1,70 @@
+/**
+ * MCP Process Manager - SAFE VERSION
+ * Emergency fix for memory crash issues
+ * Implements graceful shutdown and memory-safe cleanup
+ */
+export declare class MCPProcessManager {
+    private static instance;
+    private readonly MAX_MCP_SERVERS;
+    private readonly MAX_MEMORY_MB;
+    private readonly CLEANUP_ENABLED;
+    private readonly CLEANUP_INTERVAL;
+    private cleanupTimer?;
+    private isCleaningUp;
+    private constructor();
+    static getInstance(): MCPProcessManager;
+    /**
+     * Check if we can spawn a new MCP server
+     */
+    canSpawnServer(): boolean;
+    /**
+     * Get current MCP system status - SAFER VERSION
+     */
+    getSystemStatus(): {
+        processCount: number;
+        memoryUsageMB: number;
+        processes: Array<{
+            pid: number;
+            memory: number;
+            name: string;
+        }>;
+    };
+    /**
+     * Gracefully shutdown a process with timeout
+     */
+    private gracefulKill;
+    /**
+     * Kill duplicate MCP servers - SAFER VERSION
+     */
+    killDuplicates(): Promise<void>;
+    /**
+     * Emergency cleanup - only for critical situations
+     */
+    emergencyCleanup(): Promise<void>;
+    /**
+     * Safe cleanup - only when absolutely necessary
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Start periodic cleanup - MUCH SAFER
+     */
+    private startPeriodicCleanup;
+    /**
+     * Stop periodic cleanup
+     */
+    stopPeriodicCleanup(): void;
+    /**
+     * Kill all MCP servers - USE WITH CAUTION
+     */
+    killAll(): Promise<void>;
+    /**
+     * Get resource usage summary
+     */
+    getResourceSummary(): string;
+    /**
+     * Get health status
+     */
+    getHealthStatus(): 'healthy' | 'warning' | 'critical';
+}
+export declare const mcpProcessManager: MCPProcessManager;
+//# sourceMappingURL=mcp-process-manager-safe.d.ts.map

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

@@ -0,0 +1,319 @@
+"use strict";
+/**
+ * MCP Process Manager - SAFE VERSION
+ * Emergency fix for memory crash issues
+ * Implements graceful shutdown and memory-safe cleanup
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpProcessManager = exports.MCPProcessManager = void 0;
+const child_process_1 = require("child_process");
+const logger_js_1 = require("./logger.js");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const logger = new logger_js_1.Logger('MCPProcessManager');
+class MCPProcessManager {
+    constructor() {
+        // 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
+        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');
+        }
+    }
+    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();
+        // More lenient limits
+        if (status.processCount >= this.MAX_MCP_SERVERS) {
+            logger.warn(`⚠️ At server limit (${status.processCount}/${this.MAX_MCP_SERVERS}) - consider manual cleanup`);
+            // Still allow spawning unless critically high
+            if (status.processCount >= this.MAX_MCP_SERVERS * 1.5) {
+                return false;
+            }
+        }
+        if (status.memoryUsageMB > this.MAX_MEMORY_MB) {
+            logger.warn(`⚠️ High memory usage (${status.memoryUsageMB}MB > ${this.MAX_MEMORY_MB}MB)`);
+            // Still allow spawning unless critically high
+            if (status.memoryUsageMB > this.MAX_MEMORY_MB * 1.5) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Get current MCP system status - SAFER VERSION
+     */
+    getSystemStatus() {
+        try {
+            // More careful process detection
+            const psOutput = (0, child_process_1.execSync)('ps aux | grep -E "mcp|servicenow.*mcp" | grep -v grep || true', {
+                encoding: 'utf8',
+                maxBuffer: 1024 * 1024 // 1MB buffer limit
+            }).trim();
+            if (!psOutput) {
+                return {
+                    processCount: 0,
+                    memoryUsageMB: 0,
+                    processes: []
+                };
+            }
+            const lines = psOutput.split('\n').slice(0, 100); // Limit to 100 processes
+            const processes = [];
+            let totalMemory = 0;
+            for (const line of lines) {
+                try {
+                    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(' ').substring(0, 100); // Limit name length
+                        if (!isNaN(pid) && !isNaN(memory)) {
+                            processes.push({ pid, memory, name });
+                            totalMemory += memory;
+                        }
+                    }
+                }
+                catch (e) {
+                    // Skip malformed lines
+                }
+            }
+            return {
+                processCount: processes.length,
+                memoryUsageMB: totalMemory,
+                processes
+            };
+        }
+        catch (error) {
+            logger.error('Failed to get system status:', error);
+            return {
+                processCount: 0,
+                memoryUsageMB: 0,
+                processes: []
+            };
+        }
+    }
+    /**
+     * Gracefully shutdown a process with timeout
+     */
+    async gracefulKill(pid, name) {
+        try {
+            // First try SIGTERM for graceful shutdown
+            process.kill(pid, 'SIGTERM');
+            // Wait up to 5 seconds for graceful shutdown
+            let waited = 0;
+            while (waited < 5000) {
+                try {
+                    process.kill(pid, 0); // Check if still alive
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                    waited += 500;
+                }
+                catch {
+                    // Process terminated
+                    logger.info(`✅ Gracefully stopped ${name} (PID: ${pid})`);
+                    return true;
+                }
+            }
+            // Force kill if still alive
+            process.kill(pid, 'SIGKILL');
+            logger.warn(`⚠️ Force killed ${name} (PID: ${pid})`);
+            return true;
+        }
+        catch (error) {
+            if (error.code === 'ESRCH') {
+                // Process already dead
+                return true;
+            }
+            logger.error(`Failed to kill ${name} (PID: ${pid}):`, error);
+            return false;
+        }
+    }
+    /**
+     * Kill duplicate MCP servers - SAFER VERSION
+     */
+    async killDuplicates() {
+        if (this.isCleaningUp) {
+            logger.warn('Cleanup already in progress, skipping...');
+            return;
+        }
+        this.isCleaningUp = true;
+        try {
+            const status = this.getSystemStatus();
+            // Group processes by server type
+            const serverGroups = new Map();
+            for (const proc of status.processes) {
+                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 gracefully
+            for (const [serverType, procs] of serverGroups) {
+                if (procs.length > 2) { // Only clean if more than 2 duplicates
+                    logger.info(`Found ${procs.length} instances of ${serverType}-mcp`);
+                    // Sort by memory usage (kill highest consumers first)
+                    procs.sort((a, b) => b.memory - a.memory);
+                    // Keep 2 instances, kill the rest
+                    for (let i = 2; i < procs.length; i++) {
+                        await this.gracefulKill(procs[i].pid, `${serverType}-mcp`);
+                        // Wait between kills to avoid memory spike
+                        await new Promise(resolve => setTimeout(resolve, 1000));
+                    }
+                }
+            }
+        }
+        finally {
+            this.isCleaningUp = false;
+        }
+    }
+    /**
+     * Emergency cleanup - only for critical situations
+     */
+    async emergencyCleanup() {
+        logger.warn('🚨 EMERGENCY CLEANUP INITIATED');
+        const status = this.getSystemStatus();
+        if (status.memoryUsageMB > this.MAX_MEMORY_MB * 2) {
+            logger.error(`🔴 CRITICAL: Memory usage ${status.memoryUsageMB}MB - killing highest consumers`);
+            // Sort by memory usage
+            const sorted = status.processes.sort((a, b) => b.memory - a.memory);
+            // Kill top 3 memory consumers
+            for (let i = 0; i < Math.min(3, sorted.length); i++) {
+                await this.gracefulKill(sorted[i].pid, sorted[i].name);
+                await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2s between kills
+            }
+            // Force garbage collection if available
+            if (global.gc) {
+                global.gc();
+                logger.info('Forced garbage collection');
+            }
+        }
+    }
+    /**
+     * Safe cleanup - only when absolutely necessary
+     */
+    async cleanup() {
+        if (!this.CLEANUP_ENABLED) {
+            logger.info('Cleanup disabled for stability');
+            return;
+        }
+        if (this.isCleaningUp) {
+            logger.warn('Cleanup already in progress');
+            return;
+        }
+        const status = this.getSystemStatus();
+        // Only cleanup if REALLY necessary
+        if (status.processCount > this.MAX_MCP_SERVERS * 1.5) {
+            logger.warn(`🧹 Too many MCP servers (${status.processCount}), cleaning duplicates...`);
+            await this.killDuplicates();
+        }
+        if (status.memoryUsageMB > this.MAX_MEMORY_MB * 1.5) {
+            await this.emergencyCleanup();
+        }
+    }
+    /**
+     * Start periodic cleanup - MUCH SAFER
+     */
+    startPeriodicCleanup() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+        }
+        // Only run cleanup when critically necessary
+        this.cleanupTimer = setInterval(async () => {
+            try {
+                const status = this.getSystemStatus();
+                // Only cleanup if CRITICALLY high
+                if (status.processCount > this.MAX_MCP_SERVERS * 2 ||
+                    status.memoryUsageMB > this.MAX_MEMORY_MB * 2) {
+                    logger.warn('🔄 Critical resource usage detected, running cleanup...');
+                    await this.cleanup();
+                }
+            }
+            catch (error) {
+                logger.error('Cleanup failed:', error);
+            }
+        }, this.CLEANUP_INTERVAL);
+        // Don't block process exit
+        this.cleanupTimer.unref();
+    }
+    /**
+     * Stop periodic cleanup
+     */
+    stopPeriodicCleanup() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = undefined;
+            logger.info('✅ Periodic cleanup stopped');
+        }
+    }
+    /**
+     * Kill all MCP servers - USE WITH CAUTION
+     */
+    async killAll() {
+        logger.warn('🔴 KILLING ALL MCP PROCESSES');
+        try {
+            // First try graceful shutdown
+            await execAsync('pkill -TERM -f mcp');
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            // Then force kill any remaining
+            await execAsync('pkill -KILL -f mcp');
+            logger.info('✅ All MCP processes terminated');
+        }
+        catch (error) {
+            // pkill returns non-zero if no processes found
+            logger.info('No MCP processes to kill');
+        }
+    }
+    /**
+     * 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)}%)
+  Cleanup: ${this.CLEANUP_ENABLED ? 'ENABLED' : 'DISABLED'}
+  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 > 1.5 || memoryPercent > 1.5) {
+            return 'critical';
+        }
+        if (processPercent > 1.0 || memoryPercent > 1.0) {
+            return 'warning';
+        }
+        return 'healthy';
+    }
+}
+exports.MCPProcessManager = MCPProcessManager;
+// Export singleton instance
+exports.mcpProcessManager = MCPProcessManager.getInstance();
+//# sourceMappingURL=mcp-process-manager-safe.js.map

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

@@ -0,0 +1,58 @@
+/**
+ * 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

@@ -0,0 +1,220 @@
+"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-process-manager.d.ts

@@ -1,13 +1,16 @@
 /**
- * MCP Process Manager
- * Prevents excessive MCP server spawning and manages resource limits
+ * MCP Process Manager - SAFE VERSION
+ * Emergency fix for memory crash issues
+ * Implements graceful shutdown and memory-safe cleanup
  */
 export declare class MCPProcessManager {
     private static instance;
     private readonly MAX_MCP_SERVERS;
     private readonly MAX_MEMORY_MB;
+    private readonly CLEANUP_ENABLED;
     private readonly CLEANUP_INTERVAL;
     private cleanupTimer?;
+    private isCleaningUp;
     private constructor();
     static getInstance(): MCPProcessManager;
     /**
@@ -15,7 +18,7 @@ export declare class MCPProcessManager {
      */
     canSpawnServer(): boolean;
     /**
-     * Get current MCP system status
+     * Get current MCP system status - SAFER VERSION
      */
     getSystemStatus(): {
         processCount: number;
@@ -27,25 +30,33 @@ export declare class MCPProcessManager {
         }>;
     };
     /**
-     * Kill duplicate MCP servers (keep only the newest)
+     * Gracefully shutdown a process with timeout
      */
-    killDuplicates(): void;
+    private gracefulKill;
     /**
-     * Kill all MCP servers
+     * Kill duplicate MCP servers - SAFER VERSION
      */
-    killAll(): void;
+    killDuplicates(): Promise<void>;
     /**
-     * Clean up excessive resources
+     * Emergency cleanup - only for critical situations
      */
-    cleanup(): void;
+    emergencyCleanup(): Promise<void>;
     /**
-     * Start periodic cleanup
+     * Safe cleanup - only when absolutely necessary
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Start periodic cleanup - MUCH SAFER
      */
     private startPeriodicCleanup;
     /**
      * Stop periodic cleanup
      */
     stopPeriodicCleanup(): void;
+    /**
+     * Kill all MCP servers - USE WITH CAUTION
+     */
+    killAll(): Promise<void>;
     /**
      * Get resource usage summary
      */
@@ -55,4 +66,5 @@ export declare class MCPProcessManager {
      */
     getHealthStatus(): 'healthy' | 'warning' | 'critical';
 }
+export declare const mcpProcessManager: MCPProcessManager;
 //# sourceMappingURL=mcp-process-manager.d.ts.map

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

@@ -1,20 +1,33 @@
 "use strict";
 /**
- * MCP Process Manager
- * Prevents excessive MCP server spawning and manages resource limits
+ * MCP Process Manager - SAFE VERSION
+ * Emergency fix for memory crash issues
+ * Implements graceful shutdown and memory-safe cleanup
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCPProcessManager = void 0;
+exports.mcpProcessManager = exports.MCPProcessManager = void 0;
 const child_process_1 = require("child_process");
 const logger_js_1 = require("./logger.js");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
 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();
+        // 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
+        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');
+        }
     }
     static getInstance() {
         if (!MCPProcessManager.instance) {
@@ -27,24 +40,32 @@ class MCPProcessManager {
      */
     canSpawnServer() {
         const status = this.getSystemStatus();
+        // More lenient limits
         if (status.processCount >= this.MAX_MCP_SERVERS) {
-            logger.warn(`❌ Cannot spawn: Already at max servers (${status.processCount}/${this.MAX_MCP_SERVERS})`);
-            return false;
+            logger.warn(`⚠️ At server limit (${status.processCount}/${this.MAX_MCP_SERVERS}) - consider manual cleanup`);
+            // Still allow spawning unless critically high
+            if (status.processCount >= this.MAX_MCP_SERVERS * 1.5) {
+                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;
+            logger.warn(`⚠️ High memory usage (${status.memoryUsageMB}MB > ${this.MAX_MEMORY_MB}MB)`);
+            // Still allow spawning unless critically high
+            if (status.memoryUsageMB > this.MAX_MEMORY_MB * 1.5) {
+                return false;
+            }
         }
         return true;
     }
     /**
-     * Get current MCP system status
+     * Get current MCP system status - SAFER VERSION
      */
     getSystemStatus() {
         try {
-            // Count MCP processes
-            const psOutput = (0, child_process_1.execSync)('ps aux | grep -E "mcp|servicenow.*mcp" | grep -v grep', {
-                encoding: 'utf8'
+            // More careful process detection
+            const psOutput = (0, child_process_1.execSync)('ps aux | grep -E "mcp|servicenow.*mcp" | grep -v grep || true', {
+                encoding: 'utf8',
+                maxBuffer: 1024 * 1024 // 1MB buffer limit
             }).trim();
             if (!psOutput) {
                 return {
@@ -53,17 +74,24 @@ class MCPProcessManager {
                     processes: []
                 };
             }
-            const lines = psOutput.split('\n');
+            const lines = psOutput.split('\n').slice(0, 100); // Limit to 100 processes
             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;
+                try {
+                    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(' ').substring(0, 100); // Limit name length
+                        if (!isNaN(pid) && !isNaN(memory)) {
+                            processes.push({ pid, memory, name });
+                            totalMemory += memory;
+                        }
+                    }
+                }
+                catch (e) {
+                    // Skip malformed lines
                 }
             }
             return {
@@ -73,7 +101,7 @@ class MCPProcessManager {
             };
         }
         catch (error) {
-            // No MCP processes found
+            logger.error('Failed to get system status:', error);
             return {
                 processCount: 0,
                 memoryUsageMB: 0,
@@ -82,100 +110,149 @@ class MCPProcessManager {
         }
     }
     /**
-     * Kill duplicate MCP servers (keep only the newest)
+     * Gracefully shutdown a process with timeout
      */
-    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, []);
+    async gracefulKill(pid, name) {
+        try {
+            // First try SIGTERM for graceful shutdown
+            process.kill(pid, 'SIGTERM');
+            // Wait up to 5 seconds for graceful shutdown
+            let waited = 0;
+            while (waited < 5000) {
+                try {
+                    process.kill(pid, 0); // Check if still alive
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                    waited += 500;
+                }
+                catch {
+                    // Process terminated
+                    logger.info(`✅ Gracefully stopped ${name} (PID: ${pid})`);
+                    return true;
                 }
-                serverGroups.get(serverType).push({
-                    pid: proc.pid,
-                    memory: proc.memory
-                });
             }
+            // Force kill if still alive
+            process.kill(pid, 'SIGKILL');
+            logger.warn(`⚠️ Force killed ${name} (PID: ${pid})`);
+            return true;
         }
-        // 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
-                    }
-                }
+        catch (error) {
+            if (error.code === 'ESRCH') {
+                // Process already dead
+                return true;
             }
+            logger.error(`Failed to kill ${name} (PID: ${pid}):`, error);
+            return false;
         }
     }
     /**
-     * Kill all MCP servers
+     * Kill duplicate MCP servers - SAFER VERSION
      */
-    killAll() {
+    async killDuplicates() {
+        if (this.isCleaningUp) {
+            logger.warn('Cleanup already in progress, skipping...');
+            return;
+        }
+        this.isCleaningUp = true;
         try {
-            (0, child_process_1.execSync)('pkill -f mcp', { encoding: 'utf8' });
-            logger.info('✅ Killed all MCP processes');
+            const status = this.getSystemStatus();
+            // Group processes by server type
+            const serverGroups = new Map();
+            for (const proc of status.processes) {
+                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 gracefully
+            for (const [serverType, procs] of serverGroups) {
+                if (procs.length > 2) { // Only clean if more than 2 duplicates
+                    logger.info(`Found ${procs.length} instances of ${serverType}-mcp`);
+                    // Sort by memory usage (kill highest consumers first)
+                    procs.sort((a, b) => b.memory - a.memory);
+                    // Keep 2 instances, kill the rest
+                    for (let i = 2; i < procs.length; i++) {
+                        await this.gracefulKill(procs[i].pid, `${serverType}-mcp`);
+                        // Wait between kills to avoid memory spike
+                        await new Promise(resolve => setTimeout(resolve, 1000));
+                    }
+                }
+            }
         }
-        catch (error) {
-            // pkill returns non-zero if no processes found
+        finally {
+            this.isCleaningUp = false;
         }
     }
     /**
-     * Clean up excessive resources
+     * Emergency cleanup - only for critical situations
      */
-    cleanup() {
+    async emergencyCleanup() {
+        logger.warn('🚨 EMERGENCY CLEANUP INITIATED');
         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
+        if (status.memoryUsageMB > this.MAX_MEMORY_MB * 2) {
+            logger.error(`🔴 CRITICAL: Memory usage ${status.memoryUsageMB}MB - killing highest consumers`);
+            // Sort by memory usage
             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
-                }
+            // Kill top 3 memory consumers
+            for (let i = 0; i < Math.min(3, sorted.length); i++) {
+                await this.gracefulKill(sorted[i].pid, sorted[i].name);
+                await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2s between kills
+            }
+            // Force garbage collection if available
+            if (global.gc) {
+                global.gc();
+                logger.info('Forced garbage collection');
             }
         }
     }
     /**
-     * Start periodic cleanup
+     * Safe cleanup - only when absolutely necessary
+     */
+    async cleanup() {
+        if (!this.CLEANUP_ENABLED) {
+            logger.info('Cleanup disabled for stability');
+            return;
+        }
+        if (this.isCleaningUp) {
+            logger.warn('Cleanup already in progress');
+            return;
+        }
+        const status = this.getSystemStatus();
+        // Only cleanup if REALLY necessary
+        if (status.processCount > this.MAX_MCP_SERVERS * 1.5) {
+            logger.warn(`🧹 Too many MCP servers (${status.processCount}), cleaning duplicates...`);
+            await this.killDuplicates();
+        }
+        if (status.memoryUsageMB > this.MAX_MEMORY_MB * 1.5) {
+            await this.emergencyCleanup();
+        }
+    }
+    /**
+     * Start periodic cleanup - MUCH SAFER
      */
     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();
+        // Only run cleanup when critically necessary
+        this.cleanupTimer = setInterval(async () => {
+            try {
+                const status = this.getSystemStatus();
+                // Only cleanup if CRITICALLY high
+                if (status.processCount > this.MAX_MCP_SERVERS * 2 ||
+                    status.memoryUsageMB > this.MAX_MEMORY_MB * 2) {
+                    logger.warn('🔄 Critical resource usage detected, running cleanup...');
+                    await this.cleanup();
+                }
+            }
+            catch (error) {
+                logger.error('Cleanup failed:', error);
             }
         }, this.CLEANUP_INTERVAL);
         // Don't block process exit
@@ -188,6 +265,25 @@ class MCPProcessManager {
         if (this.cleanupTimer) {
             clearInterval(this.cleanupTimer);
             this.cleanupTimer = undefined;
+            logger.info('✅ Periodic cleanup stopped');
+        }
+    }
+    /**
+     * Kill all MCP servers - USE WITH CAUTION
+     */
+    async killAll() {
+        logger.warn('🔴 KILLING ALL MCP PROCESSES');
+        try {
+            // First try graceful shutdown
+            await execAsync('pkill -TERM -f mcp');
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            // Then force kill any remaining
+            await execAsync('pkill -KILL -f mcp');
+            logger.info('✅ All MCP processes terminated');
+        }
+        catch (error) {
+            // pkill returns non-zero if no processes found
+            logger.info('No MCP processes to kill');
         }
     }
     /**
@@ -198,6 +294,7 @@ class MCPProcessManager {
         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)}%)
+  Cleanup: ${this.CLEANUP_ENABLED ? 'ENABLED' : 'DISABLED'}
   Status: ${this.getHealthStatus()}`;
     }
     /**
@@ -207,14 +304,16 @@ class MCPProcessManager {
         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) {
+        if (processPercent > 1.5 || memoryPercent > 1.5) {
             return 'critical';
         }
-        if (processPercent > 0.7 || memoryPercent > 0.7) {
+        if (processPercent > 1.0 || memoryPercent > 1.0) {
             return 'warning';
         }
         return 'healthy';
     }
 }
 exports.MCPProcessManager = MCPProcessManager;
+// Export singleton instance
+exports.mcpProcessManager = MCPProcessManager.getInstance();
 //# sourceMappingURL=mcp-process-manager.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "2.9.5",
+  "version": "2.9.7",
   "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",
@@ -22,6 +22,8 @@
     "reset-mcp": "node scripts/reset-mcp-servers.js",
     "reset-mcp:restart": "node scripts/reset-mcp-servers.js --restart",
     "cleanup-mcp": "node scripts/cleanup-mcp-servers.js",
+    "mcp:safe-cleanup": "node scripts/safe-mcp-cleanup.js",
+    "mcp:emergency-stop": "pkill -f mcp || true",
     "mcp:clean": "node scripts/cleanup-mcp-servers.js && npm run build",
     "mcp:start": "node scripts/start-mcp-proper.js",
     "mcp:start-proper": "node scripts/start-mcp-proper.js",