@mrxkun/mcfast-mcp 4.1.11 → 4.1.12

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.1.11",
-  "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. v4.1.11: Suppress console output to prevent JSON-RPC stream corruption.",
+  "version": "4.1.12",
+  "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. v4.1.12: Implement proper MCP stdio transport lifecycle and cleanup to prevent zombie processes.",
   "type": "module",
   "bin": {
     "mcfast-mcp": "src/index.js"

package/src/index.js

@@ -757,6 +757,16 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     required: []
                 }
+            },
+            // HEALTH CHECK TOOL
+            {
+                name: "health_check",
+                description: "💚 Check MCP server health status and resource usage. Returns: process status, memory engine state, uptime, and system metrics.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                    required: []
+                }
             }
         ],
     };
@@ -964,6 +974,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             result = await projectAnalyzeExecute(args);
             summary = 'Project analyzed';
         }
+        // HEALTH CHECK TOOL
+        else if (name === "health_check") {
+            result = await handleHealthCheck();
+            summary = 'Health check completed';
+        }
         else {
             throw new Error(`Tool not found: ${name}`);
         }
@@ -3352,6 +3367,74 @@ async function handleSelectStrategy({ instruction, files = [] }) {
     }
 }
 
+/**
+ * HEALTH CHECK HANDLER
+ */
+async function handleHealthCheck() {
+    const start = Date.now();
+    
+    try {
+        const memoryStats = memoryEngine ? await memoryEngine.getStats() : null;
+        const watcherStats = memoryEngine?.watcher ? memoryEngine.watcher.getStats() : null;
+        
+        const health = {
+            status: 'healthy',
+            timestamp: Date.now(),
+            pid: process.pid,
+            uptime: process.uptime(),
+            memoryUsage: {
+                rss: Math.round(process.memoryUsage().rss / 1024 / 1024) + ' MB',
+                heapTotal: Math.round(process.memoryUsage().heapTotal / 1024 / 1024) + ' MB',
+                heapUsed: Math.round(process.memoryUsage().heapUsed / 1024 / 1024) + ' MB',
+                external: Math.round(process.memoryUsage().external / 1024 / 1024) + ' MB'
+            },
+            memoryEngine: {
+                ready: memoryEngineReady,
+                initialized: memoryEngine?.isInitialized || false,
+                stats: memoryStats
+            },
+            fileWatcher: watcherStats || {
+                enabled: process.env.MCFAST_FILE_WATCHER !== 'false',
+                status: 'not_running'
+            },
+            latencyMs: Date.now() - start
+        };
+        
+        reportAudit({
+            tool: 'health_check',
+            status: 'success',
+            latency_ms: health.latencyMs
+        });
+        
+        return {
+            content: [{
+                type: 'text',
+                text: JSON.stringify(health, null, 2)
+            }]
+        };
+        
+    } catch (error) {
+        reportAudit({
+            tool: 'health_check',
+            status: 'error',
+            error_message: error.message,
+            latency_ms: Date.now() - start
+        });
+        
+        return {
+            content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    status: 'error',
+                    error: error.message,
+                    timestamp: Date.now()
+                })
+            }],
+            isError: true
+        };
+    }
+}
+
 /**
  * Start Server
  */
