@mrxkun/mcfast-mcp 4.1.10 → 4.1.12

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.1.10",
-  "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. v4.1.10: 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

@@ -75,9 +75,87 @@ import { getAuditQueue } from './utils/audit-queue.js';
 import { getIntelligenceCache } from './utils/intelligence-cache.js';
 import { getContextPrefetcher } from './utils/context-prefetcher.js';
 import { parallelMemorySearch } from './utils/parallel-search.js';
+import { execute as projectAnalyzeExecute } from './tools/project_analyze.js';
 
 const execAsync = promisify(exec);
 
+// ============================================================================
+// LOCK FILE MECHANISM - Prevent multiple instances running simultaneously
+// ============================================================================
+const LOCK_FILE_PATH = path.join(process.cwd(), '.mcfast', '.mcp-instance.lock');
+let lockFileHandle = null;
+
+async function acquireLock() {
+  try {
+    const lockDir = path.dirname(LOCK_FILE_PATH);
+    await fs.mkdir(lockDir, { recursive: true });
+    
+    lockFileHandle = await fs.open(LOCK_FILE_PATH, 'wx');
+    
+    // Write current PID
+    await lockFileHandle.write(`${process.pid}\n${Date.now()}\n`, 0);
+    await lockFileHandle.sync();
+    
+    // Cleanup on exit
+    process.on('beforeExit', releaseLock);
+    process.on('SIGINT', releaseLock);
+    process.on('SIGTERM', releaseLock);
+    process.on('uncaughtException', releaseLock);
+    
+    console.error(`${colors.cyan}[Lock]${colors.reset} Acquired lock file: ${LOCK_FILE_PATH}`);
+    return true;
+  } catch (error) {
+    if (error.code === 'EEXIST') {
+      // Lock file exists, check if it's stale
+      try {
+        const lockContent = await fs.readFile(LOCK_FILE_PATH, 'utf-8');
+        const [pid, timestamp] = lockContent.trim().split('\n');
+        const lockAge = Date.now() - parseInt(timestamp);
+        
+        // Check if process is still running (stale lock if > 5 minutes)
+        if (lockAge > 5 * 60 * 1000) {
+          console.error(`${colors.yellow}[Lock]${colors.reset} Stale lock detected (age: ${Math.round(lockAge / 1000)}s), removing...`);
+          await fs.unlink(LOCK_FILE_PATH);
+          return acquireLock(); // Retry
+        }
+        
+        console.error(`${colors.red}[Lock]${colors.reset} Another instance is already running (PID: ${pid})`);
+        console.error(`${colors.yellow}[Lock]${colors.reset} To force start, delete: ${LOCK_FILE_PATH}`);
+        return false;
+      } catch (readError) {
+        console.error(`${colors.red}[Lock]${colors.reset} Failed to read lock file: ${readError.message}`);
+        return false;
+      }
+    }
+    console.error(`${colors.red}[Lock]${colors.reset} Failed to acquire lock: ${error.message}`);
+    return false;
+  }
+}
+
+async function releaseLock() {
+  if (lockFileHandle) {
+    try {
+      await lockFileHandle.close();
+      lockFileHandle = null;
+    } catch (e) {
+      // Ignore close errors
+    }
+  }
+  
+  try {
+    await fs.unlink(LOCK_FILE_PATH);
+    console.error(`${colors.cyan}[Lock]${colors.reset} Released lock file`);
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      console.error(`${colors.yellow}[Lock]${colors.reset} Failed to release lock: ${error.message}`);
+    }
+  }
+}
+
+// ============================================================================
+// END LOCK FILE MECHANISM
+// ============================================================================
+
 const API_URL = "https://mcfast.vercel.app/api/v1";
 const TOKEN = process.env.MCFAST_TOKEN;
 const VERBOSE = process.env.MCFAST_VERBOSE !== 'false'; // Default: true
