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

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

@@ -0,0 +1,61 @@
+/**
+ * Forwarding sinks for follower MCP servers.
+ *
+ * When a server becomes a follower in the unified console election, it
+ * registers these sinks with its LogManager and MetricsManager. Instead
+ * of broadcasting to local SSE clients, entries are batch-POSTed to
+ * the leader's ingestion endpoints.
+ *
+ * Features:
+ * - Batch buffering (50 entries or 1s flush, whichever comes first)
+ * - In-memory buffer up to 10,000 entries on leader failure
+ * - Exponential backoff on POST failure (1s → 2s → 4s, max 30s)
+ * - Automatic drain on leader recovery
+ *
+ * @since v2.1.0 — Issue #1700
+ */
+import type { ILogSink, UnifiedLogEntry } from '../../logging/types.js';
+import type { MetricSnapshot } from '../../metrics/types.js';
+/**
+ * ILogSink that batch-POSTs entries to the leader's /api/ingest/logs.
+ */
+export declare class LeaderForwardingLogSink implements ILogSink {
+    private readonly leaderUrl;
+    private readonly sessionId;
+    private readonly buffer;
+    private flushTimer;
+    private backoffMs;
+    private flushing;
+    constructor(leaderUrl: string, sessionId: string);
+    write(entry: UnifiedLogEntry): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    private flushBuffer;
+    private requeueBatch;
+    private scheduleRetry;
+}
+/**
+ * Forwards metric snapshots to the leader's /api/ingest/metrics.
+ */
+export declare class LeaderForwardingMetricsSink {
+    private readonly leaderUrl;
+    private readonly sessionId;
+    constructor(leaderUrl: string, sessionId: string);
+    onSnapshot(snapshot: MetricSnapshot): Promise<void>;
+}
+/**
+ * Sends session lifecycle events to the leader.
+ */
+export declare class SessionHeartbeat {
+    private readonly leaderUrl;
+    private readonly sessionId;
+    private readonly pid;
+    private heartbeatTimer;
+    constructor(leaderUrl: string, sessionId: string, pid: number);
+    /** Notify the leader that this session has started */
+    start(): Promise<void>;
+    /** Notify the leader that this session is stopping */
+    stop(): Promise<void>;
+    private sendEvent;
+}
+//# sourceMappingURL=LeaderForwardingSink.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LeaderForwardingSink.d.ts","sourceRoot":"","sources":["../../../src/web/console/LeaderForwardingSink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAsB7D;;GAEG;AACH,qBAAa,uBAAwB,YAAW,QAAQ;IAOpD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAP5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyB;IAChD,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,QAAQ,CAAS;gBAGN,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM;IAOpC,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAkB7B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAQd,WAAW;IA+BzB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,aAAa;CAItB;AAED;;GAEG;AACH,qBAAa,2BAA2B;IAEpC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;gBADT,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM;IAG9B,UAAU,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAgB1D;AAED;;GAEG;AACH,qBAAa,gBAAgB;IAIzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,GAAG;IALtB,OAAO,CAAC,cAAc,CAA+C;gBAGlD,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM;IAG9B,sDAAsD;IAChD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B,sDAAsD;IAChD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YAQb,SAAS;CAqBxB"}

package/dist/web/console/LeaderForwardingSink.js

