@softtechai/quickmcp 1.1.1 → 1.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softtechai/quickmcp",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "An application to generate MCP servers from various data sources and test them",
   "main": "dist/index.js",
   "bin": {

package/quickmcp-direct-stdio.js

@@ -80,6 +80,16 @@ const wantsWeb = argv.includes('--web') || argv.includes('-w') || argv.includes(
 const noWeb = argv.includes('--no-web');
 const portArg = argv.find(a => a.startsWith('--port='));
 const dataDirArg = argv.find(a => a.startsWith('--data-dir='));
+
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
 // Default behavior: Web UI enabled unless explicitly disabled
 if (noWeb || process.env.QUICKMCP_ENABLE_WEB === '0' || process.env.QUICKMCP_DISABLE_WEB === '1') {
   process.env.QUICKMCP_ENABLE_WEB = '0';
@@ -156,38 +166,69 @@ if (process.env.QUICKMCP_ENABLE_WEB === '1') {
     const preferredPort = parseInt(process.env.PORT || '3000', 10);
     const lockPath = path.join(runDir, `ui-${preferredPort}.lock`);
     let hasLock = false;
-    try {
-      const fd = fs.openSync(lockPath, 'wx');
-      fs.closeSync(fd);
-      hasLock = true;
-      const cleanup = () => { try { fs.unlinkSync(lockPath); } catch {} };
-      process.once('exit', cleanup);
-      process.once('SIGINT', () => { cleanup(); process.exit(0); });
-      process.once('SIGTERM', () => { cleanup(); process.exit(0); });
-    } catch (e) {
-      if (e && e.code !== 'EEXIST') {
-        logger.error('[QuickMCP] UI lock error (continuing without UI):', e.message || e);
+    const cleanup = () => { try { fs.unlinkSync(lockPath); } catch {} };
+    const tryAcquireLock = () => {
+      try {
+        const fd = fs.openSync(lockPath, 'wx');
+        fs.writeFileSync(fd, String(process.pid), 'utf8');
+        fs.closeSync(fd);
+        hasLock = true;
+        process.once('exit', cleanup);
+        process.once('SIGINT', () => { cleanup(); process.exit(0); });
+        process.once('SIGTERM', () => { cleanup(); process.exit(0); });
+      } catch (e) {
+        if (e && e.code === 'EEXIST') {
+          let ownerPid = NaN;
+          try {
+            ownerPid = parseInt(String(fs.readFileSync(lockPath, 'utf8')).trim(), 10);
+          } catch (_) {}
+
+          if (!isProcessAlive(ownerPid)) {
+            // Lock file exists but owner is gone (or lock format is empty/invalid): reclaim it.
+            try {
+              fs.unlinkSync(lockPath);
+              const fd = fs.openSync(lockPath, 'wx');
+              fs.writeFileSync(fd, String(process.pid), 'utf8');
+              fs.closeSync(fd);
+              hasLock = true;
+              process.once('exit', cleanup);
+              process.once('SIGINT', () => { cleanup(); process.exit(0); });
+              process.once('SIGTERM', () => { cleanup(); process.exit(0); });
+              logger.error(`[QuickMCP] Reclaimed stale UI lock: ${lockPath}`);
+              return;
+            } catch (reclaimErr) {
+              logger.error('[QuickMCP] Failed to reclaim stale UI lock (continuing without UI):', reclaimErr && reclaimErr.message ? reclaimErr.message : reclaimErr);
+              return;
+            }
+          }
+
+          logger.error(`[QuickMCP] UI lock held by pid ${ownerPid}; skipping Web UI in this process`);
+          return;
+        }
+
+        logger.error('[QuickMCP] UI lock error (continuing without UI):', e && e.message ? e.message : e);
       }
-      // Another process holds the UI lock; skip starting UI in this process
-    }
+    };
+    tryAcquireLock();
 
     if (!hasLock) {
-      logger.error('[QuickMCP] UI lock held by another process; skipping Web UI in this process');
+      logger.error('[QuickMCP] Web UI not started in this process');
     } else {
       // Only start Web UI if preferred port is actually free.
       const probe = net.createServer();
       probe.once('error', (err) => {
         if (err && (err.code === 'EADDRINUSE' || err.code === 'EACCES')) {
           // Port is busy or not permitted; skip starting Web UI to avoid crashing Claude session
+          logger.error(`[QuickMCP] Web UI port ${preferredPort} unavailable (${err.code}); skipping Web UI`);
           try { fs.unlinkSync(lockPath); } catch {}
           return;
         }
         // For other errors, still try starting server; better to attempt than silently skip for unknown cases
-        safeStartWebServer();
+        safeStartWebServer(preferredPort);
       });
       probe.once('listening', () => {
         probe.close(() => {
-          safeStartWebServer();
+          safeStartWebServer(preferredPort);
         });
       });
       try {
@@ -203,12 +244,13 @@ if (process.env.QUICKMCP_ENABLE_WEB === '1') {
 }
 
 // Start the web server but swallow a race-condition EADDRINUSE from Express listen
-function safeStartWebServer() {
+function safeStartWebServer(port) {
   let handled = false;
   const handler = (err) => {
     if (!handled && err && err.code === 'EADDRINUSE' && err.syscall === 'listen') {
       handled = true;
       // Swallow this once so the STDIO server keeps running; another instance already owns :3000
+      logger.error(`[QuickMCP] Web UI port ${port || process.env.PORT || 3000} became busy during startup; continuing without UI`);
       process.removeListener('uncaughtException', handler);
       return;
     }
@@ -219,7 +261,13 @@ function safeStartWebServer() {
   // Install one-time handler to catch immediate async throw from Express
   process.prependOnceListener('uncaughtException', handler);
   try {
-    require('./dist/server/server.js');
+    logger.error(`[QuickMCP] Starting Web UI at http://localhost:${port || process.env.PORT || 3000}`);
+    const webModule = require('./dist/server/server.js');
+    if (webModule && typeof webModule.startServer === 'function') {
+      webModule.startServer();
+    } else {
+      throw new Error('dist/server/server.js does not export startServer()');
+    }
   } catch (e) {
     // Synchronous load error
     process.removeListener('uncaughtException', handler);