@dollhousemcp/mcp-server 2.0.0-rc.6 → 2.0.0

package/dist/web/console/IngestRoutes.js

@@ -0,0 +1,252 @@
+/**
+ * Event ingestion routes for the unified web console.
+ *
+ * The console leader mounts these routes so follower MCP servers can
+ * forward their logs, metrics, and session lifecycle events. All ingested
+ * entries are stamped with `_sessionId` in their data field and then
+ * broadcast to SSE clients via the existing log/metrics broadcast hooks.
+ *
+ * Routes:
+ * - POST /api/ingest/logs     — Batched log entries from a follower
+ * - POST /api/ingest/metrics  — Metric snapshots from a follower
+ * - POST /api/ingest/session  — Session lifecycle events (started/stopped/heartbeat)
+ * - GET  /api/sessions        — Active session list for the UI
+ *
+ * @since v2.1.0 — Issue #1700
+ */
+import express, { Router } from 'express';
+import { SlidingWindowRateLimiter } from '../../utils/SlidingWindowRateLimiter.js';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { SessionNamePool } from './SessionNames.js';
+import { logger } from '../../utils/logger.js';
+/** Maximum payload size for ingestion requests */
+const MAX_PAYLOAD_SIZE = '1mb';
+/** Rate limit: max requests per window per source */
+const RATE_LIMIT_MAX = 1000;
+const RATE_LIMIT_WINDOW_MS = 60_000;
+/** How often to check for stale sessions (ms) */
+const REAPER_INTERVAL_MS = 5_000;
+/** How long since last heartbeat before a session is considered dead (ms) */
+const SESSION_STALE_MS = 15_000;
+/** Normalize a string via UnicodeValidator (DMCP-SEC-004) */
+function normalizeInput(s) {
+    return UnicodeValidator.normalize(s).normalizedContent;
+}
+/**
+ * Create the ingestion routes and session registry.
+ *
+ * @param broadcasts - Callbacks to forward ingested events to SSE clients
+ * @returns Router and session management functions
+ */
+export function createIngestRoutes(broadcasts) {
+    const router = Router();
+    const sessions = new Map();
+    const namePool = new SessionNamePool();
+    const rateLimiter = new SlidingWindowRateLimiter(RATE_LIMIT_MAX, RATE_LIMIT_WINDOW_MS);
+    // JSON body parsing with size limit
+    router.use(express.json({ limit: MAX_PAYLOAD_SIZE }));
+    /**
+     * POST /api/ingest/logs — Receive batched log entries from a follower.
+     */
+    router.post('/api/ingest/logs', (req, res) => {
+        if (!rateLimiter.tryAcquire()) {
+            res.status(429).json({ error: 'Rate limit exceeded' });
+            return;
+        }
+        const payload = req.body;
+        if (!payload?.sessionId || !Array.isArray(payload.entries)) {
+            const received = payload ? Object.keys(payload) : [];
+            logger.warn('[IngestRoutes] Invalid log payload', { received, hasSessionId: !!payload?.sessionId, hasEntries: Array.isArray(payload?.entries) });
+            res.status(400).json({ error: 'Invalid payload', required: ['sessionId', 'entries'], received });
+            return;
+        }
+        payload.sessionId = normalizeInput(payload.sessionId);
+        let count = 0;
+        let skipped = 0;
+        for (const entry of payload.entries) {
+            if (!entry || typeof entry.message !== 'string') {
+                skipped++;
+                continue;
+            }
+            const stamped = {
+                ...entry,
+                data: { ...entry.data, _sessionId: payload.sessionId },
+            };
+            broadcasts.logBroadcast(stamped);
+            count++;
+        }
+        // Update session heartbeat
+        const session = sessions.get(payload.sessionId);
+        if (session) {
+            session.lastHeartbeat = new Date().toISOString();
+        }
+        if (skipped > 0) {
+            logger.debug(`[IngestRoutes] Log ingest from ${session?.displayName ?? payload.sessionId}: accepted=${count}, skipped=${skipped}`);
+        }
+        res.status(200).json({ accepted: count, skipped });
+    });
+    /**
+     * POST /api/ingest/metrics — Receive metric snapshots from a follower.
+     */
+    router.post('/api/ingest/metrics', (req, res) => {
+        if (!rateLimiter.tryAcquire()) {
+            res.status(429).json({ error: 'Rate limit exceeded' });
+            return;
+        }
+        const payload = req.body;
+        if (!payload?.sessionId || !payload.snapshot) {
+            const received = payload ? Object.keys(payload) : [];
+            logger.warn('[IngestRoutes] Invalid metrics payload', { received });
+            res.status(400).json({ error: 'Invalid payload', required: ['sessionId', 'snapshot'], received });
+            return;
+        }
+        payload.sessionId = normalizeInput(payload.sessionId);
+        if (broadcasts.metricsOnSnapshot) {
+            broadcasts.metricsOnSnapshot(payload.snapshot);
+        }
+        const session = sessions.get(payload.sessionId);
+        logger.debug(`[IngestRoutes] Metrics ingested from ${session?.displayName ?? payload.sessionId}`);
+        res.status(200).json({ accepted: true });
+    });
+    /**
+     * POST /api/ingest/session — Session lifecycle events.
+     */
+    router.post('/api/ingest/session', (req, res) => {
+        const payload = req.body;
+        if (!payload?.sessionId || !payload.event) {
+            const received = payload ? Object.keys(payload) : [];
+            logger.warn('[IngestRoutes] Invalid session event payload', { received });
+            res.status(400).json({ error: 'Invalid payload', required: ['sessionId', 'event'], received });
+            return;
+        }
+        payload.sessionId = normalizeInput(payload.sessionId);
+        const now = new Date().toISOString();
+        switch (payload.event) {
+            case 'started': {
+                const displayName = namePool.assign(payload.sessionId);
+                const color = namePool.getColor(payload.sessionId) ?? '#3b82f6';
+                const info = {
+                    sessionId: payload.sessionId,
+                    displayName,
+                    color,
+                    pid: payload.pid,
+                    startedAt: payload.startedAt || now,
+                    lastHeartbeat: now,
+                    status: 'active',
+                    isLeader: false,
+                };
+                sessions.set(payload.sessionId, info);
+                logger.info('[IngestRoutes] Session registered', {
+                    displayName, sessionId: payload.sessionId, pid: payload.pid, color,
+                    activeSessions: Array.from(sessions.values()).filter(s => s.status === 'active').length,
+                });
+                broadcasts.sessionBroadcast?.(info);
+                break;
+            }
+            case 'stopped': {
+                const existing = sessions.get(payload.sessionId);
+                if (existing) {
+                    existing.status = 'ended';
+                    existing.lastHeartbeat = now;
+                    namePool.release(payload.sessionId);
+                    logger.info('[IngestRoutes] Session stopped', {
+                        displayName: existing.displayName, sessionId: payload.sessionId, pid: existing.pid,
+                        activeSessions: Array.from(sessions.values()).filter(s => s.status === 'active').length - 1,
+                    });
+                    broadcasts.sessionBroadcast?.(existing);
+                }
+                break;
+            }
+            case 'heartbeat': {
+                const existing = sessions.get(payload.sessionId);
+                if (existing) {
+                    existing.lastHeartbeat = now;
+                }
+                break;
+            }
+        }
+        res.status(200).json({ ok: true });
+    });
+    /**
+     * GET /api/sessions — List all tracked sessions.
+     */
+    router.get('/api/sessions', (_req, res) => {
+        const allSessions = Array.from(sessions.values());
+        res.json({ sessions: allSessions });
+    });
+    /**
+     * POST /api/sessions/:sessionId/kill — Terminate a session's server process.
+     */
+    router.post('/api/sessions/:sessionId/kill', (req, res) => {
+        const sessionId = req.params['sessionId'];
+        const session = sessions.get(sessionId);
+        if (!session) {
+            logger.warn('[IngestRoutes] Kill requested for unknown session', { sessionId });
+            res.status(404).json({ error: 'Session not found', sessionId });
+            return;
+        }
+        if (!session.pid) {
+            res.status(400).json({ error: 'No PID for session', sessionId, displayName: session.displayName });
+            return;
+        }
+        try {
+            process.kill(session.pid, 'SIGTERM');
+            session.status = 'ended';
+            namePool.release(sessionId);
+            logger.info('[IngestRoutes] Session killed', {
+                displayName: session.displayName, sessionId, pid: session.pid,
+                activeSessions: Array.from(sessions.values()).filter(s => s.status === 'active').length - 1,
+            });
+            res.json({ ok: true, killed: session.displayName, pid: session.pid });
+        }
+        catch (err) {
+            const message = err.message;
+            logger.error('[IngestRoutes] Failed to kill session', {
+                displayName: session.displayName, sessionId, pid: session.pid, error: message,
+            });
+            res.status(500).json({ error: 'Failed to kill session', sessionId, displayName: session.displayName, pid: session.pid, detail: message });
+        }
+    });
+    // Reaper: periodically check for stale sessions whose heartbeat has expired
+    const reaperInterval = setInterval(() => {
+        const now = Date.now();
+        for (const [id, session] of sessions) {
+            if (session.status !== 'active')
+                continue;
+            if (session.isLeader)
+                continue; // leader manages itself
+            const age = now - new Date(session.lastHeartbeat).getTime();
+            if (age > SESSION_STALE_MS) {
+                session.status = 'ended';
+                namePool.release(id);
+                logger.info('[IngestRoutes] Reaped stale session', {
+                    displayName: session.displayName, sessionId: id, pid: session.pid,
+                    lastHeartbeatAgo: `${Math.round(age / 1000)}s`,
+                    activeSessions: Array.from(sessions.values()).filter(s => s.status === 'active').length - 1,
+                });
+                broadcasts.sessionBroadcast?.(session);
+            }
+        }
+    }, REAPER_INTERVAL_MS);
+    reaperInterval.unref();
+    function getSessions() {
+        return Array.from(sessions.values()).filter(s => s.status === 'active');
+    }
+    function registerLeaderSession(sessionId, pid) {
+        const displayName = namePool.assign(sessionId, true);
+        const color = namePool.getColor(sessionId) ?? '#3b82f6';
+        sessions.set(sessionId, {
+            sessionId,
+            displayName,
+            color,
+            pid,
+            startedAt: new Date().toISOString(),
+            lastHeartbeat: new Date().toISOString(),
+            status: 'active',
+            isLeader: true,
+        });
+        logger.info('[IngestRoutes] Leader session registered', { displayName, sessionId, pid, color });
+    }
+    return { router, getSessions, registerLeaderSession };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"IngestRoutes.js","sourceRoot":"","sources":["../../../src/web/console/IngestRoutes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,OAAO,EAAE,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAI1C,OAAO,EAAE,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AACnF,OAAO,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE/C,kDAAkD;AAClD,MAAM,gBAAgB,GAAG,KAAK,CAAC;AAE/B,qDAAqD;AACrD,MAAM,cAAc,GAAG,IAAI,CAAC;AAC5B,MAAM,oBAAoB,GAAG,MAAM,CAAC;AAEpC,iDAAiD;AACjD,MAAM,kBAAkB,GAAG,KAAK,CAAC;AAEjC,6EAA6E;AAC7E,MAAM,gBAAgB,GAAG,MAAM,CAAC;AAiEhC,6DAA6D;AAC7D,SAAS,cAAc,CAAC,CAAS;IAC/B,OAAO,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,UAA4B;IAC7D,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC;IACxB,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAuB,CAAC;IAChD,MAAM,QAAQ,GAAG,IAAI,eAAe,EAAE,CAAC;IACvC,MAAM,WAAW,GAAG,IAAI,wBAAwB,CAAC,cAAc,EAAE,oBAAoB,CAAC,CAAC;IAEvF,oCAAoC;IACpC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,gBAAgB,EAAE,CAAC,CAAC,CAAC;IAEtD;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC,GAAY,EAAE,GAAa,EAAE,EAAE;QAC9D,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,EAAE,CAAC;YAC9B,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,qBAAqB,EAAE,CAAC,CAAC;YACvD,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,GAAG,CAAC,IAAwB,CAAC;QAC7C,IAAI,CAAC,OAAO,EAAE,SAAS,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3D,MAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACrD,MAAM,CAAC,IAAI,CAAC,oCAAoC,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC,CAAC,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;YACjJ,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,CAAC,WAAW,EAAE,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;YACjG,OAAO;QACT,CAAC;QACD,OAAO,CAAC,SAAS,GAAG,cAAc,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAEtD,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YACpC,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;gBAAC,OAAO,EAAE,CAAC;gBAAC,SAAS;YAAC,CAAC;YACzE,MAAM,OAAO,GAAoB;gBAC/B,GAAG,KAAK;gBACR,IAAI,EAAE,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,SAAS,EAAE;aACvD,CAAC;YACF,UAAU,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;YACjC,KAAK,EAAE,CAAC;QACV,CAAC;QAED,2BAA2B;QAC3B,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAChD,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,CAAC,aAAa,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QACnD,CAAC;QAED,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;YAChB,MAAM,CAAC,KAAK,CAAC,kCAAkC,OAAO,EAAE,WAAW,IAAI,OAAO,CAAC,SAAS,cAAc,KAAK,aAAa,OAAO,EAAE,CAAC,CAAC;QACrI,CAAC;QAED,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC,GAAY,EAAE,GAAa,EAAE,EAAE;QACjE,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,EAAE,CAAC;YAC9B,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,qBAAqB,EAAE,CAAC,CAAC;YACvD,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,GAAG,CAAC,IAA4B,CAAC;QACjD,IAAI,CAAC,OAAO,EAAE,SAAS,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;YAC7C,MAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACrD,MAAM,CAAC,IAAI,CAAC,wCAAwC,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;YACpE,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,CAAC,WAAW,EAAE,UAAU,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;YAClG,OAAO;QACT,CAAC;QACD,OAAO,CAAC,SAAS,GAAG,cAAc,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAEtD,IAAI,UAAU,CAAC,iBAAiB,EAAE,CAAC;YACjC,UAAU,CAAC,iBAAiB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACjD,CAAC;QAED,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAChD,MAAM,CAAC,KAAK,CAAC,wCAAwC,OAAO,EAAE,WAAW,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;QAClG,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC;IAEH;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC,GAAY,EAAE,GAAa,EAAE,EAAE;QACjE,MAAM,OAAO,GAAG,GAAG,CAAC,IAA2B,CAAC;QAChD,IAAI,CAAC,OAAO,EAAE,SAAS,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;YAC1C,MAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACrD,MAAM,CAAC,IAAI,CAAC,8CAA8C,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;YAC1E,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,CAAC,WAAW,EAAE,OAAO,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;YAC/F,OAAO;QACT,CAAC;QACD,OAAO,CAAC,SAAS,GAAG,cAAc,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAEtD,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAErC,QAAQ,OAAO,CAAC,KAAK,EAAE,CAAC;YACtB,KAAK,SAAS,CAAC,CAAC,CAAC;gBACf,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;gBACvD,MAAM,KAAK,GAAG,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC;gBAChE,MAAM,IAAI,GAAgB;oBACxB,SAAS,EAAE,OAAO,CAAC,SAAS;oBAC5B,WAAW;oBACX,KAAK;oBACL,GAAG,EAAE,OAAO,CAAC,GAAG;oBAChB,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,GAAG;oBACnC,aAAa,EAAE,GAAG;oBAClB,MAAM,EAAE,QAAQ;oBAChB,QAAQ,EAAE,KAAK;iBAChB,CAAC;gBACF,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;gBACtC,MAAM,CAAC,IAAI,CAAC,mCAAmC,EAAE;oBAC/C,WAAW,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,KAAK;oBAClE,cAAc,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,MAAM;iBACxF,CAAC,CAAC;gBACH,UAAU,CAAC,gBAAgB,EAAE,CAAC,IAAI,CAAC,CAAC;gBACpC,MAAM;YACR,CAAC;YACD,KAAK,SAAS,CAAC,CAAC,CAAC;gBACf,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;gBACjD,IAAI,QAAQ,EAAE,CAAC;oBACb,QAAQ,CAAC,MAAM,GAAG,OAAO,CAAC;oBAC1B,QAAQ,CAAC,aAAa,GAAG,GAAG,CAAC;oBAC7B,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;oBACpC,MAAM,CAAC,IAAI,CAAC,gCAAgC,EAAE;wBAC5C,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,GAAG,EAAE,QAAQ,CAAC,GAAG;wBAClF,cAAc,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC;qBAC5F,CAAC,CAAC;oBACH,UAAU,CAAC,gBAAgB,EAAE,CAAC,QAAQ,CAAC,CAAC;gBAC1C,CAAC;gBACD,MAAM;YACR,CAAC;YACD,KAAK,WAAW,CAAC,CAAC,CAAC;gBACjB,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;gBACjD,IAAI,QAAQ,EAAE,CAAC;oBACb,QAAQ,CAAC,aAAa,GAAG,GAAG,CAAC;gBAC/B,CAAC;gBACD,MAAM;YACR,CAAC;QACH,CAAC;QAED,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;IACrC,CAAC,CAAC,CAAC;IAEH;;OAEG;IACH,MAAM,CAAC,GAAG,CAAC,eAAe,EAAE,CAAC,IAAa,EAAE,GAAa,EAAE,EAAE;QAC3D,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;QAClD,GAAG,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,+BAA+B,EAAE,CAAC,GAAY,EAAE,GAAa,EAAE,EAAE;QAC3E,MAAM,SAAS,GAAG,GAAG,CAAC,MAAM,CAAC,WAAW,CAAW,CAAC;QACpD,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAExC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,mDAAmD,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC;YAChF,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,mBAAmB,EAAE,SAAS,EAAE,CAAC,CAAC;YAChE,OAAO;QACT,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;YACjB,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;YACnG,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;YACrC,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC;YACzB,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAC5B,MAAM,CAAC,IAAI,CAAC,+BAA+B,EAAE;gBAC3C,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,SAAS,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG;gBAC7D,cAAc,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC;aAC5F,CAAC,CAAC;YACH,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,WAAW,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;QACxE,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,OAAO,GAAI,GAAa,CAAC,OAAO,CAAC;YACvC,MAAM,CAAC,KAAK,CAAC,uCAAuC,EAAE;gBACpD,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,SAAS,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,KAAK,EAAE,OAAO;aAC9E,CAAC,CAAC;YACH,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,wBAAwB,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;QAC5I,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,4EAA4E;IAC5E,MAAM,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE;QACtC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,KAAK,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,IAAI,QAAQ,EAAE,CAAC;YACrC,IAAI,OAAO,CAAC,MAAM,KAAK,QAAQ;gBAAE,SAAS;YAC1C,IAAI,OAAO,CAAC,QAAQ;gBAAE,SAAS,CAAC,wBAAwB;YACxD,MAAM,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE,CAAC;YAC5D,IAAI,GAAG,GAAG,gBAAgB,EAAE,CAAC;gBAC3B,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC;gBACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;gBACrB,MAAM,CAAC,IAAI,CAAC,qCAAqC,EAAE;oBACjD,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,SAAS,EAAE,EAAE,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG;oBACjE,gBAAgB,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG;oBAC9C,cAAc,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC;iBAC5F,CAAC,CAAC;gBACH,UAAU,CAAC,gBAAgB,EAAE,CAAC,OAAO,CAAC,CAAC;YACzC,CAAC;QACH,CAAC;IACH,CAAC,EAAE,kBAAkB,CAAC,CAAC;IACvB,cAAc,CAAC,KAAK,EAAE,CAAC;IAEvB,SAAS,WAAW;QAClB,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC;IAC1E,CAAC;IAED,SAAS,qBAAqB,CAAC,SAAiB,EAAE,GAAW;QAC3D,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QACrD,MAAM,KAAK,GAAG,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC;QACxD,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE;YACtB,SAAS;YACT,WAAW;YACX,KAAK;YACL,GAAG;YACH,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACnC,aAAa,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACvC,MAAM,EAAE,QAAQ;YAChB,QAAQ,EAAE,IAAI;SACf,CAAC,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,0CAA0C,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;IAClG,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,qBAAqB,EAAE,CAAC;AACxD,CAAC","sourcesContent":["/**\n * Event ingestion routes for the unified web console.\n *\n * The console leader mounts these routes so follower MCP servers can\n * forward their logs, metrics, and session lifecycle events. All ingested\n * entries are stamped with `_sessionId` in their data field and then\n * broadcast to SSE clients via the existing log/metrics broadcast hooks.\n *\n * Routes:\n * - POST /api/ingest/logs     — Batched log entries from a follower\n * - POST /api/ingest/metrics  — Metric snapshots from a follower\n * - POST /api/ingest/session  — Session lifecycle events (started/stopped/heartbeat)\n * - GET  /api/sessions        — Active session list for the UI\n *\n * @since v2.1.0 — Issue #1700\n */\n\nimport express, { Router } from 'express';\nimport type { Request, Response } from 'express';\nimport type { UnifiedLogEntry } from '../../logging/types.js';\nimport type { MetricSnapshot } from '../../metrics/types.js';\nimport { SlidingWindowRateLimiter } from '../../utils/SlidingWindowRateLimiter.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SessionNamePool } from './SessionNames.js';\nimport { logger } from '../../utils/logger.js';\n\n/** Maximum payload size for ingestion requests */\nconst MAX_PAYLOAD_SIZE = '1mb';\n\n/** Rate limit: max requests per window per source */\nconst RATE_LIMIT_MAX = 1000;\nconst RATE_LIMIT_WINDOW_MS = 60_000;\n\n/** How often to check for stale sessions (ms) */\nconst REAPER_INTERVAL_MS = 5_000;\n\n/** How long since last heartbeat before a session is considered dead (ms) */\nconst SESSION_STALE_MS = 15_000;\n\n/**\n * Tracked session information.\n */\nexport interface SessionInfo {\n  sessionId: string;\n  /** Friendly puppet name (e.g., \"Kermit\", \"Punch\") */\n  displayName: string;\n  /** Canonical hex color for this puppet character */\n  color: string;\n  pid: number;\n  startedAt: string;\n  lastHeartbeat: string;\n  status: 'active' | 'ended';\n  isLeader: boolean;\n}\n\n/**\n * Payload for POST /api/ingest/logs\n */\nexport interface IngestLogPayload {\n  sessionId: string;\n  entries: UnifiedLogEntry[];\n}\n\n/**\n * Payload for POST /api/ingest/metrics\n */\nexport interface IngestMetricsPayload {\n  sessionId: string;\n  snapshot: MetricSnapshot;\n}\n\n/**\n * Payload for POST /api/ingest/session\n */\nexport interface SessionEventPayload {\n  sessionId: string;\n  event: 'started' | 'stopped' | 'heartbeat';\n  pid: number;\n  startedAt: string;\n}\n\n/**\n * Callbacks provided by the unified console orchestrator for broadcasting\n * ingested events through the existing SSE infrastructure.\n */\nexport interface IngestBroadcasts {\n  logBroadcast: (entry: UnifiedLogEntry) => void;\n  metricsOnSnapshot?: (snapshot: MetricSnapshot) => void;\n  sessionBroadcast?: (event: SessionInfo) => void;\n}\n\n/**\n * Result of creating ingest routes.\n */\nexport interface IngestRoutesResult {\n  router: Router;\n  /** Get all tracked sessions */\n  getSessions: () => SessionInfo[];\n  /** Register the leader as a session */\n  registerLeaderSession: (sessionId: string, pid: number) => void;\n}\n\n/** Normalize a string via UnicodeValidator (DMCP-SEC-004) */\nfunction normalizeInput(s: string): string {\n  return UnicodeValidator.normalize(s).normalizedContent;\n}\n\n/**\n * Create the ingestion routes and session registry.\n *\n * @param broadcasts - Callbacks to forward ingested events to SSE clients\n * @returns Router and session management functions\n */\nexport function createIngestRoutes(broadcasts: IngestBroadcasts): IngestRoutesResult {\n  const router = Router();\n  const sessions = new Map<string, SessionInfo>();\n  const namePool = new SessionNamePool();\n  const rateLimiter = new SlidingWindowRateLimiter(RATE_LIMIT_MAX, RATE_LIMIT_WINDOW_MS);\n\n  // JSON body parsing with size limit\n  router.use(express.json({ limit: MAX_PAYLOAD_SIZE }));\n\n  /**\n   * POST /api/ingest/logs — Receive batched log entries from a follower.\n   */\n  router.post('/api/ingest/logs', (req: Request, res: Response) => {\n    if (!rateLimiter.tryAcquire()) {\n      res.status(429).json({ error: 'Rate limit exceeded' });\n      return;\n    }\n\n    const payload = req.body as IngestLogPayload;\n    if (!payload?.sessionId || !Array.isArray(payload.entries)) {\n      const received = payload ? Object.keys(payload) : [];\n      logger.warn('[IngestRoutes] Invalid log payload', { received, hasSessionId: !!payload?.sessionId, hasEntries: Array.isArray(payload?.entries) });\n      res.status(400).json({ error: 'Invalid payload', required: ['sessionId', 'entries'], received });\n      return;\n    }\n    payload.sessionId = normalizeInput(payload.sessionId);\n\n    let count = 0;\n    let skipped = 0;\n    for (const entry of payload.entries) {\n      if (!entry || typeof entry.message !== 'string') { skipped++; continue; }\n      const stamped: UnifiedLogEntry = {\n        ...entry,\n        data: { ...entry.data, _sessionId: payload.sessionId },\n      };\n      broadcasts.logBroadcast(stamped);\n      count++;\n    }\n\n    // Update session heartbeat\n    const session = sessions.get(payload.sessionId);\n    if (session) {\n      session.lastHeartbeat = new Date().toISOString();\n    }\n\n    if (skipped > 0) {\n      logger.debug(`[IngestRoutes] Log ingest from ${session?.displayName ?? payload.sessionId}: accepted=${count}, skipped=${skipped}`);\n    }\n\n    res.status(200).json({ accepted: count, skipped });\n  });\n\n  /**\n   * POST /api/ingest/metrics — Receive metric snapshots from a follower.\n   */\n  router.post('/api/ingest/metrics', (req: Request, res: Response) => {\n    if (!rateLimiter.tryAcquire()) {\n      res.status(429).json({ error: 'Rate limit exceeded' });\n      return;\n    }\n\n    const payload = req.body as IngestMetricsPayload;\n    if (!payload?.sessionId || !payload.snapshot) {\n      const received = payload ? Object.keys(payload) : [];\n      logger.warn('[IngestRoutes] Invalid metrics payload', { received });\n      res.status(400).json({ error: 'Invalid payload', required: ['sessionId', 'snapshot'], received });\n      return;\n    }\n    payload.sessionId = normalizeInput(payload.sessionId);\n\n    if (broadcasts.metricsOnSnapshot) {\n      broadcasts.metricsOnSnapshot(payload.snapshot);\n    }\n\n    const session = sessions.get(payload.sessionId);\n    logger.debug(`[IngestRoutes] Metrics ingested from ${session?.displayName ?? payload.sessionId}`);\n    res.status(200).json({ accepted: true });\n  });\n\n  /**\n   * POST /api/ingest/session — Session lifecycle events.\n   */\n  router.post('/api/ingest/session', (req: Request, res: Response) => {\n    const payload = req.body as SessionEventPayload;\n    if (!payload?.sessionId || !payload.event) {\n      const received = payload ? Object.keys(payload) : [];\n      logger.warn('[IngestRoutes] Invalid session event payload', { received });\n      res.status(400).json({ error: 'Invalid payload', required: ['sessionId', 'event'], received });\n      return;\n    }\n    payload.sessionId = normalizeInput(payload.sessionId);\n\n    const now = new Date().toISOString();\n\n    switch (payload.event) {\n      case 'started': {\n        const displayName = namePool.assign(payload.sessionId);\n        const color = namePool.getColor(payload.sessionId) ?? '#3b82f6';\n        const info: SessionInfo = {\n          sessionId: payload.sessionId,\n          displayName,\n          color,\n          pid: payload.pid,\n          startedAt: payload.startedAt || now,\n          lastHeartbeat: now,\n          status: 'active',\n          isLeader: false,\n        };\n        sessions.set(payload.sessionId, info);\n        logger.info('[IngestRoutes] Session registered', {\n          displayName, sessionId: payload.sessionId, pid: payload.pid, color,\n          activeSessions: Array.from(sessions.values()).filter(s => s.status === 'active').length,\n        });\n        broadcasts.sessionBroadcast?.(info);\n        break;\n      }\n      case 'stopped': {\n        const existing = sessions.get(payload.sessionId);\n        if (existing) {\n          existing.status = 'ended';\n          existing.lastHeartbeat = now;\n          namePool.release(payload.sessionId);\n          logger.info('[IngestRoutes] Session stopped', {\n            displayName: existing.displayName, sessionId: payload.sessionId, pid: existing.pid,\n            activeSessions: Array.from(sessions.values()).filter(s => s.status === 'active').length - 1,\n          });\n          broadcasts.sessionBroadcast?.(existing);\n        }\n        break;\n      }\n      case 'heartbeat': {\n        const existing = sessions.get(payload.sessionId);\n        if (existing) {\n          existing.lastHeartbeat = now;\n        }\n        break;\n      }\n    }\n\n    res.status(200).json({ ok: true });\n  });\n\n  /**\n   * GET /api/sessions — List all tracked sessions.\n   */\n  router.get('/api/sessions', (_req: Request, res: Response) => {\n    const allSessions = Array.from(sessions.values());\n    res.json({ sessions: allSessions });\n  });\n\n  /**\n   * POST /api/sessions/:sessionId/kill — Terminate a session's server process.\n   */\n  router.post('/api/sessions/:sessionId/kill', (req: Request, res: Response) => {\n    const sessionId = req.params['sessionId'] as string;\n    const session = sessions.get(sessionId);\n\n    if (!session) {\n      logger.warn('[IngestRoutes] Kill requested for unknown session', { sessionId });\n      res.status(404).json({ error: 'Session not found', sessionId });\n      return;\n    }\n\n    if (!session.pid) {\n      res.status(400).json({ error: 'No PID for session', sessionId, displayName: session.displayName });\n      return;\n    }\n\n    try {\n      process.kill(session.pid, 'SIGTERM');\n      session.status = 'ended';\n      namePool.release(sessionId);\n      logger.info('[IngestRoutes] Session killed', {\n        displayName: session.displayName, sessionId, pid: session.pid,\n        activeSessions: Array.from(sessions.values()).filter(s => s.status === 'active').length - 1,\n      });\n      res.json({ ok: true, killed: session.displayName, pid: session.pid });\n    } catch (err) {\n      const message = (err as Error).message;\n      logger.error('[IngestRoutes] Failed to kill session', {\n        displayName: session.displayName, sessionId, pid: session.pid, error: message,\n      });\n      res.status(500).json({ error: 'Failed to kill session', sessionId, displayName: session.displayName, pid: session.pid, detail: message });\n    }\n  });\n\n  // Reaper: periodically check for stale sessions whose heartbeat has expired\n  const reaperInterval = setInterval(() => {\n    const now = Date.now();\n    for (const [id, session] of sessions) {\n      if (session.status !== 'active') continue;\n      if (session.isLeader) continue; // leader manages itself\n      const age = now - new Date(session.lastHeartbeat).getTime();\n      if (age > SESSION_STALE_MS) {\n        session.status = 'ended';\n        namePool.release(id);\n        logger.info('[IngestRoutes] Reaped stale session', {\n          displayName: session.displayName, sessionId: id, pid: session.pid,\n          lastHeartbeatAgo: `${Math.round(age / 1000)}s`,\n          activeSessions: Array.from(sessions.values()).filter(s => s.status === 'active').length - 1,\n        });\n        broadcasts.sessionBroadcast?.(session);\n      }\n    }\n  }, REAPER_INTERVAL_MS);\n  reaperInterval.unref();\n\n  function getSessions(): SessionInfo[] {\n    return Array.from(sessions.values()).filter(s => s.status === 'active');\n  }\n\n  function registerLeaderSession(sessionId: string, pid: number): void {\n    const displayName = namePool.assign(sessionId, true);\n    const color = namePool.getColor(sessionId) ?? '#3b82f6';\n    sessions.set(sessionId, {\n      sessionId,\n      displayName,\n      color,\n      pid,\n      startedAt: new Date().toISOString(),\n      lastHeartbeat: new Date().toISOString(),\n      status: 'active',\n      isLeader: true,\n    });\n    logger.info('[IngestRoutes] Leader session registered', { displayName, sessionId, pid, color });\n  }\n\n  return { router, getSessions, registerLeaderSession };\n}\n"]}

package/dist/web/console/LeaderElection.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Leader election for the unified web console.
+ *
+ * When multiple MCP server instances run concurrently, only one should host
+ * the web console (the "leader"). Others become "followers" that forward
+ * events to the leader. This module handles:
+ *
+ * 1. Reading/writing a leader lock file at ~/.dollhouse/run/console-leader.lock
+ * 2. Atomic claim via temp+rename to prevent TOCTOU races
+ * 3. PID-based stale detection (signal-0 liveness check)
+ * 4. Heartbeat updates (10s interval) so followers can detect hung leaders
+ * 5. Cleanup on process exit
+ *
+ * The port 3939 binding is the ultimate tiebreaker: even if two processes
+ * both write the lock file, only one can bind the port.
+ *
+ * @since v2.1.0 — Issue #1700
+ */
+/**
+ * Information stored in the leader lock file.
+ */
+export interface ConsoleLeaderInfo {
+    version: number;
+    pid: number;
+    port: number;
+    sessionId: string;
+    startedAt: string;
+    heartbeat: string;
+}
+/**
+ * Result of a leader election attempt.
+ */
+export interface ElectionResult {
+    role: 'leader' | 'follower';
+    /** Leader info — for followers, this is the existing leader's info */
+    leaderInfo: ConsoleLeaderInfo;
+}
+/**
+ * Check whether a process with the given PID is alive.
+ * Uses signal 0 which checks existence without sending a signal.
+ */
+export declare function isProcessAlive(pid: number): boolean;
+/**
+ * Read and parse the leader lock file.
+ * Returns null if the file doesn't exist, is unreadable, or has invalid content.
+ */
+export declare function readLeaderLock(): Promise<ConsoleLeaderInfo | null>;
+/**
+ * Check if a leader lock is stale (dead process or expired heartbeat).
+ */
+export declare function isLockStale(info: ConsoleLeaderInfo): boolean;
+/**
+ * Attempt to atomically claim leadership.
+ *
+ * Writes to a temp file then renames to the lock path. On POSIX systems
+ * rename is atomic, so only one writer wins. After renaming, re-reads the
+ * lock to verify our PID won.
+ *
+ * @returns true if this process successfully claimed leadership
+ */
+export declare function claimLeadership(info: ConsoleLeaderInfo): Promise<boolean>;
+/**
+ * Delete the leader lock file (for cleanup or takeover).
+ */
+export declare function deleteLeaderLock(): Promise<void>;
+/**
+ * Run the leader election protocol.
+ *
+ * 1. If no lock exists or lock is stale → claim leadership
+ * 2. If lock exists with a live, responsive leader → become follower
+ *
+ * @param sessionId - This process's unique session identifier
+ * @param port - The port this process would use as leader (typically 3939)
+ * @returns Election result with role and leader info
+ */
+export declare function electLeader(sessionId: string, port: number): Promise<ElectionResult>;
+/**
+ * Start the leader heartbeat loop.
+ * Updates the lock file every HEARTBEAT_INTERVAL_MS so followers know the leader is alive.
+ *
+ * @returns A stop function to clear the interval
+ */
+export declare function startHeartbeat(info: ConsoleLeaderInfo): () => void;
+/**
+ * Register cleanup handlers to remove the leader lock on process exit.
+ * Should only be called by the leader.
+ */
+export declare function registerLeaderCleanup(): void;
+//# sourceMappingURL=LeaderElection.d.ts.map

package/dist/web/console/LeaderElection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LeaderElection.d.ts","sourceRoot":"","sources":["../../../src/web/console/LeaderElection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAuBH;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC5B,sEAAsE;IACtE,UAAU,EAAE,iBAAiB,CAAC;CAC/B;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOnD;AAED;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAWxE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAM5D;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC,CAe/E;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEtD;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAyD1F;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,IAAI,CAgBlE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAK5C"}

package/dist/web/console/LeaderElection.js

@@ -0,0 +1,205 @@
+/**
+ * Leader election for the unified web console.
+ *
+ * When multiple MCP server instances run concurrently, only one should host
+ * the web console (the "leader"). Others become "followers" that forward
+ * events to the leader. This module handles:
+ *
+ * 1. Reading/writing a leader lock file at ~/.dollhouse/run/console-leader.lock
+ * 2. Atomic claim via temp+rename to prevent TOCTOU races
+ * 3. PID-based stale detection (signal-0 liveness check)
+ * 4. Heartbeat updates (10s interval) so followers can detect hung leaders
+ * 5. Cleanup on process exit
+ *
+ * The port 3939 binding is the ultimate tiebreaker: even if two processes
+ * both write the lock file, only one can bind the port.
+ *
+ * @since v2.1.0 — Issue #1700
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdir, readFile, writeFile, rename, unlink } from 'node:fs/promises';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { logger } from '../../utils/logger.js';
+/** Directory for runtime state files */
+const RUN_DIR = join(homedir(), '.dollhouse', 'run');
+/** Path to the leader lock file */
+const LOCK_FILE = join(RUN_DIR, 'console-leader.lock');
+/** How often the leader updates its heartbeat (ms) */
+const HEARTBEAT_INTERVAL_MS = 10_000;
+/** How long before a heartbeat is considered stale (ms) */
+const HEARTBEAT_STALE_MS = 30_000;
+/** Current lock file schema version */
+const LOCK_VERSION = 1;
+/**
+ * Check whether a process with the given PID is alive.
+ * Uses signal 0 which checks existence without sending a signal.
+ */
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read and parse the leader lock file.
+ * Returns null if the file doesn't exist, is unreadable, or has invalid content.
+ */
+export async function readLeaderLock() {
+    try {
+        const content = await readFile(LOCK_FILE, 'utf-8');
+        const data = JSON.parse(content);
+        if (data.version !== LOCK_VERSION || !data.pid || !data.port || !data.sessionId) {
+            return null;
+        }
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a leader lock is stale (dead process or expired heartbeat).
+ */
+export function isLockStale(info) {
+    if (!isProcessAlive(info.pid)) {
+        return true;
+    }
+    const heartbeatAge = Date.now() - new Date(info.heartbeat).getTime();
+    return heartbeatAge > HEARTBEAT_STALE_MS;
+}
+/**
+ * Attempt to atomically claim leadership.
+ *
+ * Writes to a temp file then renames to the lock path. On POSIX systems
+ * rename is atomic, so only one writer wins. After renaming, re-reads the
+ * lock to verify our PID won.
+ *
+ * @returns true if this process successfully claimed leadership
+ */
+export async function claimLeadership(info) {
+    await mkdir(RUN_DIR, { recursive: true });
+    const tmpFile = join(RUN_DIR, `console-leader.lock.${process.pid}.tmp`);
+    try {
+        await writeFile(tmpFile, JSON.stringify(info, null, 2), 'utf-8');
+        await rename(tmpFile, LOCK_FILE);
+        // Verify we won the race
+        const written = await readLeaderLock();
+        return written !== null && written.pid === info.pid;
+    }
+    catch {
+        // Clean up temp file on failure
+        try {
+            await unlink(tmpFile);
+        }
+        catch { /* ignore */ }
+        return false;
+    }
+}
+/**
+ * Delete the leader lock file (for cleanup or takeover).
+ */
+export async function deleteLeaderLock() {
+    try {
+        await unlink(LOCK_FILE);
+    }
+    catch { /* already gone */ }
+}
+/**
+ * Run the leader election protocol.
+ *
+ * 1. If no lock exists or lock is stale → claim leadership
+ * 2. If lock exists with a live, responsive leader → become follower
+ *
+ * @param sessionId - This process's unique session identifier
+ * @param port - The port this process would use as leader (typically 3939)
+ * @returns Election result with role and leader info
+ */
+export async function electLeader(sessionId, port) {
+    sessionId = UnicodeValidator.normalize(sessionId).normalizedContent;
+    const existingLock = await readLeaderLock();
+    if (existingLock && !isLockStale(existingLock)) {
+        logger.info('[LeaderElection] Existing leader found — becoming follower', {
+            leaderSession: existingLock.sessionId, leaderPid: existingLock.pid,
+            leaderPort: existingLock.port, mySession: sessionId, myPid: process.pid,
+        });
+        return { role: 'follower', leaderInfo: existingLock };
+    }
+    // No valid leader — try to claim
+    if (existingLock) {
+        const alive = isProcessAlive(existingLock.pid);
+        const heartbeatAge = Date.now() - new Date(existingLock.heartbeat).getTime();
+        logger.info('[LeaderElection] Stale leader lock — taking over', {
+            stalePid: existingLock.pid, alive, heartbeatAgeMs: heartbeatAge,
+            staleSession: existingLock.sessionId, mySession: sessionId,
+        });
+        await deleteLeaderLock();
+    }
+    const now = new Date().toISOString();
+    const myInfo = {
+        version: LOCK_VERSION,
+        pid: process.pid,
+        port,
+        sessionId,
+        startedAt: now,
+        heartbeat: now,
+    };
+    const claimed = await claimLeadership(myInfo);
+    if (claimed) {
+        logger.info('[LeaderElection] Claimed leadership', { sessionId, port, pid: process.pid });
+        return { role: 'leader', leaderInfo: myInfo };
+    }
+    // Another process won the race — re-read and become follower
+    const winner = await readLeaderLock();
+    if (winner) {
+        logger.info('[LeaderElection] Lost election — becoming follower', {
+            winnerPid: winner.pid, winnerSession: winner.sessionId, mySession: sessionId, myPid: process.pid,
+        });
+        return { role: 'follower', leaderInfo: winner };
+    }
+    // Extremely unlikely: lock disappeared between our claim and re-read. Retry once.
+    logger.warn('[LeaderElection] Lock vanished after failed claim. Retrying.');
+    const retryInfo = { ...myInfo, heartbeat: new Date().toISOString() };
+    const retryClaimed = await claimLeadership(retryInfo);
+    if (retryClaimed) {
+        return { role: 'leader', leaderInfo: retryInfo };
+    }
+    const actualLeader = await readLeaderLock();
+    return { role: 'follower', leaderInfo: actualLeader ?? retryInfo };
+}
+/**
+ * Start the leader heartbeat loop.
+ * Updates the lock file every HEARTBEAT_INTERVAL_MS so followers know the leader is alive.
+ *
+ * @returns A stop function to clear the interval
+ */
+export function startHeartbeat(info) {
+    const interval = setInterval(async () => {
+        try {
+            const updated = { ...info, heartbeat: new Date().toISOString() };
+            const tmpFile = join(RUN_DIR, `console-leader.lock.${process.pid}.tmp`);
+            await writeFile(tmpFile, JSON.stringify(updated, null, 2), 'utf-8');
+            await rename(tmpFile, LOCK_FILE);
+        }
+        catch (err) {
+            logger.debug('[LeaderElection] Heartbeat write failed:', err);
+        }
+    }, HEARTBEAT_INTERVAL_MS);
+    // Don't let the heartbeat interval keep the process alive
+    interval.unref();
+    return () => clearInterval(interval);
+}
+/**
+ * Register cleanup handlers to remove the leader lock on process exit.
+ * Should only be called by the leader.
+ */
+export function registerLeaderCleanup() {
+    const cleanup = () => { deleteLeaderLock().catch(() => { }); };
+    process.once('exit', cleanup);
+    process.once('SIGTERM', cleanup);
+    process.once('SIGINT', cleanup);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LeaderElection.js","sourceRoot":"","sources":["../../../src/web/console/LeaderElection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACjF,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE/C,wCAAwC;AACxC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,YAAY,EAAE,KAAK,CAAC,CAAC;AAErD,mCAAmC;AACnC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,EAAE,qBAAqB,CAAC,CAAC;AAEvD,sDAAsD;AACtD,MAAM,qBAAqB,GAAG,MAAM,CAAC;AAErC,2DAA2D;AAC3D,MAAM,kBAAkB,GAAG,MAAM,CAAC;AAElC,uCAAuC;AACvC,MAAM,YAAY,GAAG,CAAC,CAAC;AAuBvB;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,GAAW;IACxC,IAAI,CAAC;QACH,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc;IAClC,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QACnD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAsB,CAAC;QACtD,IAAI,IAAI,CAAC,OAAO,KAAK,YAAY,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YAChF,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CAAC,IAAuB;IACjD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC;IACrE,OAAO,YAAY,GAAG,kBAAkB,CAAC;AAC3C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,IAAuB;IAC3D,MAAM,KAAK,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,uBAAuB,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC;IACxE,IAAI,CAAC;QACH,MAAM,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;QACjE,MAAM,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QAEjC,yBAAyB;QACzB,MAAM,OAAO,GAAG,MAAM,cAAc,EAAE,CAAC;QACvC,OAAO,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,GAAG,KAAK,IAAI,CAAC,GAAG,CAAC;IACtD,CAAC;IAAC,MAAM,CAAC;QACP,gCAAgC;QAChC,IAAI,CAAC;YAAC,MAAM,MAAM,CAAC,OAAO,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC;QACrD,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,IAAI,CAAC;QAAC,MAAM,MAAM,CAAC,SAAS,CAAC,CAAC;IAAC,CAAC;IAAC,MAAM,CAAC,CAAC,kBAAkB,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,SAAiB,EAAE,IAAY;IAC/D,SAAS,GAAG,gBAAgB,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,iBAAiB,CAAC;IACpE,MAAM,YAAY,GAAG,MAAM,cAAc,EAAE,CAAC;IAE5C,IAAI,YAAY,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,EAAE,CAAC;QAC/C,MAAM,CAAC,IAAI,CAAC,4DAA4D,EAAE;YACxE,aAAa,EAAE,YAAY,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,CAAC,GAAG;YAClE,UAAU,EAAE,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,GAAG;SACxE,CAAC,CAAC;QACH,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC;IACxD,CAAC;IAED,iCAAiC;IACjC,IAAI,YAAY,EAAE,CAAC;QACjB,MAAM,KAAK,GAAG,cAAc,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QAC/C,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC;QAC7E,MAAM,CAAC,IAAI,CAAC,kDAAkD,EAAE;YAC9D,QAAQ,EAAE,YAAY,CAAC,GAAG,EAAE,KAAK,EAAE,cAAc,EAAE,YAAY;YAC/D,YAAY,EAAE,YAAY,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS;SAC3D,CAAC,CAAC;QACH,MAAM,gBAAgB,EAAE,CAAC;IAC3B,CAAC;IAED,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACrC,MAAM,MAAM,GAAsB;QAChC,OAAO,EAAE,YAAY;QACrB,GAAG,EAAE,OAAO,CAAC,GAAG;QAChB,IAAI;QACJ,SAAS;QACT,SAAS,EAAE,GAAG;QACd,SAAS,EAAE,GAAG;KACf,CAAC;IAEF,MAAM,OAAO,GAAG,MAAM,eAAe,CAAC,MAAM,CAAC,CAAC;IAC9C,IAAI,OAAO,EAAE,CAAC;QACZ,MAAM,CAAC,IAAI,CAAC,qCAAqC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;QAC1F,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAChD,CAAC;IAED,6DAA6D;IAC7D,MAAM,MAAM,GAAG,MAAM,cAAc,EAAE,CAAC;IACtC,IAAI,MAAM,EAAE,CAAC;QACX,MAAM,CAAC,IAAI,CAAC,oDAAoD,EAAE;YAChE,SAAS,EAAE,MAAM,CAAC,GAAG,EAAE,aAAa,EAAE,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,GAAG;SACjG,CAAC,CAAC;QACH,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAClD,CAAC;IAED,kFAAkF;IAClF,MAAM,CAAC,IAAI,CAAC,8DAA8D,CAAC,CAAC;IAC5E,MAAM,SAAS,GAAsB,EAAE,GAAG,MAAM,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC;IACxF,MAAM,YAAY,GAAG,MAAM,eAAe,CAAC,SAAS,CAAC,CAAC;IACtD,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;IACnD,CAAC;IACD,MAAM,YAAY,GAAG,MAAM,cAAc,EAAE,CAAC;IAC5C,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,IAAI,SAAS,EAAE,CAAC;AACrE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,IAAuB;IACpD,MAAM,QAAQ,GAAG,WAAW,CAAC,KAAK,IAAI,EAAE;QACtC,IAAI,CAAC;YACH,MAAM,OAAO,GAAsB,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC;YACpF,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,uBAAuB,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC;YACxE,MAAM,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;YACpE,MAAM,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QACnC,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,CAAC,KAAK,CAAC,0CAA0C,EAAE,GAAG,CAAC,CAAC;QAChE,CAAC;IACH,CAAC,EAAE,qBAAqB,CAAC,CAAC;IAE1B,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,CAAC;IAEjB,OAAO,GAAG,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;AACvC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB;IACnC,MAAM,OAAO,GAAG,GAAG,EAAE,GAAG,gBAAgB,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9D,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IACjC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AAClC,CAAC","sourcesContent":["/**\n * Leader election for the unified web console.\n *\n * When multiple MCP server instances run concurrently, only one should host\n * the web console (the \"leader\"). Others become \"followers\" that forward\n * events to the leader. This module handles:\n *\n * 1. Reading/writing a leader lock file at ~/.dollhouse/run/console-leader.lock\n * 2. Atomic claim via temp+rename to prevent TOCTOU races\n * 3. PID-based stale detection (signal-0 liveness check)\n * 4. Heartbeat updates (10s interval) so followers can detect hung leaders\n * 5. Cleanup on process exit\n *\n * The port 3939 binding is the ultimate tiebreaker: even if two processes\n * both write the lock file, only one can bind the port.\n *\n * @since v2.1.0 — Issue #1700\n */\n\nimport { homedir } from 'node:os';\nimport { join } from 'node:path';\nimport { mkdir, readFile, writeFile, rename, unlink } from 'node:fs/promises';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { logger } from '../../utils/logger.js';\n\n/** Directory for runtime state files */\nconst RUN_DIR = join(homedir(), '.dollhouse', 'run');\n\n/** Path to the leader lock file */\nconst LOCK_FILE = join(RUN_DIR, 'console-leader.lock');\n\n/** How often the leader updates its heartbeat (ms) */\nconst HEARTBEAT_INTERVAL_MS = 10_000;\n\n/** How long before a heartbeat is considered stale (ms) */\nconst HEARTBEAT_STALE_MS = 30_000;\n\n/** Current lock file schema version */\nconst LOCK_VERSION = 1;\n\n/**\n * Information stored in the leader lock file.\n */\nexport interface ConsoleLeaderInfo {\n  version: number;\n  pid: number;\n  port: number;\n  sessionId: string;\n  startedAt: string;\n  heartbeat: string;\n}\n\n/**\n * Result of a leader election attempt.\n */\nexport interface ElectionResult {\n  role: 'leader' | 'follower';\n  /** Leader info — for followers, this is the existing leader's info */\n  leaderInfo: ConsoleLeaderInfo;\n}\n\n/**\n * Check whether a process with the given PID is alive.\n * Uses signal 0 which checks existence without sending a signal.\n */\nexport function isProcessAlive(pid: number): boolean {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Read and parse the leader lock file.\n * Returns null if the file doesn't exist, is unreadable, or has invalid content.\n */\nexport async function readLeaderLock(): Promise<ConsoleLeaderInfo | null> {\n  try {\n    const content = await readFile(LOCK_FILE, 'utf-8');\n    const data = JSON.parse(content) as ConsoleLeaderInfo;\n    if (data.version !== LOCK_VERSION || !data.pid || !data.port || !data.sessionId) {\n      return null;\n    }\n    return data;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Check if a leader lock is stale (dead process or expired heartbeat).\n */\nexport function isLockStale(info: ConsoleLeaderInfo): boolean {\n  if (!isProcessAlive(info.pid)) {\n    return true;\n  }\n  const heartbeatAge = Date.now() - new Date(info.heartbeat).getTime();\n  return heartbeatAge > HEARTBEAT_STALE_MS;\n}\n\n/**\n * Attempt to atomically claim leadership.\n *\n * Writes to a temp file then renames to the lock path. On POSIX systems\n * rename is atomic, so only one writer wins. After renaming, re-reads the\n * lock to verify our PID won.\n *\n * @returns true if this process successfully claimed leadership\n */\nexport async function claimLeadership(info: ConsoleLeaderInfo): Promise<boolean> {\n  await mkdir(RUN_DIR, { recursive: true });\n  const tmpFile = join(RUN_DIR, `console-leader.lock.${process.pid}.tmp`);\n  try {\n    await writeFile(tmpFile, JSON.stringify(info, null, 2), 'utf-8');\n    await rename(tmpFile, LOCK_FILE);\n\n    // Verify we won the race\n    const written = await readLeaderLock();\n    return written !== null && written.pid === info.pid;\n  } catch {\n    // Clean up temp file on failure\n    try { await unlink(tmpFile); } catch { /* ignore */ }\n    return false;\n  }\n}\n\n/**\n * Delete the leader lock file (for cleanup or takeover).\n */\nexport async function deleteLeaderLock(): Promise<void> {\n  try { await unlink(LOCK_FILE); } catch { /* already gone */ }\n}\n\n/**\n * Run the leader election protocol.\n *\n * 1. If no lock exists or lock is stale → claim leadership\n * 2. If lock exists with a live, responsive leader → become follower\n *\n * @param sessionId - This process's unique session identifier\n * @param port - The port this process would use as leader (typically 3939)\n * @returns Election result with role and leader info\n */\nexport async function electLeader(sessionId: string, port: number): Promise<ElectionResult> {\n  sessionId = UnicodeValidator.normalize(sessionId).normalizedContent;\n  const existingLock = await readLeaderLock();\n\n  if (existingLock && !isLockStale(existingLock)) {\n    logger.info('[LeaderElection] Existing leader found — becoming follower', {\n      leaderSession: existingLock.sessionId, leaderPid: existingLock.pid,\n      leaderPort: existingLock.port, mySession: sessionId, myPid: process.pid,\n    });\n    return { role: 'follower', leaderInfo: existingLock };\n  }\n\n  // No valid leader — try to claim\n  if (existingLock) {\n    const alive = isProcessAlive(existingLock.pid);\n    const heartbeatAge = Date.now() - new Date(existingLock.heartbeat).getTime();\n    logger.info('[LeaderElection] Stale leader lock — taking over', {\n      stalePid: existingLock.pid, alive, heartbeatAgeMs: heartbeatAge,\n      staleSession: existingLock.sessionId, mySession: sessionId,\n    });\n    await deleteLeaderLock();\n  }\n\n  const now = new Date().toISOString();\n  const myInfo: ConsoleLeaderInfo = {\n    version: LOCK_VERSION,\n    pid: process.pid,\n    port,\n    sessionId,\n    startedAt: now,\n    heartbeat: now,\n  };\n\n  const claimed = await claimLeadership(myInfo);\n  if (claimed) {\n    logger.info('[LeaderElection] Claimed leadership', { sessionId, port, pid: process.pid });\n    return { role: 'leader', leaderInfo: myInfo };\n  }\n\n  // Another process won the race — re-read and become follower\n  const winner = await readLeaderLock();\n  if (winner) {\n    logger.info('[LeaderElection] Lost election — becoming follower', {\n      winnerPid: winner.pid, winnerSession: winner.sessionId, mySession: sessionId, myPid: process.pid,\n    });\n    return { role: 'follower', leaderInfo: winner };\n  }\n\n  // Extremely unlikely: lock disappeared between our claim and re-read. Retry once.\n  logger.warn('[LeaderElection] Lock vanished after failed claim. Retrying.');\n  const retryInfo: ConsoleLeaderInfo = { ...myInfo, heartbeat: new Date().toISOString() };\n  const retryClaimed = await claimLeadership(retryInfo);\n  if (retryClaimed) {\n    return { role: 'leader', leaderInfo: retryInfo };\n  }\n  const actualLeader = await readLeaderLock();\n  return { role: 'follower', leaderInfo: actualLeader ?? retryInfo };\n}\n\n/**\n * Start the leader heartbeat loop.\n * Updates the lock file every HEARTBEAT_INTERVAL_MS so followers know the leader is alive.\n *\n * @returns A stop function to clear the interval\n */\nexport function startHeartbeat(info: ConsoleLeaderInfo): () => void {\n  const interval = setInterval(async () => {\n    try {\n      const updated: ConsoleLeaderInfo = { ...info, heartbeat: new Date().toISOString() };\n      const tmpFile = join(RUN_DIR, `console-leader.lock.${process.pid}.tmp`);\n      await writeFile(tmpFile, JSON.stringify(updated, null, 2), 'utf-8');\n      await rename(tmpFile, LOCK_FILE);\n    } catch (err) {\n      logger.debug('[LeaderElection] Heartbeat write failed:', err);\n    }\n  }, HEARTBEAT_INTERVAL_MS);\n\n  // Don't let the heartbeat interval keep the process alive\n  interval.unref();\n\n  return () => clearInterval(interval);\n}\n\n/**\n * Register cleanup handlers to remove the leader lock on process exit.\n * Should only be called by the leader.\n */\nexport function registerLeaderCleanup(): void {\n  const cleanup = () => { deleteLeaderLock().catch(() => {}); };\n  process.once('exit', cleanup);\n  process.once('SIGTERM', cleanup);\n  process.once('SIGINT', cleanup);\n}\n"]}