lensmcp 1.16.18 → 1.16.19

package/lib/cli.js

@@ -330,15 +330,37 @@ function runGateway(ctx, args, out, err) {
         }
         if (healed)
             out(`healed: found an orphaned gateway (pid ${pid}) the pid file had lost — stopping it.`);
-        // Detached child is its own process-group leader → negative pid kills the whole tree.
+        // GRACEFUL first: SIGTERM the whole process group (the daemon's handler reaps its children — pods +
+        // lens vites/dashboard/mcp — and exits, so `nx run` deregisters and the next `start` won't hang on the
+        // nx run-lock). Then WAIT for the port to actually free.
         killGatewayTree(pid);
-        rmFile(pidFile);
-        // Escalate: if a lens gateway STILL holds :443 (a differently-parented tree), kill that too, so
-        // `stop` genuinely frees the port instead of leaving a wedged listener behind.
+        let hardKilled = false;
+        if (!waitForPortFree(6000)) {
+            // A child wedged (vite ignores SIGTERM) and is still holding :443. Escalate to a GROUP SIGKILL — that
+            // reaps the wedged vite AND its forks — then SIGKILL any straggler still on the port.
+            hardKilled = true;
+            killGatewayTree(pid, 'SIGKILL');
+            for (const p of pidsOnPort443()) {
+                try {
+                    process.kill(p, 'SIGKILL');
+                }
+                catch { /* already gone */ }
+            }
+            waitForPortFree(3000);
+        }
+        // A differently-parented lens gateway may still hold :443 (a desync tree) — force it too.
         const still = gatewayOnPort443(cwd);
-        if (still !== undefined && still !== pid)
-            killGatewayTree(still);
-        out(`gateway stopped (pid ${pid}).`);
+        if (still !== undefined && still !== pid) {
+            killGatewayTree(still, 'SIGKILL');
+            hardKilled = true;
+        }
+        rmFile(pidFile);
+        // A hard SIGKILL means the `nx run gateway:serve` process died WITHOUT deregistering from the nx daemon,
+        // so the next `start` would block on "Waiting for gateway:serve in another nx process". Clear the stale
+        // nx daemon state (best-effort) so a subsequent start is clean. The graceful path skips this (fast).
+        if (hardKilled)
+            refreshNxGraph(cwd, ctx.env, () => { });
+        out(`gateway stopped (pid ${pid})${hardKilled ? ' — forced (a child ignored SIGTERM)' : ''}.`);
         return { exitCode: 0 };
     };
     const status = () => {
@@ -519,20 +541,37 @@ function reconcileGateway(pidFile, cwd) {
     }
     return { healed: false };
 }
-/** Best-effort kill of a detached gateway process GROUP (the leader is its own group via `detached`). */
-function killGatewayTree(pid) {
+/** Best-effort kill of a detached gateway process GROUP (the leader is its own group via `detached`).
+ *  `signal` defaults to SIGTERM (graceful — the daemon's handler reaps its children + exits, so `nx run`
+ *  deregisters cleanly); a caller escalates to SIGKILL when a wedged child (vite ignores SIGTERM) keeps the
+ *  port held. Killing the GROUP (`-pid`) reaps the daemon + `nx run` + every child + their forks at once. */
+function killGatewayTree(pid, signal = 'SIGTERM') {
     try {
-        process.kill(-pid, 'SIGTERM');
+        process.kill(-pid, signal);
     }
     catch {
         try {
-            process.kill(pid, 'SIGTERM');
+            process.kill(pid, signal);
         }
         catch {
             /* already gone */
         }
     }
 }
+/** Poll (via lsof) until :443 is free or the timeout elapses. Returns true once free. Unix-only; on a
+ *  platform without lsof `pidsOnPort443()` returns [] so this resolves free immediately (unchanged path). */
+function waitForPortFree(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        if (pidsOnPort443().length === 0)
+            return true;
+        if (Date.now() >= deadline)
+            return false;
+        // Busy-wait in ~150ms slices (a stop/restart command, not a hot path) — spawnSync('sleep') keeps it
+        // synchronous so the CLI result reflects the real port state before returning.
+        spawnSync('sleep', ['0.15']);
+    }
+}
 function rmFile(path) {
     try {
         if (existsSync(path))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lensmcp",
-  "version": "1.16.18",
+  "version": "1.16.19",
   "type": "module",
   "main": "./index.js",
   "module": "./index.js",

package/plugin/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "lensmcp",
   "displayName": "LensMCP",
   "description": "The observability lens for coding agents. One command brings up the dev cluster gateway (every project.json `cluster` decl → its host on :443), the per-project lens dashboard at https://lensmcp.local/<project>/, and the MCP server your agent connects to — scoped automatically to whatever project you opened Claude Code in.",
-  "version": "1.16.18",
+  "version": "1.16.19",
   "author": {
     "name": "David Antoon",
     "email": "davidmantoon@gmail.com"