snow-flow 2.8.6 → 2.8.8

package/dist/cli.js

@@ -2365,7 +2365,7 @@ program
                 await manager.initialize();
                 console.log('📡 Starting all ServiceNow MCP servers...');
                 await manager.startAllServers();
-                const status = manager.getServerStatus();
+                const status = manager.getServerList();
                 const running = status.filter((s) => s.status === 'running').length;
                 const total = status.length;
                 console.log(chalk_1.default.green(`✅ Started ${running}/${total} MCP servers successfully!`));
@@ -4058,7 +4058,7 @@ async function handleMCPStart(manager, options) {
     else {
         console.log('📡 Starting all configured MCP servers...');
         await manager.startAllServers();
-        const status = manager.getServerStatus();
+        const status = manager.getServerList();
         const running = status.filter((s) => s.status === 'running').length;
         const total = status.length;
         console.log(`\n✅ Started ${running}/${total} MCP servers`);
@@ -4110,12 +4110,12 @@ async function handleMCPRestart(manager, options) {
         await manager.stopAllServers();
         await manager.startAllServers();
         const running = manager.getRunningServersCount();
-        const total = manager.getServerStatus().length;
+        const total = manager.getServerList().length;
         console.log(`✅ Restarted ${running}/${total} MCP servers`);
     }
 }
 async function handleMCPStatus(manager, options) {
-    const servers = manager.getServerStatus();
+    const servers = manager.getServerList();
     console.log('\n📊 MCP Server Status');
     console.log('═'.repeat(80));
     if (servers.length === 0) {
@@ -4184,7 +4184,7 @@ async function handleMCPLogs(manager, options) {
     }
 }
 async function handleMCPList(manager, options) {
-    const servers = manager.getServerStatus();
+    const servers = manager.getServerList();
     console.log('\n📋 Configured MCP Servers');
     console.log('═'.repeat(80));
     if (servers.length === 0) {

package/dist/health/system-health.js

@@ -254,7 +254,7 @@ class SystemHealth extends events_1.EventEmitter {
     async checkMCP() {
         const startTime = Date.now();
         try {
-            const serverStatuses = this.mcpManager.getServerStatus();
+            const serverStatuses = this.mcpManager.getServerList();
             const totalServers = serverStatuses.length;
             const healthyServers = serverStatuses.filter(s => s.status === 'running').length;
             const unhealthyServers = serverStatuses.filter(s => s.status === 'error').length;

package/dist/mcp/start-all-mcp-servers.d.ts

@@ -1,6 +1,11 @@
 #!/usr/bin/env node
 /**
- * Start all ServiceNow MCP servers
+ * ⚠️ DEPRECATED: Legacy MCP Server Starter
+ *
+ * This script is DEPRECATED and will be removed in v3.0.0
+ * Use MCPServerManager instead for proper server management.
+ *
+ * Migration: Use scripts/start-mcp-proper.js or MCPServerManager directly
  */
 export {};
 //# sourceMappingURL=start-all-mcp-servers.d.ts.map

package/dist/mcp/start-all-mcp-servers.js

@@ -1,86 +1,74 @@
 #!/usr/bin/env node
 "use strict";
 /**
- * Start all ServiceNow MCP servers
+ * ⚠️ DEPRECATED: Legacy MCP Server Starter
+ *
+ * This script is DEPRECATED and will be removed in v3.0.0
+ * Use MCPServerManager instead for proper server management.
+ *
+ * Migration: Use scripts/start-mcp-proper.js or MCPServerManager directly
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-const child_process_1 = require("child_process");
 const logger_js_1 = require("../utils/logger.js");
-const logger = new logger_js_1.Logger('MCPServerLauncher');
+const logger = new logger_js_1.Logger('DeprecatedMCPLauncher');
 async function startAllServers() {
-    logger.info('Starting all ServiceNow MCP servers...');
-    const servers = [
-        {
-            name: 'ServiceNow MCP Server',
-            script: 'dist/mcp/servicenow-mcp-server.js'
-        },
-        {
-            name: 'ServiceNow Deployment MCP',
-            script: 'dist/mcp/servicenow-deployment-mcp.js'
-        },
-        {
-            name: 'ServiceNow Intelligent MCP',
-            script: 'dist/mcp/servicenow-intelligent-mcp.js'
-        },
-        {
-            name: 'ServiceNow Update Set MCP',
-            script: 'dist/mcp/servicenow-update-set-mcp.js'
-        },
-        {
-            name: 'ServiceNow Advanced Features MCP',
-            script: 'dist/mcp/advanced/servicenow-advanced-features-mcp.js'
-        },
-        {
-            name: 'ServiceNow Operations MCP',
-            script: 'dist/mcp/servicenow-operations-mcp.js'
-        },
-        {
-            name: 'ServiceNow Reporting Analytics MCP',
-            script: 'dist/mcp/servicenow-reporting-analytics-mcp.js'
-        },
-        {
-            name: 'ServiceNow Security Compliance MCP',
-            script: 'dist/mcp/servicenow-security-compliance-mcp.js'
-        },
-        {
-            name: 'ServiceNow Platform Development MCP',
-            script: 'dist/mcp/servicenow-platform-development-mcp.js'
-        },
-        {
-            name: 'ServiceNow Automation MCP',
-            script: 'dist/mcp/servicenow-automation-mcp.js'
-        },
-        {
-            name: 'ServiceNow Integration MCP',
-            script: 'dist/mcp/servicenow-integration-mcp.js'
-        },
-        {
-            name: 'Snow-Flow MCP',
-            script: 'dist/mcp/snow-flow-mcp.js'
-        }
-    ];
-    const processes = servers.map(server => {
-        logger.info(`Starting ${server.name}...`);
-        const proc = (0, child_process_1.spawn)('node', [server.script], {
-            stdio: 'inherit',
-            env: { ...process.env }
-        });
-        proc.on('error', (error) => {
-            logger.error(`Failed to start ${server.name}:`, error);
-        });
-        proc.on('exit', (code) => {
-            logger.info(`${server.name} exited with code ${code}`);
-        });
-        return proc;
-    });
-    // Handle graceful shutdown
+    logger.warn('⚠️ DEPRECATED: This start-all-mcp-servers.ts script is deprecated!');
+    logger.warn('   Please use MCPServerManager or scripts/start-mcp-proper.js instead');
+    logger.warn('   This provides proper process management and singleton protection');
+    console.log('\n🔄 Redirecting to proper MCPServerManager...\n');
+    try {
+        // Redirect to proper approach
+        const { MCPServerManager } = await Promise.resolve().then(() => __importStar(require('../utils/mcp-server-manager.js')));
+        const manager = new MCPServerManager();
+        await manager.initialize();
+        await manager.startAllServers();
+        logger.info('✅ Servers started using proper MCPServerManager');
+    }
+    catch (error) {
+        logger.error('❌ Failed to start servers:', error.message);
+        logger.info('💡 Consider migrating to: scripts/start-mcp-proper.js');
+        process.exit(1);
+    }
+    // If we get here, MCPServerManager started successfully
+    logger.info('🎉 Migration successful! Using proper MCPServerManager now.');
+    // Keep process alive to monitor servers (handled by MCPServerManager)
     process.on('SIGINT', () => {
-        logger.info('Shutting down all MCP servers...');
-        processes.forEach(proc => proc.kill());
+        logger.info('👋 Shutting down...');
         process.exit(0);
     });
-    logger.info('All MCP servers started successfully!');
-    logger.info('Press Ctrl+C to stop all servers');
 }
 startAllServers().catch(error => {
     logger.error('Failed to start MCP servers:', error);

package/dist/test-singleton-protection.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Test Singleton Protection for MCP Servers
+ * Verifies that duplicate MCP server instances cannot start
+ */
+declare function testSingletonProtection(): Promise<boolean>;
+export { testSingletonProtection };
+//# sourceMappingURL=test-singleton-protection.d.ts.map

package/dist/test-singleton-protection.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Test Singleton Protection for MCP Servers
+ * Verifies that duplicate MCP server instances cannot start
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testSingletonProtection = testSingletonProtection;
+const mcp_singleton_lock_js_1 = require("./utils/mcp-singleton-lock.js");
+const logger_js_1 = require("./utils/logger.js");
+const logger = new logger_js_1.Logger('SingletonTest');
+async function testSingletonProtection() {
+    console.log('🧪 Testing MCP Singleton Protection\n');
+    console.log('═'.repeat(60));
+    try {
+        // Test 1: First instance should acquire lock successfully
+        console.log('\n1️⃣ Testing first instance lock acquisition...');
+        const firstLock = (0, mcp_singleton_lock_js_1.getMCPSingletonLock)();
+        const firstResult = firstLock.acquire();
+        if (firstResult) {
+            console.log('✅ First instance successfully acquired lock');
+        }
+        else {
+            console.log('❌ First instance failed to acquire lock');
+            return false;
+        }
+        // Test 2: Second instance should fail to acquire lock
+        console.log('\n2️⃣ Testing second instance prevention...');
+        const secondLock = new mcp_singleton_lock_js_1.MCPSingletonLock();
+        const secondResult = secondLock.acquire();
+        if (!secondResult) {
+            console.log('✅ Second instance correctly prevented (singleton working!)');
+        }
+        else {
+            console.log('❌ Second instance acquired lock (singleton BROKEN!)');
+            secondLock.release();
+            firstLock.release();
+            return false;
+        }
+        // Test 3: Lock release and re-acquisition
+        console.log('\n3️⃣ Testing lock release and re-acquisition...');
+        firstLock.release();
+        // Wait a moment for cleanup
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const thirdLock = new mcp_singleton_lock_js_1.MCPSingletonLock();
+        const thirdResult = thirdLock.acquire();
+        if (thirdResult) {
+            console.log('✅ Lock successfully re-acquired after release');
+            thirdLock.release();
+        }
+        else {
+            console.log('❌ Failed to re-acquire lock after release');
+            return false;
+        }
+        // Test 4: Force release functionality
+        console.log('\n4️⃣ Testing force release functionality...');
+        const fourthLock = new mcp_singleton_lock_js_1.MCPSingletonLock();
+        fourthLock.acquire();
+        const forceResult = mcp_singleton_lock_js_1.MCPSingletonLock.forceRelease();
+        if (forceResult) {
+            console.log('✅ Force release successful');
+        }
+        else {
+            console.log('⚠️  No lock to force release (expected if cleanup worked)');
+        }
+        // Clean up
+        fourthLock.release();
+        // Summary
+        console.log('\n' + '═'.repeat(60));
+        console.log('\n📋 SINGLETON PROTECTION TEST RESULTS:\n');
+        console.log('✅ First instance acquires lock correctly');
+        console.log('✅ Duplicate instances are prevented');
+        console.log('✅ Lock release works correctly');
+        console.log('✅ Lock re-acquisition works after release');
+        console.log('✅ Force release works for cleanup');
+        console.log('\n🎯 Practical Impact:');
+        console.log('• No more duplicate MCP servers');
+        console.log('• No more memory exhaustion (1.5GB+ usage)');
+        console.log('• No more random timeouts in swarm operations');
+        console.log('• MCP servers cleanly prevent conflicts');
+        console.log('\n🔧 Usage:');
+        console.log('• MCP servers automatically use singleton protection');
+        console.log('• If stuck: run "npm run cleanup-mcp"');
+        console.log('• Or kill manually: "pkill -f mcp"');
+        return true;
+    }
+    catch (error) {
+        console.error('\n❌ Singleton test failed:', error.message);
+        return false;
+    }
+}
+// Run test if executed directly
+if (require.main === module) {
+    testSingletonProtection()
+        .then(success => {
+        if (success) {
+            console.log('\n🎉 All singleton protection tests PASSED!');
+            process.exit(0);
+        }
+        else {
+            console.log('\n💥 Singleton protection tests FAILED!');
+            process.exit(1);
+        }
+    })
+        .catch(error => {
+        console.error('\n💥 Test execution failed:', error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=test-singleton-protection.js.map

package/dist/utils/mcp-server-manager.d.ts

@@ -59,10 +59,6 @@ export declare class MCPServerManager extends EventEmitter {
      * Stop all running MCP servers
      */
     stopAllServers(): Promise<void>;
-    /**
-     * Get status of all servers
-     */
-    getServerStatus(): MCPServer[];
     /**
      * Get status of a specific server
      */
@@ -83,6 +79,25 @@ export declare class MCPServerManager extends EventEmitter {
      * Remove a server configuration
      */
     removeServer(name: string): Promise<void>;
+    /**
+     * Get list of all servers (for monitoring/status display)
+     */
+    getServerList(): MCPServer[];
+    /**
+     * Get server status by name
+     */
+    getServerStatus(name: string): MCPServer | undefined;
+    /**
+     * Get overall system status
+     */
+    getSystemStatus(): {
+        total: number;
+        running: number;
+        stopped: number;
+        starting: number;
+        error: number;
+        health: string;
+    };
     /**
      * Cleanup - stop all servers and clean up resources
      */

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

@@ -13,6 +13,7 @@ const path_1 = require("path");
 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");
 class MCPServerManager extends events_1.EventEmitter {
     constructor(configPath) {
         super();
@@ -281,6 +282,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.');
+        }
+        console.log('✅ Starting all MCP servers (singleton protected)...');
         const promises = Array.from(this.servers.keys()).map(name => this.startServer(name).catch(error => {
             console.error(`Failed to start server '${name}':`, error);
             return false;
@@ -297,12 +304,6 @@ class MCPServerManager extends events_1.EventEmitter {
         }));
         await Promise.all(promises);
     }
-    /**
-     * Get status of all servers
-     */
-    getServerStatus() {
-        return Array.from(this.servers.values());
-    }
     /**
      * Get status of a specific server
      */
@@ -360,6 +361,34 @@ class MCPServerManager extends events_1.EventEmitter {
         }));
         await this.saveConfiguration(configs);
     }
+    /**
+     * Get list of all servers (for monitoring/status display)
+     */
+    getServerList() {
+        return Array.from(this.servers.values());
+    }
+    /**
+     * Get server status by name
+     */
+    getServerStatus(name) {
+        return this.servers.get(name);
+    }
+    /**
+     * Get overall system status
+     */
+    getSystemStatus() {
+        const servers = this.getServerList();
+        const running = servers.filter(s => s.status === 'running').length;
+        const total = servers.length;
+        return {
+            total,
+            running,
+            stopped: servers.filter(s => s.status === 'stopped').length,
+            starting: servers.filter(s => s.status === 'starting').length,
+            error: servers.filter(s => s.status === 'error').length,
+            health: running === total ? 'healthy' : running > 0 ? 'partial' : 'down'
+        };
+    }
     /**
      * Cleanup - stop all servers and clean up resources
      */

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

@@ -0,0 +1,35 @@
+/**
+ * MCP Singleton Lock Utility
+ * Prevents duplicate MCP server instances across all start mechanisms
+ */
+export declare class MCPSingletonLock {
+    private lockDir;
+    private lockFile;
+    private acquired;
+    constructor();
+    /**
+     * Acquire singleton lock to prevent duplicate MCP server instances
+     */
+    acquire(): boolean;
+    /**
+     * Release the singleton lock
+     */
+    release(): void;
+    /**
+     * Check if lock is currently held by this process
+     */
+    isAcquired(): boolean;
+    /**
+     * Setup cleanup handlers to release lock on process exit
+     */
+    private setupCleanupHandlers;
+    /**
+     * Force release any existing lock (for cleanup scripts)
+     */
+    static forceRelease(): boolean;
+}
+/**
+ * Get the global MCP singleton lock instance
+ */
+export declare function getMCPSingletonLock(): MCPSingletonLock;
+//# sourceMappingURL=mcp-singleton-lock.d.ts.map

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

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * MCP Singleton Lock Utility
+ * Prevents duplicate MCP server instances across all start mechanisms
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPSingletonLock = void 0;
+exports.getMCPSingletonLock = getMCPSingletonLock;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const logger_js_1 = require("./logger.js");
+const logger = new logger_js_1.Logger('MCPSingleton');
+class MCPSingletonLock {
+    constructor() {
+        this.acquired = false;
+        this.lockDir = (0, path_1.join)((0, os_1.homedir)(), '.claude');
+        this.lockFile = (0, path_1.join)(this.lockDir, 'mcp-servers.lock');
+    }
+    /**
+     * Acquire singleton lock to prevent duplicate MCP server instances
+     */
+    acquire() {
+        // Create .claude directory if it doesn't exist
+        if (!(0, fs_1.existsSync)(this.lockDir)) {
+            (0, fs_1.mkdirSync)(this.lockDir, { recursive: true });
+        }
+        // Check if lock exists and process is still running
+        if ((0, fs_1.existsSync)(this.lockFile)) {
+            try {
+                const existingPid = parseInt((0, fs_1.readFileSync)(this.lockFile, 'utf8'));
+                // Check if process is still running
+                try {
+                    process.kill(existingPid, 0); // Signal 0 just checks if process exists
+                    logger.warn(`MCP servers already running with PID: ${existingPid}`);
+                    logger.info('Use "pkill -f mcp" to stop existing servers first');
+                    return false;
+                }
+                catch (e) {
+                    // Process not running, remove stale lock
+                    logger.info('Removing stale lock file from dead process');
+                    (0, fs_1.unlinkSync)(this.lockFile);
+                }
+            }
+            catch (e) {
+                // Invalid lock file, remove it
+                logger.info('Removing invalid lock file');
+                (0, fs_1.unlinkSync)(this.lockFile);
+            }
+        }
+        // Create new lock with current PID
+        (0, fs_1.writeFileSync)(this.lockFile, process.pid.toString());
+        logger.info(`🔒 MCP singleton lock acquired (PID: ${process.pid})`);
+        this.acquired = true;
+        // Set up cleanup handlers
+        this.setupCleanupHandlers();
+        return true;
+    }
+    /**
+     * Release the singleton lock
+     */
+    release() {
+        if (this.acquired && (0, fs_1.existsSync)(this.lockFile)) {
+            try {
+                (0, fs_1.unlinkSync)(this.lockFile);
+                logger.info('🔓 MCP singleton lock released');
+                this.acquired = false;
+            }
+            catch (e) {
+                logger.warn('Failed to release lock file:', e);
+            }
+        }
+    }
+    /**
+     * Check if lock is currently held by this process
+     */
+    isAcquired() {
+        return this.acquired;
+    }
+    /**
+     * Setup cleanup handlers to release lock on process exit
+     */
+    setupCleanupHandlers() {
+        const cleanup = () => {
+            this.release();
+        };
+        process.on('exit', cleanup);
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        process.on('uncaughtException', (error) => {
+            logger.error('Uncaught exception, releasing MCP lock:', error);
+            cleanup();
+            process.exit(1);
+        });
+        process.on('unhandledRejection', (reason) => {
+            logger.error('Unhandled rejection, releasing MCP lock:', reason);
+            cleanup();
+            process.exit(1);
+        });
+    }
+    /**
+     * Force release any existing lock (for cleanup scripts)
+     */
+    static forceRelease() {
+        const lockFile = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'mcp-servers.lock');
+        if ((0, fs_1.existsSync)(lockFile)) {
+            try {
+                (0, fs_1.unlinkSync)(lockFile);
+                logger.info('🔓 Forced release of MCP singleton lock');
+                return true;
+            }
+            catch (e) {
+                logger.error('Failed to force release lock:', e);
+                return false;
+            }
+        }
+        return false; // No lock existed
+    }
+}
+exports.MCPSingletonLock = MCPSingletonLock;
+// Global singleton instance
+let globalLock = null;
+/**
+ * Get the global MCP singleton lock instance
+ */
+function getMCPSingletonLock() {
+    if (!globalLock) {
+        globalLock = new MCPSingletonLock();
+    }
+    return globalLock;
+}
+//# sourceMappingURL=mcp-singleton-lock.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "2.8.6",
+  "version": "2.8.8",
   "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",
@@ -23,6 +23,8 @@
     "reset-mcp:restart": "node scripts/reset-mcp-servers.js --restart",
     "cleanup-mcp": "node scripts/cleanup-mcp-servers.js",
     "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",
     "postbuild-disabled": "npm run setup-mcp",
     "postinstall": "node scripts/postinstall.js",
     "version": "node scripts/update-version.js && npm run build && git add src/version.ts",