lensmcp 1.16.26 → 1.16.27

package/lib/cli.d.ts

@@ -13,5 +13,21 @@ interface CliContext {
     err?: (line: string) => void;
 }
 export declare function runCli(ctx: CliContext): Promise<CliResult>;
+export type AliveGatewayReality = 'serving' | 'booting' | 'zombie';
+/** Classify what a TRACKED-ALIVE gateway pid really is. ALIVE ≠ SERVING: the tracked pid is the
+ *  `nx run` WRAPPER, and the process that actually binds :443 is its run-executor child. When that
+ *  child crashes while the wrapper wedges (a lost nx-daemon connection), the pid file points at a live
+ *  process that serves NOTHING — the state that made `start` a no-op forever ("already running") while
+ *  the workspace 404'd. So:
+ *  - serving: this workspace's gateway (the wrapper or a descendant) holds :443 — genuinely up.
+ *  - booting: :443 is unbound and the spawn is fresh — the listeners just haven't bound yet.
+ *  - zombie:  past the boot window with nothing of ours on :443, or the port is already held by
+ *             someone else (a boot could never win it) — dead weight to reap. */
+export declare function classifyAliveGateway(o: {
+    oursOn443: boolean;
+    port443Held: boolean;
+    pidFileAgeMs: number | undefined;
+    bootGraceMs?: number;
+}): AliveGatewayReality;
 export {};
 //# sourceMappingURL=cli.d.ts.map

package/lib/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/lib/cli.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,UAAU;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,4EAA4E;IAC5E,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,qDAAqD;IACrD,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,gEAAgE;IAChE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7B,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAqFD,wBAAsB,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CA4ChE"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/lib/cli.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,UAAU;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,4EAA4E;IAC5E,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,qDAAqD;IACrD,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,gEAAgE;IAChE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7B,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAqFD,wBAAsB,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CA4ChE;AA0lBD,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEnE;;;;;;;;iFAQiF;AACjF,wBAAgB,oBAAoB,CAAC,CAAC,EAAE;IACtC,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,mBAAmB,CAItB"}

package/lib/cli.js

