@lensmcp/cluster 1.18.4 → 1.18.7

package/executors/gateway/runtime/lens-children.js

@@ -1,651 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.probePortFree = probePortFree;
-exports.probePortListening = probePortListening;
-exports.waitForPortFree = waitForPortFree;
-exports.viteArgPort = viteArgPort;
-exports.createLensChildren = createLensChildren;
-const tslib_1 = require("tslib");
-/**
- * Lens-mode managed children: the dashboard + MCP SINGLETONS (cluster-wide,
- * owned by the gateway), and each `lens:true` app's Vite + browser capture.
- * EVERY managed child AUTO-HEALS — restarted with exponential backoff when it
- * exits while the gateway is up — and a dead child NEVER kills the cluster.
- */
-const net = tslib_1.__importStar(require("node:net"));
-const path = tslib_1.__importStar(require("node:path"));
-const node_child_process_1 = require("node:child_process");
-const lens_frontend_1 = require("@lensmcp/nx-plugin/lens-frontend");
-const pod_env_1 = require("./pod-env");
-const scope_1 = require("./scope");
-const workspace_registry_1 = require("./workspace-registry");
-const lifecycle_1 = require("./lifecycle");
-const types_1 = require("./types");
-const observability_1 = require("./observability");
-const HEAL_BASE_MS = 1_500; // first restart delay
-const HEAL_MAX_MS = 30_000; // backoff cap — a true boot-loop settles here, never hot-loops
-const HEAL_HEALTHY_MS = 20_000; // ran at least this long ⇒ a FRESH crash ⇒ reset the backoff budget
-/** True when `port` can actually be BOUND on this machine right now. The in-process `used*Ports` sets only
- *  know what THIS daemon claimed — an ORPHANED child of a CRASHED daemon (or any foreign process) still
- *  holds its port at the OS level. Routing to such a port serves the WRONG workspace's content: the child
- *  we spawn crash-loops on EADDRINUSE while the route proxies into the stale squatter (the "tetros
- *  dashboard redirects to foodguard" bug). */
-/** One bind attempt. `in-use` only for the errnos that actually mean "someone has it"; any other failure
- *  means that ADDRESS FAMILY is unavailable on this machine (no IPv6, for instance), which is not evidence
- *  either way and must never be reported as "taken" — that would make `claimFreePort` step up forever. */
-function tryBind(port, host) {
-    return new Promise((resolve) => {
-        const probe = net.createServer();
-        probe.unref();
-        probe.once('error', (e) => {
-            const code = e.code ?? '';
-            resolve(code === 'EADDRINUSE' || code === 'EACCES' ? 'in-use' : 'unavailable');
-        });
-        probe.listen(host === undefined ? { port } : { port, host }, () => probe.close(() => resolve('free')));
-    });
-}
-async function probePortFree(port) {
-    // The WILDCARD bind alone is NOT enough, and that hole defeated the very purpose of this probe. MEASURED:
-    // with a holder on `127.0.0.1:P`, `listen({ port: P })` (the wildcard) reports **FREE** — a wildcard bind
-    // does not collide with a specific-address bind on macOS/BSD. Our children bind the NAME `localhost`
-    // (vite `--port N --strictPort`, the dashboard bundles), i.e. a LOOPBACK address — exactly the case the
-    // wildcard probe cannot see. So an orphaned vite holding `127.0.0.1:4200` looked free, `claimFreePort`
-    // handed 4200 straight back out, and the fresh child died on `listen EADDRINUSE` — the self-inflicted
-    // crash this probe exists to prevent (and what makes `waitForPortFree` meaningful rather than a no-op).
-    // Free means bindable on the wildcard AND on both loopback addresses; unavailable families are skipped.
-    for (const host of [undefined, '127.0.0.1', '::1']) {
-        if ((await tryBind(port, host)) === 'in-use')
-            return false;
-    }
-    return true;
-}
-/** A single-address TCP connect: does `host:port` ACCEPT right now? Connect-and-destroy, never an HTTP
- *  request — a WEDGED vite may accept then hang forever, so a `GET` would time out even where the listener
- *  is fine (and would pollute the dev server's log). Every timer/socket is unref'd: a probe must never hold
- *  the gateway process open. */
-function probeConnect(host, port, timeoutMs) {
-    return new Promise((resolve) => {
-        let done = false;
-        const sock = net.createConnection({ host, port });
-        sock.unref();
-        const timer = setTimeout(() => finish(false), timeoutMs);
-        timer.unref?.();
-        function finish(ok) {
-            if (done)
-                return;
-            done = true;
-            clearTimeout(timer);
-            sock.destroy();
-            resolve(ok);
-        }
-        sock.once('connect', () => finish(true));
-        sock.once('error', () => finish(false));
-    });
-}
-/** True when something is LISTENING on `port` on loopback — the liveness signal the exit handler cannot
- *  give us ({@link LENS_PROBE_ENABLED}: a vite alive with zero LISTEN sockets).
- *
- *  BOTH loopback families are tried before reporting a failure. Vite binds the NAME `localhost`, which can
- *  resolve to `::1` on a v6-preferring host — probing only `127.0.0.1` there would report every healthy dev
- *  server as wedged and SIGKILL the whole cluster in a loop. The v6 attempt only runs on the v4 failure
- *  path, so the healthy case stays one connect. */
-async function probePortListening(port, timeoutMs = 1_000) {
-    if (await probeConnect('127.0.0.1', port, timeoutMs))
-        return true;
-    return probeConnect('::1', port, timeoutMs);
-}
-/** Unref'd sleep — a heal/backoff wait must never keep the gateway alive past `stop()`. */
-const sleepUnref = (ms) => new Promise((r) => { const t = setTimeout(r, ms); t.unref?.(); });
-/**
- * Poll until `port` is actually BINDABLE, up to `timeoutMs`. Resolves `true` when it frees, `false` on
- * timeout (the caller then spawns anyway and lets the normal heal handle the fallout).
- *
- * WHY a respawn must await this: a dying vite can hold its listener for seconds (open HMR websockets keep
- * the server closing), so the fixed 1.5s heal delay raced it and the fresh child died on
- * `listen EADDRINUSE` — a self-inflicted crash that burned a heal attempt and lengthened the outage
- * (see {@link PORT_FREE_WAIT_MS}). Probes at least ONCE even with `timeoutMs: 0`, so the common already-free
- * case costs a single probe and no delay.
- */
-async function waitForPortFree(port, timeoutMs, deps = {}) {
-    const isFree = deps.isPortFree ?? probePortFree;
-    const intervalMs = Math.max(1, deps.intervalMs ?? types_1.PORT_FREE_POLL_MS);
-    const deadline = Date.now() + Math.max(0, timeoutMs);
-    for (;;) {
-        if (await isFree(port))
-            return true;
-        const left = deadline - Date.now();
-        if (left <= 0)
-            return false;
-        await sleepUnref(Math.min(intervalMs, left));
-    }
-}
-/** The `--port <n>` / `--port=<n>` a vite child was launched with. `spawnLensFrontend` always PINS the port
- *  for a gateway-routed app (`--port <n> --strictPort`), so argv is the authoritative record of which port
- *  this child owns — the port the liveness probe checks and the port its respawn must wait to be free.
- *  `undefined` for an unpinned child (nothing to probe, nothing to wait for). */
-function viteArgPort(args) {
-    const valid = (n) => (Number.isInteger(n) && n > 0 && n < 65_536 ? n : undefined);
-    for (let i = 0; i < args.length; i += 1) {
-        const a = args[i];
-        if (a === '--port')
-            return valid(Number(args[i + 1]));
-        if (a.startsWith('--port='))
-            return valid(Number(a.slice('--port='.length)));
-    }
-    return undefined;
-}
-function createLensChildren(rt, obs, options, 
-// Injectable OS-level port probe (unit tests stub it; real ports are machine-dependent).
-deps) {
-    const { emit } = obs;
-    const isPortFree = deps?.isPortFree ?? probePortFree;
-    const lensChildren = [];
-    // Auto-heal bookkeeping per child label: consecutive restart attempts (drives the exponential
-    // backoff) so a boot-loop settles instead of hammering, reset once a child has run healthily.
-    // `portConflicts` counts CONSECUTIVE lost bind races (EADDRINUSE) — forgiven rather than charged to
-    // `attempts`, but capped so a permanently-squatted port still falls back to backoff.
-    const lensHeal = new Map();
-    const viteChildren = new Map();
-    // Per-project last-recycle time — the cooldown survives the kill→auto-heal→respawn (a new child handle).
-    const viteRecycleAt = new Map();
-    let lensSweeper;
-    // Per-workspace dashboard hosting (P3d): the current child by label, labels we've intentionally removed
-    // (so auto-heal does NOT respawn them on the reap kill), and the dashboard ports already in use (so two
-    // workspaces' dashboards get distinct ports).
-    const labeledChildren = new Map();
-    const removedLabels = new Set();
-    const usedDashboardPorts = new Set();
-    // Lens-app vite ports already claimed (the daemon's own apps + every registered workspace's), so a
-    // registered workspace whose app declares a port already in use gets offset (vite's --strictPort would
-    // otherwise exit-loop). Keyed by the actual bound port.
-    const usedAppPorts = new Set();
-    // The FIRST port at/above `desired` that is neither claimed in-process nor held at the OS level (an
-    // orphaned child of a crashed daemon squats its old port — see probePortFree). Claims it in `claimed`.
-    const claimFreePort = async (desired, claimed) => {
-        let port = desired;
-        while (claimed.has(port) || !(await isPortFree(port)))
-            port += 1;
-        claimed.add(port);
-        if (port !== desired) {
-            console.warn(`[gateway] port ${desired} is unavailable (another process holds it — an orphan from a crashed gateway?) — using ${port} instead.`);
-        }
-        return port;
-    };
-    // A `SpawnChild` over the gateway's managed-children array — the SAME shape `agent-dev` passes to
-    // `spawnLensFrontend`. EVERY gateway-managed child AUTO-HEALS: the dashboard + MCP singletons AND each
-    // `lens:true` vite app are restarted when they exit while the gateway is up, with exponential backoff.
-    // So a transient crash (a dev-server wedge, an OOM) recovers on its own — the user never hand-restarts —
-    // and a child that crashes-on-boot backs off to HEAL_MAX_MS rather than spinning. A child that ran
-    // healthily (≥ HEAL_HEALTHY_MS) gets a fresh budget, so one that dies after an hour comes back fast. A
-    // dead child still NEVER kills the cluster — it simply respawns in the background.
-    const spawnManagedChild = (label, bin, args, env, optional = false, respawn, 
-    // Per-child working dir. The daemon's OWN children run in `rt.root`; a REGISTERED workspace's vite must
-    // run in ITS root (so vite loads the right .env / resolves its own context). Threaded through auto-heal.
-    cwd) => {
-        void optional;
-        void respawn; // legacy knobs — auto-heal is now universal (signature kept for compat)
-        const spawnedAt = Date.now();
-        // LENSMCP_PARENT_PID: our own bundles (dashboard/MCP) run a ppid watchdog against it and SELF-EXIT when
-        // this gateway dies ungracefully (crash/SIGKILL — reapAll never ran), so they don't orphan and squat
-        // their ports for the next gateway to route into.
-        const child = (0, node_child_process_1.spawn)(bin, args, {
-            cwd: cwd ?? rt.root,
-            // FOREIGN-POD ENV SCRUB (pod-env.ts): a registered workspace's vite/child runs in ITS root and must
-            // not inherit the daemon host's dotenv-loaded env (vite, like nx, keeps an already-set var over the
-            // workspace's own .env) — the caller's explicit `env` overlay still applies on top.
-            env: { ...(0, pod_env_1.podBaseEnv)(process.env, rt.root, cwd ?? rt.root), ...(env ?? {}), LENSMCP_PARENT_PID: String(process.pid) },
-            stdio: 'inherit',
-        });
-        lensChildren.push(child);
-        labeledChildren.set(label, child); // the CURRENT handle for this label (a per-workspace dashboard reap targets it)
-        // Track a `lens:true` app's vite dev server (label 'vite', or `<ws>:<proj>:vite` for a registered
-        // workspace) for the zombie recycle + the liveness probe. Its `LENSMCP_PROJECT` names the app and its
-        // argv pins the port; a fresh respawn re-adds here with a clean probe run.
-        const isVite = label === 'vite' || label.endsWith(':vite');
-        // The port THIS child owns (pinned `--port <n> --strictPort`): what the liveness probe checks and what
-        // the respawn must wait to be free. `undefined` for the dashboard/MCP singletons + an unpinned vite.
-        const ownPort = isVite ? viteArgPort(args) : undefined;
-        if (isVite) {
-            // `spawnLensFrontend` always stamps the OWNING workspace's bus into the child env, so this is
-            // the authoritative "whose app is this" — a registered workspace's lifecycle events go to its
-            // own `.lensmcp/events.jsonl`, exactly as the service layer's `emitSvc` routes pod events.
-            const childBus = typeof env?.['LENSMCP_EVENT_FILE'] === 'string' ? env['LENSMCP_EVENT_FILE'] : undefined;
-            viteChildren.set(child, {
-                project: env?.['LENSMCP_PROJECT'] ?? 'app',
-                spawnedAt,
-                port: ownPort,
-                probeFails: 0,
-                listening: false,
-                ...(childBus && childBus !== rt.eventFile ? { bus: childBus } : {}),
-            });
-        }
-        child.on('exit', (code, sig) => {
-            const idx = lensChildren.indexOf(child);
-            if (idx >= 0)
-                lensChildren.splice(idx, 1); // drop the dead handle so stop() won't signal it
-            viteChildren.delete(child); // the auto-heal respawn re-registers a fresh handle with a new spawnedAt
-            if (rt.stopped() || removedLabels.has(label))
-                return; // shutting down, or this workspace unregistered — do NOT resurrect
-            const ranMs = Date.now() - spawnedAt;
-            const heal = lensHeal.get(label) ?? { attempts: 0, portConflicts: 0 };
-            // The heal is ASYNC from here: classifying a bind race and waiting for the port both need a probe.
-            // Every wait is unref'd and every resume re-checks stopped()/removedLabels, so shutdown still wins.
-            void (async () => {
-                // BIND RACE vs CRASH. A fast non-zero exit while ANOTHER process still holds our pinned port is
-                // vite's `--strictPort` losing an EADDRINUSE race with the child it replaced — an environment
-                // condition, not a code fault. Charging it to `attempts` is what pushed the observed heal to
-                // "attempt 2" and doubled the outage; forgive it (bounded) and wait the port out instead.
-                const portHeld = ownPort !== undefined && !(await isPortFree(ownPort));
-                const raceLost = (0, lifecycle_1.isPortConflictExit)({ code, signal: sig, ranMs, portHeld }, { fastFailMs: types_1.CHILD_START_FAIL_MS });
-                if (raceLost && heal.portConflicts < types_1.MAX_PORT_CONFLICT_RETRIES) {
-                    heal.portConflicts += 1; // `attempts` UNTOUCHED — the crash-loop budget is for real crashes
-                    lensHeal.set(label, heal);
-                    console.warn(`[gateway] lens child ${label} lost the :${ownPort} bind race (EADDRINUSE, code=${code}); waiting for the port, then retrying (port-retry ${heal.portConflicts}/${types_1.MAX_PORT_CONFLICT_RETRIES}; crash budget untouched).`);
-                }
-                else {
-                    heal.portConflicts = 0; // a real exit ends the bind-race run
-                    if (ranMs >= HEAL_HEALTHY_MS)
-                        heal.attempts = 0; // it was healthy → fresh budget
-                    const delay = Math.min(HEAL_MAX_MS, HEAL_BASE_MS * 2 ** heal.attempts);
-                    heal.attempts += 1;
-                    lensHeal.set(label, heal);
-                    console.warn(`[gateway] lens child ${label} exited (code=${code} sig=${sig}); auto-healing in ${Math.round(delay / 1000)}s (attempt ${heal.attempts}).`);
-                    await sleepUnref(delay);
-                }
-                if (rt.stopped() || removedLabels.has(label))
-                    return;
-                // NEVER respawn into the dying child's port. A closing vite can hold its listener for seconds (open
-                // HMR websockets), so the old fixed delay raced it → `listen EADDRINUSE` → a self-inflicted crash
-                // that burned a heal attempt and LENGTHENED the 502. Bounded: past the budget we spawn anyway and
-                // let the (now correctly-classified) heal take it from there.
-                if (ownPort !== undefined && !(await waitForPortFree(ownPort, types_1.PORT_FREE_WAIT_MS, { isPortFree, intervalMs: types_1.PORT_FREE_POLL_MS }))) {
-                    console.warn(`[gateway] lens child ${label}: :${ownPort} still held after ${Math.round(types_1.PORT_FREE_WAIT_MS / 1000)}s — spawning anyway.`);
-                }
-                if (rt.stopped() || removedLabels.has(label))
-                    return;
-                spawnManagedChild(label, bin, args, env, optional, respawn, cwd);
-            })().catch(() => undefined); // a heal must never surface as an unhandled rejection
-        });
-        return child;
-    };
-    // LIVENESS probe for lens frontends: kill a vite that is ALIVE but NOT LISTENING (the permanent-502 wedge
-    // — see LENS_PROBE_ENABLED). One cheap TCP connect per tracked child per tick; the pure `lensChildWedged`
-    // owns the verdict (grace + N consecutive failures + the shared per-project cooldown), this owns the I/O.
-    // A confirmed wedge gets SIGKILL — deliberately NOT SIGTERM: graceful shutdown is exactly what wedged (the
-    // event loop is pinned by the lens WS server / bridge sockets), so a SIGTERM can hang and leave the app
-    // 502ing forever. The kill lands on the proven exit→auto-heal path, which respawns after waiting the port
-    // out. `probeInFlight` keeps a slow round from overlapping the next tick.
-    let probeInFlight = false;
-    const probeLensChildren = async (cfg, killWedged) => {
-        if (probeInFlight)
-            return;
-        probeInFlight = true;
-        try {
-            for (const [child, meta] of [...viteChildren]) {
-                if (rt.stopped())
-                    return;
-                if (meta.port === undefined)
-                    continue; // unpinned port ⇒ nothing to probe
-                if (child.exitCode !== null || child.signalCode !== null)
-                    continue; // already dying — the exit heal owns it
-                // The probe now runs DURING the spawn grace too. It costs one extra TCP connect per child
-                // for the first `graceMs`, and it buys the RECOVERY edge below at first-listen instead of
-                // 45s later — the grace exists to withhold the KILL verdict from a booting vite, not to
-                // withhold the observation that it came up.
-                if (await probePortListening(meta.port, types_1.LENS_PROBE_TIMEOUT_MS)) {
-                    meta.probeFails = 0;
-                    // RECOVERY EDGE. A wedged/zombie-recycled vite is SIGKILLed and auto-healed by the exit
-                    // handler, which announces nothing — so `pod-recycle` (→ `wedged` in the lens fold) had no
-                    // counterpart and a lens app stayed "wedged" for the rest of the session while serving
-                    // every request (foodguard 2026-07-31: `wedged: ["authentication","dashboard"]`, `up: []`,
-                    // zero 502s). An accepting listener is the same evidence the wedge verdict is the absence
-                    // of, so it is what clears it. Once per generation: a fresh child starts `listening: false`.
-                    if (!meta.listening) {
-                        meta.listening = true;
-                        emit('info', `lens app up: ${meta.project} (vite :${meta.port} listening)`, `cluster-lens-app:${meta.project}`, { kind: 'service-up', project: meta.project, port: meta.port }, undefined, meta.bus);
-                    }
-                    continue;
-                }
-                if (Date.now() - meta.spawnedAt < cfg.graceMs) {
-                    meta.probeFails = 0;
-                    continue;
-                } // still booting
-                if (!killWedged)
-                    continue; // liveness still OBSERVED above; only the kill verdict is switched off
-                meta.probeFails += 1;
-                const reason = (0, lifecycle_1.lensChildWedged)(meta, viteRecycleAt.get(meta.project) ?? 0, Date.now(), cfg);
-                if (!reason)
-                    continue; // failing, but not yet N-in-a-row / still in cooldown
-                viteRecycleAt.set(meta.project, Date.now());
-                meta.probeFails = 0;
-                meta.listening = false; // re-arm the recovery edge, in case the SIGKILL below doesn't take
-                console.error(`[gateway] wedge recycle: lens app ${meta.project} is ALIVE but NOT LISTENING on :${meta.port} after ${Math.max(2, cfg.failureThreshold)} probes — SIGKILL; a fresh vite is coming.`);
-                emit('warning', `wedge recycle: ${meta.project} (${reason})`, `cluster-lens-app:${meta.project}`, { kind: 'pod-recycle', project: meta.project, reason, port: meta.port }, undefined, meta.bus);
-                try {
-                    child.kill('SIGKILL');
-                }
-                catch { /* already gone — the exit auto-heal will respawn */ }
-            }
-        }
-        finally {
-            probeInFlight = false;
-        }
-    };
-    // The lens-frontend sweeper drives BOTH self-heals over the tracked vite children:
-    //  1. the LIVENESS probe above — alive but not listening (a permanent 502, invisible to the exit handler);
-    //  2. ZOMBIE recycle — a vite whose fs-watcher went stale: ALIVE + reachable yet MISSING files created
-    //     after it spawned (500 `Failed to resolve import` for a file that exists; the reported 17.7h
-    //     dashboard pod). The shared `rt.sourceSetChangedAt` (stamped by the lifecycle sweeper's source-set
-    //     scan) drives it: a vite that spawned before a settled set change is killed → this manager's own
-    //     `on('exit')` auto-heal respawns a fresh vite that re-scans the FS. Only on a set CHANGE
-    //     (add/remove), never a content save, and never a blind max-age (no idle signal for a frontend).
-    const startLensSweeper = () => {
-        // Either heal alone justifies the sweeper: a user who disabled the staleness recycle (its churn was a
-        // known problem) must still get a wedged 502 healed, so each branch is gated on its OWN switch.
-        if (lensSweeper || (!types_1.POD_RECYCLE_ENABLED && !types_1.LENS_PROBE_ENABLED))
-            return;
-        const cfg = { graceMs: types_1.POD_STALE_GRACE_MS, settleMs: types_1.POD_RECYCLE_SETTLE_MS, cooldownMs: types_1.POD_STALE_RECYCLE_COOLDOWN_MS };
-        lensSweeper = setInterval(() => {
-            if (rt.stopped() || viteChildren.size === 0)
-                return;
-            // The liveness probe is INDEPENDENT of the source-set clock — a wedge has nothing to do with the file
-            // set, so it must run before (and regardless of) the staleness early-return below. It runs whenever
-            // the sweeper does: `LENS_PROBE_ENABLED` gates the KILL verdict, NOT the observation, because the
-            // probe is also the only RECOVERY signal a lens frontend has — with the staleness recycle on and the
-            // probe off, a zombie-recycled app would otherwise stay `wedged` in the fold forever.
-            void probeLensFrontends();
-            if (!types_1.POD_RECYCLE_ENABLED)
-                return;
-            const wideChangedAt = rt.sourceSetChangedAt ?? 0;
-            if (wideChangedAt <= 0)
-                return;
-            const now = Date.now();
-            for (const [child, meta] of viteChildren) {
-                // Prefer this app's SCOPED clock — the file set within the subtrees ITS vite can resolve. On the wide
-                // clock a backend-only `.ts` add anywhere in the monorepo restarted every frontend (`sourceScopeDirs`).
-                const changedAt = rt.sourceSetChangedFor?.get(meta.project) ?? wideChangedAt;
-                const last = viteRecycleAt.get(meta.project) ?? 0;
-                if (!(0, lifecycle_1.lensFrontendStale)(meta.spawnedAt, last, changedAt, now, cfg))
-                    continue;
-                viteRecycleAt.set(meta.project, now);
-                meta.listening = false; // re-arm the recovery edge — the respawned vite must announce itself
-                console.log(`[gateway] zombie recycle: lens app ${meta.project} (stale-source-set) — vite missed a file add; restarting it`);
-                emit('warning', `zombie recycle: ${meta.project} (stale-source-set)`, `cluster-lens-app:${meta.project}`, { kind: 'pod-recycle', project: meta.project, reason: 'stale-source-set' }, undefined, meta.bus);
-                try {
-                    child.kill('SIGTERM');
-                }
-                catch { /* already gone — the exit auto-heal will respawn */ }
-            }
-        }, Math.min(types_1.POD_STALE_SCAN_MS, 15_000));
-        lensSweeper.unref?.();
-    };
-    const bootSingletonsAndApps = async () => {
-        const lensApps = [...new Map(rt.routes.filter((r) => r.lens).map((r) => [r.project, r.lens])).values()];
-        const wantDashboard = options.dashboard !== false;
-        const wantMcp = options.mcp !== false && lensApps.length > 0;
-        if (wantDashboard) {
-            const dashboardBundle = (0, lens_frontend_1.findDashboardBundle)(rt.root);
-            if (!dashboardBundle) {
-                console.warn("[gateway] lens dashboard bundle not found — skipping. Install the self-contained CLI: `npm i -D lensmcp` (it ships `bundled/dashboard.js`), or `yarn nx build @lensmcp/lensmcp-mcp` in-repo.");
-            }
-            else {
-                // Per-project lens scope: the dashboard is mounted at lensmcp.local/<key>/ so
-                // MANY projects coexist (each at its own /<key> on its own port). The dashboard
-                // OWNS its base path (LENSMCP_DASHBOARD_BASE) and history-routes under it, so the
-                // gateway routes pass-through (matchRoute on the prefix; the proxy never strips).
-                const scope = (0, scope_1.readLensScope)(rt.root);
-                // The per-workspace scoped port (`.lensmcp/config.json` ports.dashboard) unless explicitly
-                // overridden — then OS-probed: an orphaned dashboard from a crashed gateway may still hold it, and
-                // routing there serves ANOTHER workspace's dashboard. Claiming also reserves it in-process so a
-                // registered workspace's dashboard differs.
-                const dashboardPort = await claimFreePort(options.dashboardPort ?? scope.dashboardPort, usedDashboardPorts);
-                const lensHost = options.lensHost ?? 'lensmcp.local';
-                const lensBase = scope.basePath; // e.g. /tetros
-                // Pushed BEFORE the cert SANs are derived (routes.map(r=>r.host)), so lensmcp.local
-                // auto-joins the TLS SANs. Run `gateway:trust` to add it to /etc/hosts.
-                // Add this workspace's dashboard route to ITS fragment (not straight to rt.routes) so it survives a
-                // registry rebuild when another workspace registers/unregisters, then rebuild the live merged table.
-                rt.registry.appendRoutes(rt.wsKey, [{ host: lensHost, prefix: lensBase, project: observability_1.LENS_DASHBOARD_PROJECT, target: `http://localhost:${dashboardPort}` }]);
-                rt.rebuildRoutes();
-                // Publish this workspace to the GLOBAL registry so the root chooser at `${lensHost}/` lists it
-                // (and marks it live while this gateway runs). Best-effort — a registry write never blocks serving.
-                (0, workspace_registry_1.registerWorkspace)({ key: scope.key, root: rt.root, base: lensBase, pid: process.pid, procStamp: (0, workspace_registry_1.processStamp)(process.pid), updatedAt: new Date().toISOString() });
-                console.log(`[gateway] starting lens dashboard → http://localhost:${dashboardPort} (routed at https://${lensHost}${lensBase}/)`);
-                emit('info', `lens dashboard up: ${lensHost}${lensBase} → :${dashboardPort}`, 'cluster-lens-dashboard', { kind: 'lens-dashboard-up', host: lensHost, port: dashboardPort, base: lensBase });
-                spawnManagedChild('lens-dashboard', process.execPath, [dashboardBundle], {
-                    LENSMCP_EVENT_FILE: rt.eventFile,
-                    LENSMCP_DASHBOARD_PORT: String(dashboardPort),
-                    LENSMCP_DASHBOARD_BASE: lensBase,
-                });
-            }
-        }
-        if (wantMcp) {
-            const mcpBundle = (0, lens_frontend_1.findMcpBundle)(rt.root);
-            if (!mcpBundle) {
-                console.warn("[gateway] MCP server bundle not found — skipping (lens apps will still publish to the bus; an external `lensmcp mcp` can read it). Install: `npm i -D lensmcp`.");
-            }
-            else {
-                // The workspace's OWN port, not a shared default. This used to be a
-                // hardcoded 3000 for EVERY workspace: with two gateways (or one daemon
-                // hosting two workspaces) whichever bound first served the other's
-                // sessions too — one project's agent reading another project's events.
-                // The port is also the contract the MCP shim resolves from
-                // `.lensmcp/config.json`, so it must not be stepped up on collision:
-                // a shim pointed at 4543 cannot find a server that quietly moved to 4544.
-                const scope = (0, scope_1.readLensScope)(rt.root);
-                const mcpPort = Number(process.env['LENSMCP_PORT'] ?? scope.mcpHttpPort);
-                console.log(`[gateway] starting lens MCP server on 127.0.0.1:${mcpPort} (${mcpBundle})`);
-                spawnManagedChild('lens-mcp', process.execPath, [mcpBundle], {
-                    LENSMCP_EVENT_FILE: rt.eventFile,
-                    LENSMCP_TRANSPORT: process.env['LENSMCP_TRANSPORT'] ?? 'http',
-                    LENSMCP_PORT: String(mcpPort),
-                    // Which workspace this server serves — it publishes this on its identity
-                    // route so a shim can REFUSE it when two workspaces derive one port
-                    // (rather than silently reading the other project's events). Passed
-                    // explicitly because the child's cwd is ambient and inheritable, while
-                    // this is the workspace the gateway actually resolved the port from.
-                    LENSMCP_WORKSPACE_KEY: scope.key,
-                    LENSMCP_WORKSPACE_ROOT: rt.root,
-                });
-            }
-        }
-        // Spawn each `lens:true` frontend's Vite + browser capture as the upstream,
-        // via the SAME shared helper `agent-dev` uses (singletons excluded — owned above).
-        for (const app of lensApps) {
-            if (app.started)
-                continue;
-            app.started = true;
-            // Claim the app's port OS-probed (an orphaned vite from a crashed daemon may hold it — vite's
-            // --strictPort would exit-loop while the route proxies into the stale one). On a step-up, point every
-            // route of this project at the ACTUAL port (route objects are shared with the registry fragment, so
-            // the rewrite survives rebuilds — mirrors hostWorkspaceApps).
-            const appPort = await claimFreePort(app.port, usedAppPorts);
-            if (appPort !== app.port) {
-                for (const r of rt.routes) {
-                    if (r.lens?.project === app.project) {
-                        r.lens.port = appPort;
-                        r.target = `http://localhost:${appPort}`;
-                    }
-                }
-                app.port = appPort;
-            }
-            try {
-                (0, lens_frontend_1.spawnLensFrontend)({
-                    projectRoot: app.projectRoot,
-                    workspaceRoot: rt.root,
-                    project: app.project,
-                    eventFile: rt.eventFile,
-                    port: app.port,
-                    chrome: true,
-                    headless: true,
-                    // Identify this app's events on the shared bus (mirrors the serve
-                    // executor's LENSMCP_PROJECT stamp for pods).
-                    viteEnv: { LENSMCP_PROJECT: app.project },
-                    log: (l) => console.log(l),
-                }, spawnManagedChild);
-                emit('info', `lens app started: ${app.project} (vite :${app.port})`, `cluster-lens-app:${app.project}`, { kind: 'lens-app-up', project: app.project, port: app.port });
-            }
-            catch (e) {
-                console.error(`[gateway] lens app ${app.project}: ${e.message}`);
-            }
-        }
-        startLensSweeper(); // watch the just-spawned lens vites for a stale-source-set zombie
-    };
-    // P3d — host a REGISTERED workspace's dashboard: its OWN events file, a distinct port, and a
-    // `lensmcp.local/<key>` route on its fragment. The dashboard BUNDLE is the daemon's (rt.root); only the
-    // events file + base + port are the registered workspace's. Returns a reaper the control endpoint calls
-    // on unregister (marks the label removed so auto-heal won't respawn it, then kills the child).
-    const hostWorkspaceDashboard = async (fragment) => {
-        const bundle = (0, lens_frontend_1.findDashboardBundle)(rt.root);
-        if (!bundle)
-            return undefined;
-        const scope = (0, scope_1.readLensScope)(fragment.root);
-        const lensHost = options.lensHost ?? 'lensmcp.local';
-        const lensBase = scope.basePath; // /<registered key>
-        // Distinct from every other workspace's dashboard AND actually bindable (OS-probed for orphans).
-        const port = await claimFreePort(scope.dashboardPort, usedDashboardPorts);
-        const label = `lens-dashboard:${fragment.wsKey}`;
-        const eventFile = path.join(fragment.root, '.lensmcp', 'events.jsonl'); // the registered workspace's OWN bus
-        removedLabels.delete(label); // a fresh registration after a prior unregister → allow auto-heal again
-        rt.registry.appendRoutes(fragment.wsKey, [{ host: lensHost, prefix: lensBase, project: observability_1.LENS_DASHBOARD_PROJECT, target: `http://localhost:${port}` }]);
-        // Publish the hosted workspace to the GLOBAL chooser registry (keyed on the DAEMON's pid — the daemon is
-        // what keeps it live), so `lensmcp.local/` lists it. Reaped on unregister below.
-        (0, workspace_registry_1.registerWorkspace)({ key: fragment.wsKey, root: fragment.root, base: lensBase, pid: process.pid, procStamp: (0, workspace_registry_1.processStamp)(process.pid), updatedAt: new Date().toISOString() });
-        console.log(`[gateway] hosting dashboard for workspace '${fragment.wsKey}' → http://localhost:${port} (routed at https://${lensHost}${lensBase}/)`);
-        emit('info', `lens dashboard up: ${lensHost}${lensBase} → :${port}`, 'cluster-lens-dashboard', { kind: 'lens-dashboard-up', host: lensHost, port, base: lensBase });
-        spawnManagedChild(label, process.execPath, [bundle], {
-            LENSMCP_EVENT_FILE: eventFile,
-            LENSMCP_DASHBOARD_PORT: String(port),
-            LENSMCP_DASHBOARD_BASE: lensBase,
-            LENSMCP_WS_KEY: fragment.wsKey,
-        }, false, undefined, 
-        // The guest dashboard's Cluster view derives its service DECLS + service-keys from `process.cwd()`
-        // (dashboard bundle: `const root = process.cwd()`), so the child MUST run in the REGISTERED
-        // workspace's root — NOT the default `rt.root` (the daemon owner's). Without this a hosted workspace's
-        // dashboard renders the DAEMON's `project.json` services (the "foodguard page shows tetros" bug); the
-        // sibling `hostWorkspaceApps` already threads `fragment.root` this way.
-        fragment.root);
-        return () => {
-            removedLabels.add(label); // stop auto-heal from resurrecting it
-            usedDashboardPorts.delete(port);
-            (0, workspace_registry_1.unregisterWorkspace)(fragment.wsKey); // drop it from the chooser registry
-            try {
-                labeledChildren.get(label)?.kill('SIGTERM');
-            }
-            catch { /* already gone */ }
-            labeledChildren.delete(label);
-        };
-    };
-    // P3d — host a REGISTERED workspace's `lens:true` FRONTEND apps (the model-A completeness gap: the daemon
-    // spawned a registered workspace's pods on-demand + its dashboard, but NOT its lens frontends, so a route
-    // like app.<key>.local pointed at a port nothing bound → 502). For each lens app: spawn its vite (+ browser
-    // capture) in the registered workspace's OWN root + event bus, on a COLLISION-SAFE port (offset off the
-    // daemon's own + other workspaces', since vite's --strictPort exits on a clash), and update the route
-    // TARGET to that port so the merged table (rebuilt right after this in the control handler) upstreams
-    // correctly. Unique labels (`<ws>:<proj>:vite`) keep auto-heal + the reaper from touching the daemon's own
-    // identically-named vites. Returns a reaper the control endpoint calls on unregister.
-    const hostWorkspaceApps = async (fragment) => {
-        // Group a project's (possibly several host) routes so one spawned vite serves them all.
-        const byProject = new Map();
-        for (const r of fragment.routes) {
-            if (!r.lens)
-                continue;
-            const list = byProject.get(r.lens.project) ?? [];
-            list.push(r);
-            byProject.set(r.lens.project, list);
-        }
-        if (byProject.size === 0)
-            return () => { };
-        const eventFile = path.join(fragment.root, '.lensmcp', 'events.jsonl'); // the registered workspace's OWN bus
-        const labels = [];
-        const ports = [];
-        for (const [project, routes] of byProject) {
-            const lens0 = routes[0].lens;
-            if (lens0.started)
-                continue;
-            // Collision-safe port: keep the declared port unless already claimed in-process OR held at the OS
-            // level (an orphaned vite from a crashed daemon), else step up.
-            const port = await claimFreePort(lens0.port, usedAppPorts);
-            ports.push(port);
-            // Point every route of this project at the actual bound port (all share the one vite).
-            for (const r of routes) {
-                r.lens.started = true;
-                r.lens.port = port;
-                r.target = `http://localhost:${port}`;
-            }
-            const labelPrefix = `${fragment.wsKey}:${project}:`;
-            const viteLabel = `${labelPrefix}vite`;
-            const captureLabel = `${labelPrefix}browser-capture`;
-            labels.push(viteLabel, captureLabel);
-            removedLabels.delete(viteLabel); // a fresh registration after a prior unregister → allow auto-heal again
-            removedLabels.delete(captureLabel);
-            // A cwd-injecting spawn view: the registered workspace's children run in ITS root (not the daemon's).
-            const spawnInRoot = (label, bin, args, env, optional, respawn) => spawnManagedChild(label, bin, args, env, optional, respawn, fragment.root);
-            console.log(`[gateway] hosting lens app '${project}' of '${fragment.wsKey}' → vite :${port}`);
-            try {
-                (0, lens_frontend_1.spawnLensFrontend)({
-                    projectRoot: lens0.projectRoot,
-                    workspaceRoot: fragment.root,
-                    project,
-                    eventFile,
-                    port,
-                    chrome: true,
-                    headless: true,
-                    viteEnv: { LENSMCP_PROJECT: project },
-                    labelPrefix,
-                    log: (l) => console.log(l),
-                }, spawnInRoot);
-                // Onto the REGISTERED workspace's OWN bus (like the service layer's `emitSvc`): its cluster
-                // view must show its apps, and the daemon's must not — two workspaces can both own a
-                // project called `dashboard`, so a shared bus makes the fold ambiguous as well as wrong.
-                emit('info', `lens app started: ${fragment.wsKey}/${project} (vite :${port})`, `cluster-lens-app:${fragment.wsKey}:${project}`, { kind: 'lens-app-up', project, port }, undefined, eventFile);
-            }
-            catch (e) {
-                console.error(`[gateway] lens app ${fragment.wsKey}/${project}: ${e.message}`);
-            }
-        }
-        return () => {
-            for (const label of labels) {
-                removedLabels.add(label); // stop auto-heal resurrecting it
-                try {
-                    labeledChildren.get(label)?.kill('SIGTERM');
-                }
-                catch { /* already gone */ }
-                labeledChildren.delete(label);
-            }
-            for (const p of ports)
-                usedAppPorts.delete(p);
-        };
-    };
-    const reapAll = async (graceMs = 2500) => {
-        if (lensSweeper) {
-            clearInterval(lensSweeper);
-            lensSweeper = undefined;
-        }
-        const kids = [...lensChildren];
-        for (const c of kids) {
-            try {
-                c.kill('SIGTERM');
-            }
-            catch { /* already gone */ }
-        }
-        // Grace, then SIGKILL any survivor — vite ignores SIGTERM, so without this it ORPHANS (reparents to
-        // ppid 1) when the daemon exits, keeping its port held (5173/4200/…). Poll so we escalate only for the
-        // stragglers and wait no longer than needed.
-        const alive = (c) => c.exitCode === null && c.signalCode === null;
-        const deadline = Date.now() + graceMs;
-        while (Date.now() < deadline && kids.some(alive)) {
-            await new Promise((r) => setTimeout(r, 100));
-        }
-        for (const c of kids) {
-            if (alive(c)) {
-                try {
-                    c.kill('SIGKILL');
-                }
-                catch { /* already gone */ }
-            }
-        }
-    };
-    const probeLensFrontends = () => probeLensChildren({ graceMs: types_1.LENS_PROBE_GRACE_MS, failureThreshold: types_1.LENS_PROBE_FAILS, cooldownMs: types_1.LENS_PROBE_COOLDOWN_MS }, types_1.LENS_PROBE_ENABLED);
-    return { spawnManagedChild, bootSingletonsAndApps, hostWorkspaceDashboard, hostWorkspaceApps, probeLensFrontends, reapAll };
-}
+"use strict";var V=Object.defineProperty;var L=(t,c)=>V(t,"name",{value:c,configurable:!0});var G=Object.defineProperty,i=L((t,c)=>G(t,"name",{value:c,configurable:!0}),"i");Object.defineProperty(exports,"__esModule",{value:!0}),exports.probePortFree=probePortFree,exports.probePortListening=probePortListening,exports.waitForPortFree=waitForPortFree,exports.viteArgPort=viteArgPort,exports.createLensChildren=createLensChildren;const tslib_1=require("tslib"),net=tslib_1.__importStar(require("node:net")),path=tslib_1.__importStar(require("node:path")),node_child_process_1=require("node:child_process"),lens_frontend_1=require("@lensmcp/nx-plugin/lens-frontend"),pod_env_1=require("./pod-env"),scope_1=require("./scope"),workspace_registry_1=require("./workspace-registry"),lifecycle_1=require("./lifecycle"),types_1=require("./types"),observability_1=require("./observability"),HEAL_BASE_MS=1500,HEAL_MAX_MS=3e4,HEAL_HEALTHY_MS=2e4;function tryBind(t,c){return new Promise(p=>{const h=net.createServer();h.unref(),h.once("error",E=>{const _=E.code??"";p(_==="EADDRINUSE"||_==="EACCES"?"in-use":"unavailable")}),h.listen(c===void 0?{port:t}:{port:t,host:c},()=>h.close(()=>p("free")))})}L(tryBind,"tryBind"),i(tryBind,"tryBind");async function probePortFree(t){for(const c of[void 0,"127.0.0.1","::1"])if(await tryBind(t,c)==="in-use")return!1;return!0}L(probePortFree,"probePortFree"),i(probePortFree,"probePortFree");function probeConnect(t,c,p){return new Promise(h=>{let E=!1;const _=net.createConnection({host:t,port:c});_.unref();const g=setTimeout(()=>b(!1),p);g.unref?.();function b(M){E||(E=!0,clearTimeout(g),_.destroy(),h(M))}L(b,"g"),i(b,"finish"),_.once("connect",()=>b(!0)),_.once("error",()=>b(!1))})}L(probeConnect,"probeConnect"),i(probeConnect,"probeConnect");async function probePortListening(t,c=1e3){return await probeConnect("127.0.0.1",t,c)?!0:probeConnect("::1",t,c)}L(probePortListening,"probePortListening"),i(probePortListening,"probePortListening");const sleepUnref=i(t=>new Promise(c=>{setTimeout(c,t).unref?.()}),"sleepUnref");async function waitForPortFree(t,c,p={}){const h=p.isPortFree??probePortFree,E=Math.max(1,p.intervalMs??types_1.PORT_FREE_POLL_MS),_=Date.now()+Math.max(0,c);for(;;){if(await h(t))return!0;const g=_-Date.now();if(g<=0)return!1;await sleepUnref(Math.min(E,g))}}L(waitForPortFree,"waitForPortFree"),i(waitForPortFree,"waitForPortFree");function viteArgPort(t){const c=i(p=>Number.isInteger(p)&&p>0&&p<65536?p:void 0,"valid");for(let p=0;p<t.length;p+=1){const h=t[p];if(h==="--port")return c(Number(t[p+1]));if(h.startsWith("--port="))return c(Number(h.slice(7)))}}L(viteArgPort,"viteArgPort"),i(viteArgPort,"viteArgPort");function createLensChildren(t,c,p,h){const{emit:E}=c,_=h?.isPortFree??probePortFree,g=[],b=new Map,M=new Map,A=new Map;let R;const v=new Map,y=new Set,j=new Set,D=new Set,m=i(async(o,a)=>{let s=o;for(;a.has(s)||!await _(s);)s+=1;return a.add(s),s!==o&&console.warn(`[gateway] port ${o} is unavailable (another process holds it \u2014 an orphan from a crashed gateway?) \u2014 using ${s} instead.`),s},"claimFreePort"),C=i((o,a,s,e,r=!1,n,l)=>{const d=Date.now(),u=(0,node_child_process_1.spawn)(a,s,{cwd:l??t.root,env:{...(0,pod_env_1.podBaseEnv)(process.env,t.root,l??t.root),...e??{},LENSMCP_PARENT_PID:String(process.pid)},stdio:"inherit"});g.push(u),v.set(o,u);const $=o==="vite"||o.endsWith(":vite"),w=$?viteArgPort(s):void 0;if($){const P=typeof e?.LENSMCP_EVENT_FILE=="string"?e.LENSMCP_EVENT_FILE:void 0;M.set(u,{project:e?.LENSMCP_PROJECT??"app",spawnedAt:d,port:w,probeFails:0,listening:!1,...P&&P!==t.eventFile?{bus:P}:{}})}return u.on("exit",(P,O)=>{const f=g.indexOf(u);if(f>=0&&g.splice(f,1),M.delete(u),t.stopped()||y.has(o))return;const T=Date.now()-d,S=b.get(o)??{attempts:0,portConflicts:0};(async()=>{const I=w!==void 0&&!await _(w);if((0,lifecycle_1.isPortConflictExit)({code:P,signal:O,ranMs:T,portHeld:I},{fastFailMs:types_1.CHILD_START_FAIL_MS})&&S.portConflicts<types_1.MAX_PORT_CONFLICT_RETRIES)S.portConflicts+=1,b.set(o,S),console.warn(`[gateway] lens child ${o} lost the :${w} bind race (EADDRINUSE, code=${P}); waiting for the port, then retrying (port-retry ${S.portConflicts}/${types_1.MAX_PORT_CONFLICT_RETRIES}; crash budget untouched).`);else{S.portConflicts=0,T>=HEAL_HEALTHY_MS&&(S.attempts=0);const N=Math.min(HEAL_MAX_MS,HEAL_BASE_MS*2**S.attempts);S.attempts+=1,b.set(o,S),console.warn(`[gateway] lens child ${o} exited (code=${P} sig=${O}); auto-healing in ${Math.round(N/1e3)}s (attempt ${S.attempts}).`),await sleepUnref(N)}t.stopped()||y.has(o)||(w!==void 0&&!await waitForPortFree(w,types_1.PORT_FREE_WAIT_MS,{isPortFree:_,intervalMs:types_1.PORT_FREE_POLL_MS})&&console.warn(`[gateway] lens child ${o}: :${w} still held after ${Math.round(types_1.PORT_FREE_WAIT_MS/1e3)}s \u2014 spawning anyway.`),!(t.stopped()||y.has(o))&&C(o,a,s,e,r,n,l))})().catch(()=>{})}),u},"spawnManagedChild");let F=!1;const B=i(async(o,a)=>{if(!F){F=!0;try{for(const[s,e]of[...M]){if(t.stopped())return;if(e.port===void 0||s.exitCode!==null||s.signalCode!==null)continue;if(await probePortListening(e.port,types_1.LENS_PROBE_TIMEOUT_MS)){e.probeFails=0,e.listening||(e.listening=!0,E("info",`lens app up: ${e.project} (vite :${e.port} listening)`,`cluster-lens-app:${e.project}`,{kind:"service-up",project:e.project,port:e.port},void 0,e.bus));continue}if(Date.now()-e.spawnedAt<o.graceMs){e.probeFails=0;continue}if(!a)continue;e.probeFails+=1;const r=(0,lifecycle_1.lensChildWedged)(e,A.get(e.project)??0,Date.now(),o);if(r){A.set(e.project,Date.now()),e.probeFails=0,e.listening=!1,console.error(`[gateway] wedge recycle: lens app ${e.project} is ALIVE but NOT LISTENING on :${e.port} after ${Math.max(2,o.failureThreshold)} probes \u2014 SIGKILL; a fresh vite is coming.`),E("warning",`wedge recycle: ${e.project} (${r})`,`cluster-lens-app:${e.project}`,{kind:"pod-recycle",project:e.project,reason:r,port:e.port},void 0,e.bus);try{s.kill("SIGKILL")}catch{}}}}finally{F=!1}}},"probeLensChildren"),x=i(()=>{if(R||!types_1.POD_RECYCLE_ENABLED&&!types_1.LENS_PROBE_ENABLED)return;const o={graceMs:types_1.POD_STALE_GRACE_MS,settleMs:types_1.POD_RECYCLE_SETTLE_MS,cooldownMs:types_1.POD_STALE_RECYCLE_COOLDOWN_MS};R=setInterval(()=>{if(t.stopped()||M.size===0||(k(),!types_1.POD_RECYCLE_ENABLED))return;const a=t.sourceSetChangedAt??0;if(a<=0)return;const s=Date.now();for(const[e,r]of M){const n=t.sourceSetChangedFor?.get(r.project)??a,l=A.get(r.project)??0;if((0,lifecycle_1.lensFrontendStale)(r.spawnedAt,l,n,s,o)){A.set(r.project,s),r.listening=!1,console.log(`[gateway] zombie recycle: lens app ${r.project} (stale-source-set) \u2014 vite missed a file add; restarting it`),E("warning",`zombie recycle: ${r.project} (stale-source-set)`,`cluster-lens-app:${r.project}`,{kind:"pod-recycle",project:r.project,reason:"stale-source-set"},void 0,r.bus);try{e.kill("SIGTERM")}catch{}}}},Math.min(types_1.POD_STALE_SCAN_MS,15e3)),R.unref?.()},"startLensSweeper"),K=i(async()=>{const o=[...new Map(t.routes.filter(e=>e.lens).map(e=>[e.project,e.lens])).values()],a=p.dashboard!==!1,s=p.mcp!==!1&&o.length>0;if(a){const e=(0,lens_frontend_1.findDashboardBundle)(t.root);if(!e)console.warn("[gateway] lens dashboard bundle not found \u2014 skipping. Install the self-contained CLI: `npm i -D lensmcp` (it ships `bundled/dashboard.js`), or `yarn nx build @lensmcp/lensmcp-mcp` in-repo.");else{const r=(0,scope_1.readLensScope)(t.root),n=await m(p.dashboardPort??r.dashboardPort,j),l=p.lensHost??"lensmcp.local",d=r.basePath;t.registry.appendRoutes(t.wsKey,[{host:l,prefix:d,project:observability_1.LENS_DASHBOARD_PROJECT,target:`http://localhost:${n}`}]),t.rebuildRoutes(),(0,workspace_registry_1.registerWorkspace)({key:r.key,root:t.root,base:d,pid:process.pid,procStamp:(0,workspace_registry_1.processStamp)(process.pid),updatedAt:new Date().toISOString()}),console.log(`[gateway] starting lens dashboard \u2192 http://localhost:${n} (routed at https://${l}${d}/)`),E("info",`lens dashboard up: ${l}${d} \u2192 :${n}`,"cluster-lens-dashboard",{kind:"lens-dashboard-up",host:l,port:n,base:d}),C("lens-dashboard",process.execPath,[e],{LENSMCP_EVENT_FILE:t.eventFile,LENSMCP_DASHBOARD_PORT:String(n),LENSMCP_DASHBOARD_BASE:d})}}if(s){const e=(0,lens_frontend_1.findMcpBundle)(t.root);if(!e)console.warn("[gateway] MCP server bundle not found \u2014 skipping (lens apps will still publish to the bus; an external `lensmcp mcp` can read it). Install: `npm i -D lensmcp`.");else{const r=(0,scope_1.readLensScope)(t.root),n=Number(process.env.LENSMCP_PORT??r.mcpHttpPort);console.log(`[gateway] starting lens MCP server on 127.0.0.1:${n} (${e})`),C("lens-mcp",process.execPath,[e],{LENSMCP_EVENT_FILE:t.eventFile,LENSMCP_TRANSPORT:process.env.LENSMCP_TRANSPORT??"http",LENSMCP_PORT:String(n),LENSMCP_WORKSPACE_KEY:r.key,LENSMCP_WORKSPACE_ROOT:t.root})}}for(const e of o){if(e.started)continue;e.started=!0;const r=await m(e.port,D);if(r!==e.port){for(const n of t.routes)n.lens?.project===e.project&&(n.lens.port=r,n.target=`http://localhost:${r}`);e.port=r}try{(0,lens_frontend_1.spawnLensFrontend)({projectRoot:e.projectRoot,workspaceRoot:t.root,project:e.project,eventFile:t.eventFile,port:e.port,chrome:!0,headless:!0,viteEnv:{LENSMCP_PROJECT:e.project},log:i(n=>console.log(n),"log")},C),E("info",`lens app started: ${e.project} (vite :${e.port})`,`cluster-lens-app:${e.project}`,{kind:"lens-app-up",project:e.project,port:e.port})}catch(n){console.error(`[gateway] lens app ${e.project}: ${n.message}`)}}x()},"bootSingletonsAndApps"),W=i(async o=>{const a=(0,lens_frontend_1.findDashboardBundle)(t.root);if(!a)return;const s=(0,scope_1.readLensScope)(o.root),e=p.lensHost??"lensmcp.local",r=s.basePath,n=await m(s.dashboardPort,j),l=`lens-dashboard:${o.wsKey}`,d=path.join(o.root,".lensmcp","events.jsonl");return y.delete(l),t.registry.appendRoutes(o.wsKey,[{host:e,prefix:r,project:observability_1.LENS_DASHBOARD_PROJECT,target:`http://localhost:${n}`}]),(0,workspace_registry_1.registerWorkspace)({key:o.wsKey,root:o.root,base:r,pid:process.pid,procStamp:(0,workspace_registry_1.processStamp)(process.pid),updatedAt:new Date().toISOString()}),console.log(`[gateway] hosting dashboard for workspace '${o.wsKey}' \u2192 http://localhost:${n} (routed at https://${e}${r}/)`),E("info",`lens dashboard up: ${e}${r} \u2192 :${n}`,"cluster-lens-dashboard",{kind:"lens-dashboard-up",host:e,port:n,base:r}),C(l,process.execPath,[a],{LENSMCP_EVENT_FILE:d,LENSMCP_DASHBOARD_PORT:String(n),LENSMCP_DASHBOARD_BASE:r,LENSMCP_WS_KEY:o.wsKey},!1,void 0,o.root),()=>{y.add(l),j.delete(n),(0,workspace_registry_1.unregisterWorkspace)(o.wsKey);try{v.get(l)?.kill("SIGTERM")}catch{}v.delete(l)}},"hostWorkspaceDashboard"),H=i(async o=>{const a=new Map;for(const n of o.routes){if(!n.lens)continue;const l=a.get(n.lens.project)??[];l.push(n),a.set(n.lens.project,l)}if(a.size===0)return()=>{};const s=path.join(o.root,".lensmcp","events.jsonl"),e=[],r=[];for(const[n,l]of a){const d=l[0].lens;if(d.started)continue;const u=await m(d.port,D);r.push(u);for(const f of l)f.lens.started=!0,f.lens.port=u,f.target=`http://localhost:${u}`;const $=`${o.wsKey}:${n}:`,w=`${$}vite`,P=`${$}browser-capture`;e.push(w,P),y.delete(w),y.delete(P);const O=i((f,T,S,I,N,Y)=>C(f,T,S,I,N,Y,o.root),"spawnInRoot");console.log(`[gateway] hosting lens app '${n}' of '${o.wsKey}' \u2192 vite :${u}`);try{(0,lens_frontend_1.spawnLensFrontend)({projectRoot:d.projectRoot,workspaceRoot:o.root,project:n,eventFile:s,port:u,chrome:!0,headless:!0,viteEnv:{LENSMCP_PROJECT:n},labelPrefix:$,log:i(f=>console.log(f),"log")},O),E("info",`lens app started: ${o.wsKey}/${n} (vite :${u})`,`cluster-lens-app:${o.wsKey}:${n}`,{kind:"lens-app-up",project:n,port:u},void 0,s)}catch(f){console.error(`[gateway] lens app ${o.wsKey}/${n}: ${f.message}`)}}return()=>{for(const n of e){y.add(n);try{v.get(n)?.kill("SIGTERM")}catch{}v.delete(n)}for(const n of r)D.delete(n)}},"hostWorkspaceApps"),q=i(async(o=2500)=>{R&&(clearInterval(R),R=void 0);const a=[...g];for(const r of a)try{r.kill("SIGTERM")}catch{}const s=i(r=>r.exitCode===null&&r.signalCode===null,"alive"),e=Date.now()+o;for(;Date.now()<e&&a.some(s);)await new Promise(r=>setTimeout(r,100));for(const r of a)if(s(r))try{r.kill("SIGKILL")}catch{}},"reapAll"),k=i(()=>B({graceMs:types_1.LENS_PROBE_GRACE_MS,failureThreshold:types_1.LENS_PROBE_FAILS,cooldownMs:types_1.LENS_PROBE_COOLDOWN_MS},types_1.LENS_PROBE_ENABLED),"probeLensFrontends");return{spawnManagedChild:C,bootSingletonsAndApps:K,hostWorkspaceDashboard:W,hostWorkspaceApps:H,probeLensFrontends:k,reapAll:q}}L(createLensChildren,"createLensChildren"),i(createLensChildren,"createLensChildren");