@@ -0,0 +1,197 @@
+/**
+ * Forwarding sinks for follower MCP servers.
+ *
+ * When a server becomes a follower in the unified console election, it
+ * registers these sinks with its LogManager and MetricsManager. Instead
+ * of broadcasting to local SSE clients, entries are batch-POSTed to
+ * the leader's ingestion endpoints.
+ *
+ * Features:
+ * - Batch buffering (50 entries or 1s flush, whichever comes first)
+ * - In-memory buffer up to 10,000 entries on leader failure
+ * - Exponential backoff on POST failure (1s → 2s → 4s, max 30s)
+ * - Automatic drain on leader recovery
+ *
+ * @since v2.1.0 — Issue #1700
+ */
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { logger } from '../../utils/logger.js';
+/** Maximum entries to buffer when leader is unreachable */
+const MAX_BUFFER_SIZE = 10_000;
+/** Batch size before flushing */
+const BATCH_SIZE = 50;
+/** Time-based flush interval (ms) */
+const FLUSH_INTERVAL_MS = 1_000;
+/** Initial backoff delay on failure (ms) */
+const INITIAL_BACKOFF_MS = 1_000;
+/** Maximum backoff delay (ms) */
+const MAX_BACKOFF_MS = 30_000;
+/** HTTP request timeout (ms) */
+const REQUEST_TIMEOUT_MS = 5_000;
+/**
+ * ILogSink that batch-POSTs entries to the leader's /api/ingest/logs.
+ */
+export class LeaderForwardingLogSink {
+    leaderUrl;
+    sessionId;
+    buffer = [];
+    flushTimer = null;
+    backoffMs = INITIAL_BACKOFF_MS;
+    flushing = false;
+    constructor(leaderUrl, sessionId) {
+        this.leaderUrl = leaderUrl;
+        this.sessionId = sessionId;
+        this.sessionId = UnicodeValidator.normalize(sessionId).normalizedContent;
+        this.flushTimer = setInterval(() => this.flushBuffer(), FLUSH_INTERVAL_MS);
+        this.flushTimer.unref();
+    }
+    write(entry) {
+        // Stamp session ID before buffering
+        const stamped = {
+            ...entry,
+            data: { ...entry.data, _sessionId: this.sessionId },
+        };
+        if (this.buffer.length >= MAX_BUFFER_SIZE) {
+            // Evict oldest entry (FIFO)
+            this.buffer.shift();
+        }
+        this.buffer.push(stamped);
+        if (this.buffer.length >= BATCH_SIZE) {
+            this.flushBuffer();
+        }
+    }
+    async flush() {
+        await this.flushBuffer();
+    }
+    async close() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.flushBuffer();
+    }
+    async flushBuffer() {
+        if (this.flushing || this.buffer.length === 0)
+            return;
+        this.flushing = true;
+        const batch = this.buffer.splice(0, BATCH_SIZE);
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+            const response = await fetch(`${this.leaderUrl}/api/ingest/logs`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ sessionId: this.sessionId, entries: batch }),
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            if (response.ok) {
+                this.backoffMs = INITIAL_BACKOFF_MS;
+            }
+            else {
+                this.requeueBatch(batch);
+                this.scheduleRetry();
+            }
+        }
+        catch {
+            this.requeueBatch(batch);
+            this.scheduleRetry();
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+    requeueBatch(batch) {
+        const spaceAvailable = MAX_BUFFER_SIZE - this.buffer.length;
+        if (spaceAvailable > 0) {
+            const toRequeue = batch.slice(0, spaceAvailable);
+            this.buffer.unshift(...toRequeue);
+        }
+        else {
+            logger.warn(`[ForwardingSink] Buffer full (${MAX_BUFFER_SIZE}), dropping ${batch.length} entries`);
+        }
+    }
+    scheduleRetry() {
+        logger.debug(`[ForwardingSink] Leader unreachable, backoff ${this.backoffMs}ms (buffered: ${this.buffer.length})`);
+        this.backoffMs = Math.min(this.backoffMs * 2, MAX_BACKOFF_MS);
+    }
+}
+/**
+ * Forwards metric snapshots to the leader's /api/ingest/metrics.
+ */
+export class LeaderForwardingMetricsSink {
+    leaderUrl;
+    sessionId;
+    constructor(leaderUrl, sessionId) {
+        this.leaderUrl = leaderUrl;
+        this.sessionId = sessionId;
+    }
+    async onSnapshot(snapshot) {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+            await fetch(`${this.leaderUrl}/api/ingest/metrics`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ sessionId: this.sessionId, snapshot }),
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+        }
+        catch {
+            logger.debug('[ForwardingSink] Failed to forward metrics snapshot');
+        }
+    }
+}
+/**
+ * Sends session lifecycle events to the leader.
+ */
+export class SessionHeartbeat {
+    leaderUrl;
+    sessionId;
+    pid;
+    heartbeatTimer = null;
+    constructor(leaderUrl, sessionId, pid) {
+        this.leaderUrl = leaderUrl;
+        this.sessionId = sessionId;
+        this.pid = pid;
+    }
+    /** Notify the leader that this session has started */
+    async start() {
+        await this.sendEvent('started');
+        this.heartbeatTimer = setInterval(() => {
+            this.sendEvent('heartbeat').catch(() => { });
+        }, 10_000);
+        this.heartbeatTimer.unref();
+    }
+    /** Notify the leader that this session is stopping */
+    async stop() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        await this.sendEvent('stopped');
+    }
+    async sendEvent(event) {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+            await fetch(`${this.leaderUrl}/api/ingest/session`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    sessionId: this.sessionId,
+                    event,
+                    pid: this.pid,
+                    startedAt: new Date().toISOString(),
+                }),
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+        }
+        catch {
+            logger.debug(`[SessionHeartbeat] Failed to send ${event} event`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LeaderForwardingSink.js","sourceRoot":"","sources":["../../../src/web/console/LeaderForwardingSink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACjF,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE/C,2DAA2D;AAC3D,MAAM,eAAe,GAAG,MAAM,CAAC;AAE/B,iCAAiC;AACjC,MAAM,UAAU,GAAG,EAAE,CAAC;AAEtB,qCAAqC;AACrC,MAAM,iBAAiB,GAAG,KAAK,CAAC;AAEhC,4CAA4C;AAC5C,MAAM,kBAAkB,GAAG,KAAK,CAAC;AAEjC,iCAAiC;AACjC,MAAM,cAAc,GAAG,MAAM,CAAC;AAE9B,gCAAgC;AAChC,MAAM,kBAAkB,GAAG,KAAK,CAAC;AAEjC;;GAEG;AACH,MAAM,OAAO,uBAAuB;IAOf;IACA;IAPF,MAAM,GAAsB,EAAE,CAAC;IACxC,UAAU,GAA0C,IAAI,CAAC;IACzD,SAAS,GAAG,kBAAkB,CAAC;IAC/B,QAAQ,GAAG,KAAK,CAAC;IAEzB,YACmB,SAAiB,EACjB,SAAiB;QADjB,cAAS,GAAT,SAAS,CAAQ;QACjB,cAAS,GAAT,SAAS,CAAQ;QAElC,IAAI,CAAC,SAAS,GAAG,gBAAgB,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,iBAAiB,CAAC;QACzE,IAAI,CAAC,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,iBAAiB,CAAC,CAAC;QAC3E,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;IAC1B,CAAC;IAED,KAAK,CAAC,KAAsB;QAC1B,oCAAoC;QACpC,MAAM,OAAO,GAAoB;YAC/B,GAAG,KAAK;YACR,IAAI,EAAE,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,SAAS,EAAE;SACpD,CAAC;QAEF,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,eAAe,EAAE,CAAC;YAC1C,4BAA4B;YAC5B,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACtB,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE1B,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,UAAU,EAAE,CAAC;YACrC,IAAI,CAAC,WAAW,EAAE,CAAC;QACrB,CAAC;IACH,CAAC;IAED,KAAK,CAAC,KAAK;QACT,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;IAC3B,CAAC;IAED,KAAK,CAAC,KAAK;QACT,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC/B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACzB,CAAC;QACD,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;IAC3B,CAAC;IAEO,KAAK,CAAC,WAAW;QACvB,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QACtD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QAErB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;QAChD,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;YACzC,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,kBAAkB,CAAC,CAAC;YAEzE,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,kBAAkB,EAAE;gBAChE,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;gBACnE,MAAM,EAAE,UAAU,CAAC,MAAM;aAC1B,CAAC,CAAC;YACH,YAAY,CAAC,OAAO,CAAC,CAAC;YAEtB,IAAI,QAAQ,CAAC,EAAE,EAAE,CAAC;gBAChB,IAAI,CAAC,SAAS,GAAG,kBAAkB,CAAC;YACtC,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;gBACzB,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;YACzB,IAAI,CAAC,aAAa,EAAE,CAAC;QACvB,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACxB,CAAC;IACH,CAAC;IAEO,YAAY,CAAC,KAAwB;QAC3C,MAAM,cAAc,GAAG,eAAe,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;QAC5D,IAAI,cAAc,GAAG,CAAC,EAAE,CAAC;YACvB,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;YACjD,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,CAAC;QACpC,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,IAAI,CAAC,iCAAiC,eAAe,eAAe,KAAK,CAAC,MAAM,UAAU,CAAC,CAAC;QACrG,CAAC;IACH,CAAC;IAEO,aAAa;QACnB,MAAM,CAAC,KAAK,CAAC,gDAAgD,IAAI,CAAC,SAAS,iBAAiB,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;QACnH,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,EAAE,cAAc,CAAC,CAAC;IAChE,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,2BAA2B;IAEnB;IACA;IAFnB,YACmB,SAAiB,EACjB,SAAiB;QADjB,cAAS,GAAT,SAAS,CAAQ;QACjB,cAAS,GAAT,SAAS,CAAQ;IACjC,CAAC;IAEJ,KAAK,CAAC,UAAU,CAAC,QAAwB;QACvC,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;YACzC,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,kBAAkB,CAAC,CAAC;YAEzE,MAAM,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,qBAAqB,EAAE;gBAClD,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,QAAQ,EAAE,CAAC;gBAC7D,MAAM,EAAE,UAAU,CAAC,MAAM;aAC1B,CAAC,CAAC;YACH,YAAY,CAAC,OAAO,CAAC,CAAC;QACxB,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,CAAC,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACtE,CAAC;IACH,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,gBAAgB;IAIR;IACA;IACA;IALX,cAAc,GAA0C,IAAI,CAAC;IAErE,YACmB,SAAiB,EACjB,SAAiB,EACjB,GAAW;QAFX,cAAS,GAAT,SAAS,CAAQ;QACjB,cAAS,GAAT,SAAS,CAAQ;QACjB,QAAG,GAAH,GAAG,CAAQ;IAC3B,CAAC;IAEJ,sDAAsD;IACtD,KAAK,CAAC,KAAK;QACT,MAAM,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QAEhC,IAAI,CAAC,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE;YACrC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QAC9C,CAAC,EAAE,MAAM,CAAC,CAAC;QACX,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;IAED,sDAAsD;IACtD,KAAK,CAAC,IAAI;QACR,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,aAAa,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YACnC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC7B,CAAC;QACD,MAAM,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IAClC,CAAC;IAEO,KAAK,CAAC,SAAS,CAAC,KAA0C;QAChE,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;YACzC,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,kBAAkB,CAAC,CAAC;YAEzE,MAAM,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,qBAAqB,EAAE;gBAClD,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;oBACnB,SAAS,EAAE,IAAI,CAAC,SAAS;oBACzB,KAAK;oBACL,GAAG,EAAE,IAAI,CAAC,GAAG;oBACb,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;iBACpC,CAAC;gBACF,MAAM,EAAE,UAAU,CAAC,MAAM;aAC1B,CAAC,CAAC;YACH,YAAY,CAAC,OAAO,CAAC,CAAC;QACxB,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,CAAC,KAAK,CAAC,qCAAqC,KAAK,QAAQ,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;CACF","sourcesContent":["/**\n * Forwarding sinks for follower MCP servers.\n *\n * When a server becomes a follower in the unified console election, it\n * registers these sinks with its LogManager and MetricsManager. Instead\n * of broadcasting to local SSE clients, entries are batch-POSTed to\n * the leader's ingestion endpoints.\n *\n * Features:\n * - Batch buffering (50 entries or 1s flush, whichever comes first)\n * - In-memory buffer up to 10,000 entries on leader failure\n * - Exponential backoff on POST failure (1s → 2s → 4s, max 30s)\n * - Automatic drain on leader recovery\n *\n * @since v2.1.0 — Issue #1700\n */\n\nimport type { ILogSink, UnifiedLogEntry } from '../../logging/types.js';\nimport type { MetricSnapshot } from '../../metrics/types.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { logger } from '../../utils/logger.js';\n\n/** Maximum entries to buffer when leader is unreachable */\nconst MAX_BUFFER_SIZE = 10_000;\n\n/** Batch size before flushing */\nconst BATCH_SIZE = 50;\n\n/** Time-based flush interval (ms) */\nconst FLUSH_INTERVAL_MS = 1_000;\n\n/** Initial backoff delay on failure (ms) */\nconst INITIAL_BACKOFF_MS = 1_000;\n\n/** Maximum backoff delay (ms) */\nconst MAX_BACKOFF_MS = 30_000;\n\n/** HTTP request timeout (ms) */\nconst REQUEST_TIMEOUT_MS = 5_000;\n\n/**\n * ILogSink that batch-POSTs entries to the leader's /api/ingest/logs.\n */\nexport class LeaderForwardingLogSink implements ILogSink {\n  private readonly buffer: UnifiedLogEntry[] = [];\n  private flushTimer: ReturnType<typeof setInterval> | null = null;\n  private backoffMs = INITIAL_BACKOFF_MS;\n  private flushing = false;\n\n  constructor(\n    private readonly leaderUrl: string,\n    private readonly sessionId: string,\n  ) {\n    this.sessionId = UnicodeValidator.normalize(sessionId).normalizedContent;\n    this.flushTimer = setInterval(() => this.flushBuffer(), FLUSH_INTERVAL_MS);\n    this.flushTimer.unref();\n  }\n\n  write(entry: UnifiedLogEntry): void {\n    // Stamp session ID before buffering\n    const stamped: UnifiedLogEntry = {\n      ...entry,\n      data: { ...entry.data, _sessionId: this.sessionId },\n    };\n\n    if (this.buffer.length >= MAX_BUFFER_SIZE) {\n      // Evict oldest entry (FIFO)\n      this.buffer.shift();\n    }\n    this.buffer.push(stamped);\n\n    if (this.buffer.length >= BATCH_SIZE) {\n      this.flushBuffer();\n    }\n  }\n\n  async flush(): Promise<void> {\n    await this.flushBuffer();\n  }\n\n  async close(): Promise<void> {\n    if (this.flushTimer) {\n      clearInterval(this.flushTimer);\n      this.flushTimer = null;\n    }\n    await this.flushBuffer();\n  }\n\n  private async flushBuffer(): Promise<void> {\n    if (this.flushing || this.buffer.length === 0) return;\n    this.flushing = true;\n\n    const batch = this.buffer.splice(0, BATCH_SIZE);\n    try {\n      const controller = new AbortController();\n      const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);\n\n      const response = await fetch(`${this.leaderUrl}/api/ingest/logs`, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ sessionId: this.sessionId, entries: batch }),\n        signal: controller.signal,\n      });\n      clearTimeout(timeout);\n\n      if (response.ok) {\n        this.backoffMs = INITIAL_BACKOFF_MS;\n      } else {\n        this.requeueBatch(batch);\n        this.scheduleRetry();\n      }\n    } catch {\n      this.requeueBatch(batch);\n      this.scheduleRetry();\n    } finally {\n      this.flushing = false;\n    }\n  }\n\n  private requeueBatch(batch: UnifiedLogEntry[]): void {\n    const spaceAvailable = MAX_BUFFER_SIZE - this.buffer.length;\n    if (spaceAvailable > 0) {\n      const toRequeue = batch.slice(0, spaceAvailable);\n      this.buffer.unshift(...toRequeue);\n    } else {\n      logger.warn(`[ForwardingSink] Buffer full (${MAX_BUFFER_SIZE}), dropping ${batch.length} entries`);\n    }\n  }\n\n  private scheduleRetry(): void {\n    logger.debug(`[ForwardingSink] Leader unreachable, backoff ${this.backoffMs}ms (buffered: ${this.buffer.length})`);\n    this.backoffMs = Math.min(this.backoffMs * 2, MAX_BACKOFF_MS);\n  }\n}\n\n/**\n * Forwards metric snapshots to the leader's /api/ingest/metrics.\n */\nexport class LeaderForwardingMetricsSink {\n  constructor(\n    private readonly leaderUrl: string,\n    private readonly sessionId: string,\n  ) {}\n\n  async onSnapshot(snapshot: MetricSnapshot): Promise<void> {\n    try {\n      const controller = new AbortController();\n      const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);\n\n      await fetch(`${this.leaderUrl}/api/ingest/metrics`, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ sessionId: this.sessionId, snapshot }),\n        signal: controller.signal,\n      });\n      clearTimeout(timeout);\n    } catch {\n      logger.debug('[ForwardingSink] Failed to forward metrics snapshot');\n    }\n  }\n}\n\n/**\n * Sends session lifecycle events to the leader.\n */\nexport class SessionHeartbeat {\n  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;\n\n  constructor(\n    private readonly leaderUrl: string,\n    private readonly sessionId: string,\n    private readonly pid: number,\n  ) {}\n\n  /** Notify the leader that this session has started */\n  async start(): Promise<void> {\n    await this.sendEvent('started');\n\n    this.heartbeatTimer = setInterval(() => {\n      this.sendEvent('heartbeat').catch(() => {});\n    }, 10_000);\n    this.heartbeatTimer.unref();\n  }\n\n  /** Notify the leader that this session is stopping */\n  async stop(): Promise<void> {\n    if (this.heartbeatTimer) {\n      clearInterval(this.heartbeatTimer);\n      this.heartbeatTimer = null;\n    }\n    await this.sendEvent('stopped');\n  }\n\n  private async sendEvent(event: 'started' | 'stopped' | 'heartbeat'): Promise<void> {\n    try {\n      const controller = new AbortController();\n      const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);\n\n      await fetch(`${this.leaderUrl}/api/ingest/session`, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({\n          sessionId: this.sessionId,\n          event,\n          pid: this.pid,\n          startedAt: new Date().toISOString(),\n        }),\n        signal: controller.signal,\n      });\n      clearTimeout(timeout);\n    } catch {\n      logger.debug(`[SessionHeartbeat] Failed to send ${event} event`);\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,46 @@
+/**
+ * Friendly session names drawn from famous puppets, marionettes,
+ * and puppet characters throughout history.
+ *
+ * Names are assigned from a pool and returned after a cooldown period
+ * when sessions end. This keeps the active session list human-readable
+ * and on-brand for DollhouseMCP.
+ *
+ * @since v2.1.0 — Issue #1700
+ */
+/**
+ * Manages friendly session name assignment from the puppet name pool.
+ */
+export declare class SessionNamePool {
+    /** Names currently assigned to active sessions: sessionId → name */
+    private readonly assigned;
+    /** Reverse lookup: name → sessionId */
+    private readonly nameToSession;
+    /** Names in cooldown after session end */
+    private cooldown;
+    /**
+     * Assign a friendly name to a session.
+     * Returns an existing assignment if the session already has one.
+     *
+     * @param isLeader - If true, follower-only names (e.g., Punch) are excluded
+     */
+    assign(sessionId: string, isLeader?: boolean): string;
+    /**
+     * Release a name back to the pool with a cooldown period.
+     */
+    release(sessionId: string): void;
+    /**
+     * Get the friendly name for a session, or undefined if not assigned.
+     */
+    getName(sessionId: string): string | undefined;
+    /**
+     * Get the canonical color for an assigned session name.
+     */
+    getColor(sessionId: string): string | undefined;
+    /**
+     * Get all current assignments.
+     */
+    getAll(): Map<string, string>;
+    private flushCooldowns;
+}
+//# sourceMappingURL=SessionNames.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SessionNames.d.ts","sourceRoot":"","sources":["../../../src/web/console/SessionNames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAyLH;;GAEG;AACH,qBAAa,eAAe;IAC1B,oEAAoE;IACpE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,uCAAuC;IACvC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAC3D,0CAA0C;IAC1C,OAAO,CAAC,QAAQ,CAAuB;IAEvC;;;;;OAKG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,UAAQ,GAAG,MAAM;IAuCnD;;OAEG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAehC;;OAEG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI9C;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAK/C;;OAEG;IACH,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAI7B,OAAO,CAAC,cAAc;CAIvB"}

package/dist/web/console/SessionNames.js

@@ -0,0 +1,257 @@
+/**
+ * Friendly session names drawn from famous puppets, marionettes,
+ * and puppet characters throughout history.
+ *
+ * Names are assigned from a pool and returned after a cooldown period
+ * when sessions end. This keeps the active session list human-readable
+ * and on-brand for DollhouseMCP.
+ *
+ * @since v2.1.0 — Issue #1700
+ */
+import { randomInt } from 'node:crypto';
+import { logger } from '../../utils/logger.js';
+/**
+ * Famous puppets, marionettes, and puppet characters from around the world.
+ * Order doesn't matter — the pool is shuffled on startup.
+ */
+const ALL_PUPPET_NAMES = [
+    // Classic & traditional
+    'Punch',
+    'Judy',
+    'Pinocchio',
+    'Petrouchka',
+    'Pulcinella',
+    'Guignol',
+    'Kasperle',
+    // Muppets & Jim Henson
+    'Kermit',
+    'Piggy',
+    'Fozzie',
+    'Gonzo',
+    'Scooter',
+    'Rowlf',
+    'Waldorf',
+    'Statler',
+    // Kukla, Fran and Ollie
+    'Kukla',
+    'Ollie',
+    // Howdy Doody era
+    'Howdy',
+    'Clarabell',
+    // Sesame Street
+    'Grover',
+    'Elmo',
+    'Ernie',
+    'Bert',
+    'Oscar',
+    // Ventriloquist & variety
+    'Mortimer',
+    'Lambchop',
+    'Madame',
+    'Topo',
+    // International puppetry
+    'Bunraku',
+    'Wayang',
+    'Petrushka',
+    'Hanneschen',
+    'Vitezslav',
+    // Modern & pop culture
+    'Salem',
+    'Triumph',
+    'Peanut',
+    'Achmed',
+    // Marionette traditions
+    'Fantoccini',
+    'Saltimbanque',
+    'Burattino',
+    'Harlequin',
+    // Dollhouse (TV series)
+    'Echo',
+    // Inside jokes
+    'Spike',
+    'Angel',
+    // Classic dolls
+    'Barbie',
+    'Ken',
+    'Skipper',
+    'Midge',
+    'Christie',
+    'Annie',
+    'Andy',
+    'Cathy',
+    'Teddy',
+    'Xavier',
+    'Strawberry',
+    'Blythe',
+    'Ginny',
+    'Betsy',
+    'Madeline',
+];
+/** Names that can never be assigned to a leader session */
+const FOLLOWER_ONLY_NAMES = new Set(['Punch']);
+/** Fisher-Yates shuffle using crypto.randomInt (unbiased, no modulo) */
+function shuffleArray(arr) {
+    for (let i = arr.length - 1; i > 0; i--) {
+        const j = randomInt(i + 1);
+        [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+    return arr;
+}
+/** Shuffled copy of the name pool — randomized on each process start */
+const PUPPET_NAMES = shuffleArray([...ALL_PUPPET_NAMES]);
+/**
+ * Canonical colors for each puppet character.
+ * Adjusted from true canonical colors for UI readability in both light/dark themes.
+ */
+const PUPPET_COLORS = {
+    'Punch': '#DC143C', // crimson red costume
+    'Judy': '#1E90FF', // blue dress
+    'Pinocchio': '#DAA520', // goldenrod (wooden, yellow hat)
+    'Petrouchka': '#B0BEC5', // blue-gray (white costume, adjusted for visibility)
+    'Pulcinella': '#90A4AE', // gray-blue (white costume, adjusted)
+    'Guignol': '#8B4513', // saddle brown
+    'Kasperle': '#FF0000', // red pointed cap
+    'Kermit': '#4CAF50', // green frog
+    'Piggy': '#E91E8C', // hot pink (glamorous pig)
+    'Fozzie': '#CC7722', // ochre brown bear
+    'Gonzo': '#4169E1', // royal blue
+    'Scooter': '#FF8C00', // dark orange
+    'Rowlf': '#8B6914', // dark goldenrod brown dog
+    'Waldorf': '#556B2F', // dark olive green
+    'Statler': '#708090', // slate gray
+    'Kukla': '#FF0000', // red nose and costume
+    'Ollie': '#228B22', // forest green dragon
+    'Howdy': '#E2725B', // terra cotta
+    'Clarabell': '#FFCC00', // bright yellow clown
+    'Grover': '#4682B4', // steel blue
+    'Elmo': '#FF2400', // scarlet red
+    'Ernie': '#F4A460', // sandy brown
+    'Bert': '#FFD700', // gold yellow
+    'Oscar': '#6B8E23', // olive drab green
+    'Mortimer': '#DEB887', // burlywood
+    'Lambchop': '#D4C5A9', // warm cream (adjusted from pure white)
+    'Madame': '#800080', // purple
+    'Topo': '#A0A0A0', // silver gray
+    'Bunraku': '#B22222', // firebrick red
+    'Wayang': '#6B4226', // dark leather brown (lightened for visibility)
+    'Petrushka': '#FF4500', // orange red
+    'Hanneschen': '#CD5C5C', // indian red
+    'Vitezslav': '#B8860B', // dark goldenrod
+    'Salem': '#4A4A4A', // dark gray (black cat, lightened for visibility)
+    'Triumph': '#6F4E37', // coffee brown
+    'Peanut': '#9370DB', // medium purple
+    'Achmed': '#C8BFA9', // bone/parchment (lightened from beige)
+    'Fantoccini': '#C41E3A', // cardinal red
+    'Saltimbanque': '#DAA520', // goldenrod
+    'Burattino': '#D2691E', // chocolate brown
+    'Harlequin': '#E60026', // diamond red
+    'Echo': '#5C6370', // slate (dark attire, lightened for visibility)
+    'Spike': '#E8DCC8', // platinum/bleach (lightened for readability)
+    'Angel': '#3D3D3D', // charcoal (black duster, lightened for visibility)
+    // Classic dolls
+    'Barbie': '#E91E90', // Barbie pink
+    'Ken': '#4A90D9', // Ken blue
+    'Skipper': '#FF6B6B', // coral red
+    'Midge': '#E87040', // warm auburn
+    'Christie': '#C06030', // warm brown
+    'Annie': '#E03030', // Raggedy Ann red yarn hair
+    'Andy': '#3070C0', // Raggedy Andy blue sailor outfit
+    'Cathy': '#D4A574', // Chatty Cathy vintage tan
+    'Teddy': '#A0784A', // Teddy Ruxpin bear brown
+    'Xavier': '#5AAF4A', // Xavier Roberts / Cabbage Patch green
+    'Strawberry': '#E8445A', // strawberry red-pink
+    'Blythe': '#7B68EE', // big-eyed purple
+    'Ginny': '#5B9BD5', // classic blue dress
+    'Betsy': '#DD7694', // rose pink
+    'Madeline': '#FFD700', // yellow hat
+};
+/** Cooldown period before a released name can be reused (ms) */
+const NAME_COOLDOWN_MS = 5 * 60_000; // 5 minutes
+/**
+ * Manages friendly session name assignment from the puppet name pool.
+ */
+export class SessionNamePool {
+    /** Names currently assigned to active sessions: sessionId → name */
+    assigned = new Map();
+    /** Reverse lookup: name → sessionId */
+    nameToSession = new Map();
+    /** Names in cooldown after session end */
+    cooldown = [];
+    /**
+     * Assign a friendly name to a session.
+     * Returns an existing assignment if the session already has one.
+     *
+     * @param isLeader - If true, follower-only names (e.g., Punch) are excluded
+     */
+    assign(sessionId, isLeader = false) {
+        // Already assigned?
+        const existing = this.assigned.get(sessionId);
+        if (existing)
+            return existing;
+        // Flush expired cooldowns
+        this.flushCooldowns();
+        // Find an available name, respecting leader restrictions
+        const cooldownNames = new Set(this.cooldown.map(c => c.name));
+        const availableName = PUPPET_NAMES.find(name => !this.nameToSession.has(name) &&
+            !cooldownNames.has(name) &&
+            !(isLeader && FOLLOWER_ONLY_NAMES.has(name)));
+        if (availableName) {
+            this.assigned.set(sessionId, availableName);
+            this.nameToSession.set(availableName, sessionId);
+            logger.debug(`[SessionNames] Assigned '${availableName}' to ${sessionId}`);
+            return availableName;
+        }
+        // All names in use or cooling down — try cooldown names (oldest first)
+        if (this.cooldown.length > 0) {
+            const oldest = this.cooldown.shift();
+            this.assigned.set(sessionId, oldest.name);
+            this.nameToSession.set(oldest.name, sessionId);
+            logger.debug(`[SessionNames] Assigned '${oldest.name}' to ${sessionId} (early cooldown release)`);
+            return oldest.name;
+        }
+        // Truly exhausted — fall back to truncated session ID
+        const fallback = sessionId.split('-')[1] || sessionId.slice(0, 8);
+        this.assigned.set(sessionId, fallback);
+        logger.warn(`[SessionNames] Name pool exhausted, using fallback '${fallback}' for ${sessionId}`);
+        return fallback;
+    }
+    /**
+     * Release a name back to the pool with a cooldown period.
+     */
+    release(sessionId) {
+        const name = this.assigned.get(sessionId);
+        if (!name)
+            return;
+        this.assigned.delete(sessionId);
+        this.nameToSession.delete(name);
+        // Only cooldown puppet names, not fallback IDs
+        if (PUPPET_NAMES.includes(name)) {
+            this.cooldown.push({ name, releasedAt: Date.now() });
+        }
+        logger.debug(`[SessionNames] Released '${name}' from ${sessionId} (cooldown ${NAME_COOLDOWN_MS / 1000}s)`);
+    }
+    /**
+     * Get the friendly name for a session, or undefined if not assigned.
+     */
+    getName(sessionId) {
+        return this.assigned.get(sessionId);
+    }
+    /**
+     * Get the canonical color for an assigned session name.
+     */
+    getColor(sessionId) {
+        const name = this.assigned.get(sessionId);
+        return name ? (PUPPET_COLORS[name] ?? undefined) : undefined;
+    }
+    /**
+     * Get all current assignments.
+     */
+    getAll() {
+        return new Map(this.assigned);
+    }
+    flushCooldowns() {
+        const now = Date.now();
+        this.cooldown = this.cooldown.filter(c => (now - c.releasedAt) < NAME_COOLDOWN_MS);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SessionNames.js","sourceRoot":"","sources":["../../../src/web/console/SessionNames.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Friendly session names drawn from famous puppets, marionettes,\n * and puppet characters throughout history.\n *\n * Names are assigned from a pool and returned after a cooldown period\n * when sessions end. This keeps the active session list human-readable\n * and on-brand for DollhouseMCP.\n *\n * @since v2.1.0 — Issue #1700\n */\n\nimport { randomInt } from 'node:crypto';\nimport { logger } from '../../utils/logger.js';\n\n/**\n * Famous puppets, marionettes, and puppet characters from around the world.\n * Order doesn't matter — the pool is shuffled on startup.\n */\nconst ALL_PUPPET_NAMES: readonly string[] = [\n  // Classic & traditional\n  'Punch',\n  'Judy',\n  'Pinocchio',\n  'Petrouchka',\n  'Pulcinella',\n  'Guignol',\n  'Kasperle',\n\n  // Muppets & Jim Henson\n  'Kermit',\n  'Piggy',\n  'Fozzie',\n  'Gonzo',\n  'Scooter',\n  'Rowlf',\n  'Waldorf',\n  'Statler',\n\n  // Kukla, Fran and Ollie\n  'Kukla',\n  'Ollie',\n\n  // Howdy Doody era\n  'Howdy',\n  'Clarabell',\n\n  // Sesame Street\n  'Grover',\n  'Elmo',\n  'Ernie',\n  'Bert',\n  'Oscar',\n\n  // Ventriloquist & variety\n  'Mortimer',\n  'Lambchop',\n  'Madame',\n  'Topo',\n\n  // International puppetry\n  'Bunraku',\n  'Wayang',\n  'Petrushka',\n  'Hanneschen',\n  'Vitezslav',\n\n  // Modern & pop culture\n  'Salem',\n  'Triumph',\n  'Peanut',\n  'Achmed',\n\n  // Marionette traditions\n  'Fantoccini',\n  'Saltimbanque',\n  'Burattino',\n  'Harlequin',\n\n  // Dollhouse (TV series)\n  'Echo',\n\n  // Inside jokes\n  'Spike',\n  'Angel',\n\n  // Classic dolls\n  'Barbie',\n  'Ken',\n  'Skipper',\n  'Midge',\n  'Christie',\n  'Annie',\n  'Andy',\n  'Cathy',\n  'Teddy',\n  'Xavier',\n  'Strawberry',\n  'Blythe',\n  'Ginny',\n  'Betsy',\n  'Madeline',\n];\n\n/** Names that can never be assigned to a leader session */\nconst FOLLOWER_ONLY_NAMES = new Set(['Punch']);\n\n/** Fisher-Yates shuffle using crypto.randomInt (unbiased, no modulo) */\nfunction shuffleArray<T>(arr: T[]): T[] {\n  for (let i = arr.length - 1; i > 0; i--) {\n    const j = randomInt(i + 1);\n    [arr[i], arr[j]] = [arr[j], arr[i]];\n  }\n  return arr;\n}\n\n/** Shuffled copy of the name pool — randomized on each process start */\nconst PUPPET_NAMES: string[] = shuffleArray([...ALL_PUPPET_NAMES]);\n\n/**\n * Canonical colors for each puppet character.\n * Adjusted from true canonical colors for UI readability in both light/dark themes.\n */\nconst PUPPET_COLORS: Record<string, string> = {\n  'Punch':        '#DC143C', // crimson red costume\n  'Judy':         '#1E90FF', // blue dress\n  'Pinocchio':    '#DAA520', // goldenrod (wooden, yellow hat)\n  'Petrouchka':   '#B0BEC5', // blue-gray (white costume, adjusted for visibility)\n  'Pulcinella':   '#90A4AE', // gray-blue (white costume, adjusted)\n  'Guignol':      '#8B4513', // saddle brown\n  'Kasperle':     '#FF0000', // red pointed cap\n  'Kermit':       '#4CAF50', // green frog\n  'Piggy':        '#E91E8C', // hot pink (glamorous pig)\n  'Fozzie':       '#CC7722', // ochre brown bear\n  'Gonzo':        '#4169E1', // royal blue\n  'Scooter':      '#FF8C00', // dark orange\n  'Rowlf':        '#8B6914', // dark goldenrod brown dog\n  'Waldorf':      '#556B2F', // dark olive green\n  'Statler':      '#708090', // slate gray\n  'Kukla':        '#FF0000', // red nose and costume\n  'Ollie':        '#228B22', // forest green dragon\n  'Howdy':        '#E2725B', // terra cotta\n  'Clarabell':    '#FFCC00', // bright yellow clown\n  'Grover':       '#4682B4', // steel blue\n  'Elmo':         '#FF2400', // scarlet red\n  'Ernie':        '#F4A460', // sandy brown\n  'Bert':         '#FFD700', // gold yellow\n  'Oscar':        '#6B8E23', // olive drab green\n  'Mortimer':     '#DEB887', // burlywood\n  'Lambchop':     '#D4C5A9', // warm cream (adjusted from pure white)\n  'Madame':       '#800080', // purple\n  'Topo':         '#A0A0A0', // silver gray\n  'Bunraku':      '#B22222', // firebrick red\n  'Wayang':       '#6B4226', // dark leather brown (lightened for visibility)\n  'Petrushka':    '#FF4500', // orange red\n  'Hanneschen':   '#CD5C5C', // indian red\n  'Vitezslav':    '#B8860B', // dark goldenrod\n  'Salem':        '#4A4A4A', // dark gray (black cat, lightened for visibility)\n  'Triumph':      '#6F4E37', // coffee brown\n  'Peanut':       '#9370DB', // medium purple\n  'Achmed':       '#C8BFA9', // bone/parchment (lightened from beige)\n  'Fantoccini':   '#C41E3A', // cardinal red\n  'Saltimbanque': '#DAA520', // goldenrod\n  'Burattino':    '#D2691E', // chocolate brown\n  'Harlequin':    '#E60026', // diamond red\n  'Echo':         '#5C6370', // slate (dark attire, lightened for visibility)\n  'Spike':        '#E8DCC8', // platinum/bleach (lightened for readability)\n  'Angel':        '#3D3D3D', // charcoal (black duster, lightened for visibility)\n\n  // Classic dolls\n  'Barbie':       '#E91E90', // Barbie pink\n  'Ken':          '#4A90D9', // Ken blue\n  'Skipper':      '#FF6B6B', // coral red\n  'Midge':        '#E87040', // warm auburn\n  'Christie':     '#C06030', // warm brown\n  'Annie':        '#E03030', // Raggedy Ann red yarn hair\n  'Andy':         '#3070C0', // Raggedy Andy blue sailor outfit\n  'Cathy':        '#D4A574', // Chatty Cathy vintage tan\n  'Teddy':        '#A0784A', // Teddy Ruxpin bear brown\n  'Xavier':       '#5AAF4A', // Xavier Roberts / Cabbage Patch green\n  'Strawberry':   '#E8445A', // strawberry red-pink\n  'Blythe':       '#7B68EE', // big-eyed purple\n  'Ginny':        '#5B9BD5', // classic blue dress\n  'Betsy':        '#DD7694', // rose pink\n  'Madeline':     '#FFD700', // yellow hat\n};\n\n/** Cooldown period before a released name can be reused (ms) */\nconst NAME_COOLDOWN_MS = 5 * 60_000; // 5 minutes\n\ninterface CooldownEntry {\n  name: string;\n  releasedAt: number;\n}\n\n/**\n * Manages friendly session name assignment from the puppet name pool.\n */\nexport class SessionNamePool {\n  /** Names currently assigned to active sessions: sessionId → name */\n  private readonly assigned = new Map<string, string>();\n  /** Reverse lookup: name → sessionId */\n  private readonly nameToSession = new Map<string, string>();\n  /** Names in cooldown after session end */\n  private cooldown: CooldownEntry[] = [];\n\n  /**\n   * Assign a friendly name to a session.\n   * Returns an existing assignment if the session already has one.\n   *\n   * @param isLeader - If true, follower-only names (e.g., Punch) are excluded\n   */\n  assign(sessionId: string, isLeader = false): string {\n    // Already assigned?\n    const existing = this.assigned.get(sessionId);\n    if (existing) return existing;\n\n    // Flush expired cooldowns\n    this.flushCooldowns();\n\n    // Find an available name, respecting leader restrictions\n    const cooldownNames = new Set(this.cooldown.map(c => c.name));\n    const availableName = PUPPET_NAMES.find(\n      name => !this.nameToSession.has(name) &&\n              !cooldownNames.has(name) &&\n              !(isLeader && FOLLOWER_ONLY_NAMES.has(name))\n    );\n\n    if (availableName) {\n      this.assigned.set(sessionId, availableName);\n      this.nameToSession.set(availableName, sessionId);\n      logger.debug(`[SessionNames] Assigned '${availableName}' to ${sessionId}`);\n      return availableName;\n    }\n\n    // All names in use or cooling down — try cooldown names (oldest first)\n    if (this.cooldown.length > 0) {\n      const oldest = this.cooldown.shift()!;\n      this.assigned.set(sessionId, oldest.name);\n      this.nameToSession.set(oldest.name, sessionId);\n      logger.debug(`[SessionNames] Assigned '${oldest.name}' to ${sessionId} (early cooldown release)`);\n      return oldest.name;\n    }\n\n    // Truly exhausted — fall back to truncated session ID\n    const fallback = sessionId.split('-')[1] || sessionId.slice(0, 8);\n    this.assigned.set(sessionId, fallback);\n    logger.warn(`[SessionNames] Name pool exhausted, using fallback '${fallback}' for ${sessionId}`);\n    return fallback;\n  }\n\n  /**\n   * Release a name back to the pool with a cooldown period.\n   */\n  release(sessionId: string): void {\n    const name = this.assigned.get(sessionId);\n    if (!name) return;\n\n    this.assigned.delete(sessionId);\n    this.nameToSession.delete(name);\n\n    // Only cooldown puppet names, not fallback IDs\n    if (PUPPET_NAMES.includes(name)) {\n      this.cooldown.push({ name, releasedAt: Date.now() });\n    }\n\n    logger.debug(`[SessionNames] Released '${name}' from ${sessionId} (cooldown ${NAME_COOLDOWN_MS / 1000}s)`);\n  }\n\n  /**\n   * Get the friendly name for a session, or undefined if not assigned.\n   */\n  getName(sessionId: string): string | undefined {\n    return this.assigned.get(sessionId);\n  }\n\n  /**\n   * Get the canonical color for an assigned session name.\n   */\n  getColor(sessionId: string): string | undefined {\n    const name = this.assigned.get(sessionId);\n    return name ? (PUPPET_COLORS[name] ?? undefined) : undefined;\n  }\n\n  /**\n   * Get all current assignments.\n   */\n  getAll(): Map<string, string> {\n    return new Map(this.assigned);\n  }\n\n  private flushCooldowns(): void {\n    const now = Date.now();\n    this.cooldown = this.cooldown.filter(c => (now - c.releasedAt) < NAME_COOLDOWN_MS);\n  }\n}\n"]}