@@ -3366,6 +3449,25 @@ if (!lockAcquired) {
 
 const transport = new StdioServerTransport();
 
+// MCP Stdio Transport Best Practice: Detect client disconnection
+// https://modelcontextprotocol.info/docs/concepts/transports/
+process.stdin.on('end', () => {
+    console.error('[MCP] Client disconnected (stdin closed)');
+    gracefulShutdown('stdin.end');
+});
+
+process.stdin.on('error', (err) => {
+    if (err.code === 'EPIPE' || err.code === 'ECONNRESET') {
+        console.error('[MCP] Client disconnected (broken pipe)');
+        gracefulShutdown('stdin.error');
+    }
+});
+
+process.stdout.on('error', (err) => {
+    console.error('[MCP] stdout error:', err.code);
+    gracefulShutdown('stdout.error');
+});
+
 // Pre-initialize memory engine in background
 backgroundInitializeMemoryEngine().catch(err => {
     console.error(`${colors.yellow}[Memory]${colors.reset} Background init error: ${err.message}`);
@@ -3376,29 +3478,48 @@ backgroundInitializeMemoryEngine().catch(err => {
 async function gracefulShutdown(signal) {
   console.error(`${colors.yellow}[Shutdown]${colors.reset} Received ${signal}, cleaning up...`);
   
+  const SHUTDOWN_TIMEOUT = 5000; // 5 seconds per MCP best practices
+  
   try {
-    // Stop memory engine
-    if (memoryEngine && memoryEngineReady) {
-      await memoryEngine.cleanup();
-    }
-    
-    // Flush audit queue
-    const auditQ = getAuditQueue();
-    await auditQ.destroy();
-    
-    // Release lock
-    await releaseLock();
+    await Promise.race([
+      (async () => {
+        // Stop memory engine
+        if (memoryEngine && memoryEngineReady) {
+          await memoryEngine.cleanup();
+        }
+        
+        // Flush audit queue
+        const auditQ = getAuditQueue();
+        await auditQ.destroy();
+        
+        // Release lock
+        await releaseLock();
+      })(),
+      new Promise(resolve => setTimeout(resolve, SHUTDOWN_TIMEOUT))
+    ]);
     
     console.error(`${colors.green}[Shutdown]${colors.reset} Cleanup complete`);
   } catch (error) {
     console.error(`${colors.red}[Shutdown]${colors.reset} Error during cleanup: ${error.message}`);
   }
   
+  // Always exit (even if cleanup fails) to prevent zombie processes
   process.exit(0);
 }
 
 process.on('SIGINT', () => gracefulShutdown('SIGINT'));
 process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
 
+// Protect against zombie processes - handle unexpected errors
+process.on('uncaughtException', (err) => {
+  console.error('[MCP] Uncaught exception:', err);
+  gracefulShutdown('uncaughtException');
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('[MCP] Unhandled rejection:', reason);
+  gracefulShutdown('unhandledRejection');
+});
+
 await server.connect(transport);
 console.error("mcfast MCP v1.0.0 running on stdio");

package/src/memory/memory-engine.js

@@ -225,23 +225,30 @@ export class MemoryEngine {
       });
     }
     
-    // Initialize file watcher
-    this.watcher = new FileWatcher(projectPath, this, {
-      debounceMs: 1500,
-      ignored: [
-        '**/node_modules/**',
-        '**/.git/**',
-        '**/dist/**',
-        '**/build/**',
-        '**/.mcfast/**',
-        '**/*.log'
-      ]
-    });
-    
-    try {
-      await this.watcher.start();
-    } catch (watcherError) {
-      console.error('[MemoryEngine] ⚠️ File watcher failed to start (continuing without file watching):', watcherError.message);
+    // Initialize file watcher (configurable via MCFAST_FILE_WATCHER env)
+    const ENABLE_FILE_WATCHER = process.env.MCFAST_FILE_WATCHER !== 'false';
+    
+    if (ENABLE_FILE_WATCHER) {
+      this.watcher = new FileWatcher(projectPath, this, {
+        debounceMs: 1500,
+        ignored: [
+          '**/node_modules/**',
+          '**/.git/**',
+          '**/dist/**',
+          '**/build/**',
+          '**/.mcfast/**',
+          '**/*.log'
+        ]
+      });
+      
+      try {
+        await this.watcher.start();
+      } catch (watcherError) {
+        console.error('[MemoryEngine] ⚠️ File watcher failed to start (continuing without file watching):', watcherError.message);
+        this.watcher = null;
+      }
+    } else {
+      console.error('[MemoryEngine] File watcher disabled (MCFAST_FILE_WATCHER=false)');
       this.watcher = null;
     }
     

package/src/memory/watchers/file-watcher.js

@@ -453,19 +453,21 @@ export class FileWatcher {
     
     console.error('[FileWatcher] Stopping...');
     
-    // Stop cleanup interval
+    // 1. Stop cleanup interval
     if (this.cleanupInterval) {
       clearInterval(this.cleanupInterval);
       this.cleanupInterval = null;
     }
     
-    // Process remaining updates
-    if (this.pendingUpdates.size > 0) {
-      console.error(`[FileWatcher] Processing remaining ${this.pendingUpdates.size} updates...`);
-      await this.processQueue();
+    // 2. Clear pending updates map (free memory)
+    this.pendingUpdates.clear();
+    
+    // 3. Cancel debounce timeout if exists
+    if (this.flushQueue && this.flushQueue.cancel) {
+      this.flushQueue.cancel();
     }
     
-    // Close watcher
+    // 4. Close chokidar watcher (critical - prevents persistent file watching)
     if (this.watcher) {
       await this.watcher.close();
       this.watcher = null;