@@ -95,28 +173,49 @@ async function backgroundInitializeMemoryEngine() {
     if (memoryEngineInitPromise) return memoryEngineInitPromise;
     
     memoryEngineInitPromise = (async () => {
-        try {
-            memoryEngine = new MemoryEngine({
-                apiKey: TOKEN,
-                enableSync: true
-            });
-            // Use a shorter timeout for initialization
-            const initTimeout = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error('Memory engine init timeout')), 25000);
-            });
-            
-            await Promise.race([
-                memoryEngine.initialize(process.cwd()),
-                initTimeout
-            ]);
-            
-            memoryEngineReady = true;
-            console.error(`${colors.cyan}[Memory]${colors.reset} Engine initialized successfully`);
-        } catch (error) {
-            console.error(`${colors.yellow}[Memory]${colors.reset} Engine initialization failed: ${error.message}`);
-            // Don't throw - allow partial initialization
-            memoryEngineReady = false;
+        const maxRetries = 2;
+        let lastError = null;
+        
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                memoryEngine = new MemoryEngine({
+                    apiKey: TOKEN,
+                    enableSync: true
+                });
+                
+                // Use timeout for initialization
+                const initTimeout = new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error('Memory engine init timeout')), 25000);
+                });
+                
+                await Promise.race([
+                    memoryEngine.initialize(process.cwd()),
+                    initTimeout
+                ]);
+                
+                memoryEngineReady = true;
+                console.error(`${colors.cyan}[Memory]${colors.reset} Engine initialized successfully`);
+                return memoryEngine;
+                
+            } catch (error) {
+                lastError = error;
+                console.error(`${colors.yellow}[Memory]${colors.reset} Initialization attempt ${attempt}/${maxRetries} failed: ${error.message}`);
+                
+                if (attempt < maxRetries) {
+                    // Exponential backoff before retry
+                    const backoffMs = 1000 * Math.pow(2, attempt - 1);
+                    console.error(`${colors.yellow}[Memory]${colors.reset} Retrying in ${backoffMs}ms...`);
+                    await new Promise(resolve => setTimeout(resolve, backoffMs));
+                }
+            }
         }
+        
+        // All retries failed - graceful degradation
+        console.error(`${colors.yellow}[Memory]${colors.reset} All initialization attempts failed. Running in degraded mode.`);
+        console.error(`${colors.yellow}[Memory]${colors.reset} Error: ${lastError?.message || 'Unknown error'}`);
+        console.error(`${colors.yellow}[Memory]${colors.reset} Tools requiring memory will be unavailable.`);
+        memoryEngineReady = false;
+        return null;
     })();
     
     return memoryEngineInitPromise;
@@ -645,6 +744,29 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     required: ["instruction"]
                 }
+            },
+            // PROJECT ANALYSIS TOOL
+            {
+                name: "project_analyze",
+                description: "🔍 Analyze project structure using AI (Mercury). Returns: Project Overview, Technologies, API Endpoints, Main Features. Auto-updates MEMORY.md. Requires MCFAST_TOKEN.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        force: { type: "boolean", description: "Force re-analysis (ignore cache)" },
+                        updateMemory: { type: "boolean", description: "Update MEMORY.md with results (default: true)" }
+                    },
+                    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: []
+                }
             }
         ],
     };
@@ -847,6 +969,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             result = await handleSelectStrategy(args);
             summary = 'Strategy selected';
         }
+        // PROJECT ANALYSIS TOOL
+        else if (name === "project_analyze") {
+            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}`);
         }
@@ -3235,14 +3367,158 @@ 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
  */
+
+// Acquire lock before starting - prevents multiple instances
+const lockAcquired = await acquireLock();
+if (!lockAcquired) {
+  console.error(`${colors.red}[ERROR]${colors.reset} Failed to acquire lock. Another mcfast-mcp instance may be running.`);
+  console.error(`${colors.yellow}[HINT]${colors.reset} Delete ${LOCK_FILE_PATH} if you're sure no other instance is running.`);
+  process.exit(1);
+}
+
 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}`);
+    // Don't exit - continue without memory
+});
+
+// Graceful shutdown handler
+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 {
+    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);