@@ -1,5 +1,5 @@
 import { spawn, spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, openSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, openSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { request as httpRequest } from 'node:http';
 import { homedir, tmpdir } from 'node:os';
 import { basename, dirname, join, relative, resolve } from 'node:path';
@@ -267,15 +267,36 @@ function runGateway(ctx, args, out, err) {
     const registeredMarker = join(cwd, '.lensmcp', 'registered.json');
     const dashUrl = `https://lensmcp.local${cfg.dashboardBasePath}/`;
     const start = () => {
-        // Reconcile with reality FIRST: an alive pid-file wins; else adopt an orphaned gateway on :443 (the
-        // desync self-heal) — so a second `start` NEVER spawns a duplicate that EADDRINUSE-crashes + orphans.
+        // Reconcile with reality FIRST: adopt an orphaned gateway on :443 (the desync self-heal) — so a
+        // second `start` NEVER spawns a duplicate that EADDRINUSE-crashes + orphans.
         const { pid: running, healed } = reconcileGateway(pidFile, cwd);
         if (running !== undefined && isAlive(running)) {
-            if (healed)
-                out(`healed: adopted a running gateway (pid ${running}) the pid file had lost — no duplicate started.`);
-            out(`gateway already running (pid ${running}).`);
-            out(`  dashboard → ${dashUrl}`);
-            return { exitCode: 0 };
+            // Bare liveness is NOT enough — classify what the alive pid really is (see classifyAliveGateway:
+            // the `nx run` wrapper can outlive its crashed run-executor child, the actual :443 binder).
+            const reality = classifyAliveGateway({
+                oursOn443: gatewayOnPort443(cwd) !== undefined,
+                port443Held: pidsOnPort443().length > 0,
+                pidFileAgeMs: pidFileAgeMs(pidFile),
+            });
+            if (reality === 'serving') {
+                if (healed)
+                    out(`healed: adopted a running gateway (pid ${running}) the pid file had lost — no duplicate started.`);
+                out(`gateway already running (pid ${running}).`);
+                out(`  dashboard → ${dashUrl}`);
+                return { exitCode: 0 };
+            }
+            if (reality === 'booting') {
+                out(`gateway starting (pid ${running}) — :443 not bound yet.`);
+                out(`  dashboard → ${dashUrl}`);
+                out(`  logs      → ${logFile}`);
+                return { exitCode: 0 };
+            }
+            // A zombie: reap the wrapper tree (it would hold the nx run-lock against a respawn), clear the
+            // stale nx daemon state, and fall through to the real paths (register into a live daemon / spawn).
+            killGatewayTree(running, 'SIGKILL');
+            rmFile(pidFile);
+            refreshNxGraph(cwd, ctx.env, () => { });
+            out(`reaped a dead gateway (pid ${running} was alive but nothing served :443 for this workspace).`);
         }
         // :443 is held by another process. If it's a lens DAEMON (its control socket answers), REGISTER this
         // workspace INTO it — the daemon then hosts this workspace's services + dashboard under the one :443
@@ -283,7 +304,20 @@ function runGateway(ctx, args, out, err) {
         // EADDRINUSE-crash + orphan).
         const foreign = pidsOnPort443()[0];
         if (foreign !== undefined) {
-            if (daemonRequest('GET', '/list') !== null) {
+            const list = daemonRequest('GET', '/list');
+            if (list !== null) {
+                // Idempotent for a GUEST too: an already-registered workspace short-circuits — re-registering
+                // would make the daemon tear down + respawn its services and dashboard for nothing.
+                const registered = list.status === 200 && list.json && typeof list.json === 'object'
+                    ? (list.json.workspaces ?? []).some((w) => w.key === cfg.key)
+                    : false;
+                if (registered) {
+                    mkdirSync(dirname(registeredMarker), { recursive: true });
+                    writeFileSync(registeredMarker, JSON.stringify({ wsKey: cfg.key }));
+                    out(`already registered into the shared gateway daemon (pid ${foreign}).`);
+                    out(`  dashboard → ${dashUrl}`);
+                    return { exitCode: 0 };
+                }
                 const res = daemonRequest('POST', '/register', { wsKey: cfg.key, root: cwd, projects: buildProjectsMap(cwd) });
                 if (res && res.status === 200) {
                     mkdirSync(dirname(registeredMarker), { recursive: true });
@@ -330,8 +364,13 @@ function runGateway(ctx, args, out, err) {
     };
     const stop = () => {
         // If THIS workspace registered into a shared daemon (P4), UNREGISTER from it instead of killing a
-        // gateway it never spawned — the daemon reaps this workspace's services + dashboard.
-        if (existsSync(registeredMarker)) {
+        // gateway it never spawned — the daemon reaps this workspace's services + dashboard. But OWNERSHIP
+        // BEATS THE MARKER: when :443 is held by THIS workspace's OWN gateway, the marker is stale litter
+        // (left over from a guest era before this workspace's daemon took over). Honoring it would
+        // self-unregister and LEAVE THE OWNED DAEMON RUNNING (observed live: tetros owned the :443 daemon,
+        // yet `stop` "unregistered 'tetros'" from itself and the daemon kept serving). Guest path only when
+        // we genuinely do NOT own the port; otherwise clear the lying marker and fall through to the kill.
+        if (existsSync(registeredMarker) && gatewayOnPort443(cwd) === undefined) {
             let wsKey = cfg.key;
             try {
                 wsKey = JSON.parse(readFileSync(registeredMarker, 'utf8')).wsKey ?? cfg.key;
@@ -342,6 +381,7 @@ function runGateway(ctx, args, out, err) {
             out(res && res.status === 200 ? `unregistered '${wsKey}' from the shared gateway daemon.` : 'unregister sent (the daemon may already be gone).');
             return { exitCode: 0 };
         }
+        rmFile(registeredMarker); // a stale marker on the daemon OWNER — clear it before the kill path
         // Reality-based: kill the tracked pid OR an orphaned gateway the pid file lost track of (so `stop`
         // works even after the desync — the case where the old CLI reported "not running" but :443 was held).
         const { pid, healed } = reconcileGateway(pidFile, cwd);
@@ -387,7 +427,16 @@ function runGateway(ctx, args, out, err) {
     };
     const status = () => {
         const { pid, healed } = reconcileGateway(pidFile, cwd);
-        const alive = pid !== undefined && isAlive(pid);
+        // ALIVE ≠ SERVING (see classifyAliveGateway) — a zombie `nx run` wrapper whose executor child died
+        // must not report "running — DAEMON on :443" while the workspace 404s.
+        const reality = pid !== undefined && isAlive(pid)
+            ? classifyAliveGateway({
+                oursOn443: gatewayOnPort443(cwd) !== undefined,
+                port443Held: pidsOnPort443().length > 0,
+                pidFileAgeMs: pidFileAgeMs(pidFile),
+            })
+            : undefined;
+        const alive = reality === 'serving' || reality === 'booting';
         // Machine-readable status for the IDE plugin / scripts: the daemon's rich /status (identity + workspaces
         // + per-service live state) plus THIS workspace's role + the dashboard URL. Degrades to a minimal object
         // when no daemon is reachable, so a consumer always gets valid JSON.
@@ -423,7 +472,9 @@ function runGateway(ctx, args, out, err) {
         };
         if (alive) {
             // This workspace's own pid owns :443 → it IS the daemon (it may be hosting other workspaces too).
-            out(`gateway: running (pid ${pid}) — DAEMON on :443${healed ? ' — recovered a stale pid file' : ''}`);
+            out(reality === 'booting'
+                ? `gateway: starting (pid ${pid}) — :443 not bound yet`
+                : `gateway: running (pid ${pid}) — DAEMON on :443${healed ? ' — recovered a stale pid file' : ''}`);
             out(`  workspace → ${cfg.key}`);
             out(`  dashboard → ${dashUrl}`);
             out(`  chooser   → https://lensmcp.local/`);
@@ -441,6 +492,14 @@ function runGateway(ctx, args, out, err) {
             printWorkspaces();
             return { exitCode: 0 };
         }
+        if (reality === 'zombie') {
+            out(`gateway: NOT serving — tracked pid ${pid} is alive but nothing holds :443 for this workspace`);
+            out('  (a crashed gateway under a wedged nx wrapper) — run `lensmcp gateway restart` to recover.');
+            out(`  workspace → ${cfg.key}`);
+            out(`  logs      → ${logFile}`);
+            printWorkspaces();
+            return { exitCode: 1 };
+        }
         out('gateway: stopped');
         out(`  workspace → ${cfg.key}`);
         out(`  dashboard → ${dashUrl}`);
@@ -596,6 +655,33 @@ function gatewayOnPort443(cwd) {
     }
     return undefined;
 }
+/** How long since `start` wrote the pid file (ms) — the spawn timestamp. undefined when unreadable. */
+function pidFileAgeMs(pidFile) {
+    try {
+        return Date.now() - statSync(pidFile).mtimeMs;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A freshly-spawned gateway legitimately holds NO port yet — services + lens children boot before the
+ *  listeners bind. Give a spawn this long before an alive-but-portless pid is judged a zombie. */
+const BOOT_GRACE_MS = 180_000;
+/** Classify what a TRACKED-ALIVE gateway pid really is. ALIVE ≠ SERVING: the tracked pid is the
+ *  `nx run` WRAPPER, and the process that actually binds :443 is its run-executor child. When that
+ *  child crashes while the wrapper wedges (a lost nx-daemon connection), the pid file points at a live
+ *  process that serves NOTHING — the state that made `start` a no-op forever ("already running") while
+ *  the workspace 404'd. So:
+ *  - serving: this workspace's gateway (the wrapper or a descendant) holds :443 — genuinely up.
+ *  - booting: :443 is unbound and the spawn is fresh — the listeners just haven't bound yet.
+ *  - zombie:  past the boot window with nothing of ours on :443, or the port is already held by
+ *             someone else (a boot could never win it) — dead weight to reap. */
+export function classifyAliveGateway(o) {
+    if (o.oursOn443)
+        return 'serving';
+    const fresh = o.pidFileAgeMs !== undefined && o.pidFileAgeMs < (o.bootGraceMs ?? BOOT_GRACE_MS);
+    return !o.port443Held && fresh ? 'booting' : 'zombie';
+}
 /** Reconcile the tracked pid with reality: a LIVE pid-file wins; otherwise ADOPT an orphaned gateway
  *  still holding :443 (rewriting the pid file) — the self-heal for the stale-pid desync. */
 function reconcileGateway(pidFile, cwd) {
@@ -673,9 +759,10 @@ function firstClusterHost(cwd) {
     return undefined;
 }
 function rmFile(path) {
+    // DELETE, not truncate: an emptied-but-existing registered.json still `existsSync`s, so status/stop
+    // would keep treating an UNREGISTERED workspace as a guest (the lying-marker bug).
     try {
-        if (existsSync(path))
-            writeFileSync(path, '');
+        rmSync(path, { force: true });
     }
     catch {
         /* ignore */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lensmcp",
-  "version": "1.16.26",
+  "version": "1.16.27",
   "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.26",
+  "version": "1.16.27",
   "author": {
     "name": "David Antoon",
     "email": "davidmantoon@gmail.com"