snow-flow 2.8.6 → 2.8.7

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Start all ServiceNow MCP servers
+ * Start all ServiceNow MCP servers (WITH SINGLETON PROTECTION)
  */
 export {};
 //# sourceMappingURL=start-all-mcp-servers.d.ts.map

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

@@ -1,14 +1,21 @@
 #!/usr/bin/env node
 "use strict";
 /**
- * Start all ServiceNow MCP servers
+ * Start all ServiceNow MCP servers (WITH SINGLETON PROTECTION)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const logger_js_1 = require("../utils/logger.js");
+const mcp_singleton_lock_js_1 = require("../utils/mcp-singleton-lock.js");
 const logger = new logger_js_1.Logger('MCPServerLauncher');
 async function startAllServers() {
-    logger.info('Starting all ServiceNow MCP servers...');
+    // 🔒 SINGLETON CHECK - Prevent duplicate instances
+    const singletonLock = (0, mcp_singleton_lock_js_1.getMCPSingletonLock)();
+    if (!singletonLock.acquire()) {
+        logger.error('❌ MCP servers already running. Exiting.');
+        process.exit(1);
+    }
+    logger.info('✅ Starting all ServiceNow MCP servers (singleton protected)...');
     const servers = [
         {
             name: 'ServiceNow MCP Server',

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.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;

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.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",