@dollhousemcp/mcp-server 2.0.11 → 2.0.12-rc.2

package/dist/web/console/PromotionManager.js

@@ -0,0 +1,94 @@
+/**
+ * Follower-to-leader promotion manager (#1850).
+ *
+ * Handles the lifecycle of promoting a follower process to leader when the
+ * current leader becomes unreachable. Extracted from UnifiedConsole.ts to
+ * reduce complexity and allow per-instance state tracking.
+ *
+ * Each PromotionManager instance tracks its own attempt counter, so multiple
+ * followers in the same process (unlikely but possible) don't interfere
+ * with each other's promotion budgets.
+ */
+import { logger } from '../../utils/logger.js';
+import { deleteLeaderLock, claimLeadership, readLeaderLock, LOCK_VERSION, } from './LeaderElection.js';
+const MAX_PROMOTION_ATTEMPTS = 3;
+export class PromotionManager {
+    options;
+    consolePort;
+    startAsLeader;
+    startAsFollower;
+    inProgress = false;
+    attempts = 0;
+    constructor(options, consolePort, startAsLeader, startAsFollower) {
+        this.options = options;
+        this.consolePort = consolePort;
+        this.startAsLeader = startAsLeader;
+        this.startAsFollower = startAsFollower;
+    }
+    /**
+     * Attempt promotion. Safe to call from the ForwardingSink onLeaderDeath
+     * callback — guards against concurrent and excessive attempts.
+     */
+    async promote(forwardingSink, sessionHeartbeat) {
+        if (this.inProgress) {
+            logger.info('[PromotionManager] Promotion already in progress — skipping');
+            return;
+        }
+        this.attempts++;
+        if (this.attempts > MAX_PROMOTION_ATTEMPTS) {
+            logger.error(`[PromotionManager] Attempt ${this.attempts} exceeds max (${MAX_PROMOTION_ATTEMPTS}) — giving up`);
+            return;
+        }
+        this.inProgress = true;
+        const startMs = Date.now();
+        try {
+            logger.warn(`[PromotionManager] Leader death detected — promotion attempt ${this.attempts}/${MAX_PROMOTION_ATTEMPTS}`, {
+                sessionId: this.options.sessionId, pid: process.pid, port: this.consolePort, attempt: this.attempts,
+            });
+            await sessionHeartbeat.stop();
+            await forwardingSink.close();
+            await deleteLeaderLock();
+            const now = new Date().toISOString();
+            const myInfo = {
+                version: LOCK_VERSION,
+                pid: process.pid,
+                port: this.consolePort,
+                sessionId: this.options.sessionId,
+                startedAt: now,
+                heartbeat: now,
+            };
+            const claimed = await claimLeadership(myInfo);
+            const durationMs = Date.now() - startMs;
+            if (claimed) {
+                logger.info('[PromotionManager] Promotion succeeded — starting as leader', {
+                    sessionId: this.options.sessionId, port: this.consolePort, durationMs, attempt: this.attempts,
+                });
+                const election = { role: 'leader', leaderInfo: myInfo };
+                await this.startAsLeader(this.options, election, this.consolePort);
+            }
+            else {
+                logger.info('[PromotionManager] Lost promotion race — following new leader', {
+                    sessionId: this.options.sessionId, durationMs, attempt: this.attempts,
+                });
+                const newLeader = await readLeaderLock();
+                if (newLeader) {
+                    const election = { role: 'follower', leaderInfo: newLeader };
+                    await this.startAsFollower(this.options, election, this.consolePort);
+                }
+                else {
+                    logger.error('[PromotionManager] No leader available after lost race');
+                }
+            }
+        }
+        catch (err) {
+            logger.error('[PromotionManager] Promotion failed', {
+                error: err instanceof Error ? err.message : String(err),
+                durationMs: Date.now() - startMs, attempt: this.attempts,
+            });
+        }
+        finally {
+            this.inProgress = false;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PromotionManager.js","sourceRoot":"","sources":["../../../src/web/console/PromotionManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Follower-to-leader promotion manager (#1850).\n *\n * Handles the lifecycle of promoting a follower process to leader when the\n * current leader becomes unreachable. Extracted from UnifiedConsole.ts to\n * reduce complexity and allow per-instance state tracking.\n *\n * Each PromotionManager instance tracks its own attempt counter, so multiple\n * followers in the same process (unlikely but possible) don't interfere\n * with each other's promotion budgets.\n */\n\nimport { logger } from '../../utils/logger.js';\nimport {\n  deleteLeaderLock,\n  claimLeadership,\n  readLeaderLock,\n  LOCK_VERSION,\n  type ElectionResult,\n  type ConsoleLeaderInfo,\n} from './LeaderElection.js';\nimport type { LeaderForwardingLogSink, SessionHeartbeat } from './LeaderForwardingSink.js';\nimport type { UnifiedConsoleOptions } from './UnifiedConsole.js';\n\nconst MAX_PROMOTION_ATTEMPTS = 3;\n\nexport class PromotionManager {\n  private inProgress = false;\n  private attempts = 0;\n\n  constructor(\n    private readonly options: UnifiedConsoleOptions,\n    private readonly consolePort: number,\n    private readonly startAsLeader: (\n      options: UnifiedConsoleOptions,\n      election: ElectionResult,\n      consolePort: number,\n    ) => Promise<unknown>,\n    private readonly startAsFollower: (\n      options: UnifiedConsoleOptions,\n      election: ElectionResult,\n      consolePort: number,\n    ) => Promise<unknown>,\n  ) {}\n\n  /**\n   * Attempt promotion. Safe to call from the ForwardingSink onLeaderDeath\n   * callback — guards against concurrent and excessive attempts.\n   */\n  async promote(\n    forwardingSink: LeaderForwardingLogSink,\n    sessionHeartbeat: SessionHeartbeat,\n  ): Promise<void> {\n    if (this.inProgress) {\n      logger.info('[PromotionManager] Promotion already in progress — skipping');\n      return;\n    }\n\n    this.attempts++;\n    if (this.attempts > MAX_PROMOTION_ATTEMPTS) {\n      logger.error(`[PromotionManager] Attempt ${this.attempts} exceeds max (${MAX_PROMOTION_ATTEMPTS}) — giving up`);\n      return;\n    }\n\n    this.inProgress = true;\n    const startMs = Date.now();\n\n    try {\n      logger.warn(`[PromotionManager] Leader death detected — promotion attempt ${this.attempts}/${MAX_PROMOTION_ATTEMPTS}`, {\n        sessionId: this.options.sessionId, pid: process.pid, port: this.consolePort, attempt: this.attempts,\n      });\n\n      await sessionHeartbeat.stop();\n      await forwardingSink.close();\n      await deleteLeaderLock();\n\n      const now = new Date().toISOString();\n      const myInfo: ConsoleLeaderInfo = {\n        version: LOCK_VERSION,\n        pid: process.pid,\n        port: this.consolePort,\n        sessionId: this.options.sessionId,\n        startedAt: now,\n        heartbeat: now,\n      };\n\n      const claimed = await claimLeadership(myInfo);\n      const durationMs = Date.now() - startMs;\n\n      if (claimed) {\n        logger.info('[PromotionManager] Promotion succeeded — starting as leader', {\n          sessionId: this.options.sessionId, port: this.consolePort, durationMs, attempt: this.attempts,\n        });\n        const election: ElectionResult = { role: 'leader', leaderInfo: myInfo };\n        await this.startAsLeader(this.options, election, this.consolePort);\n      } else {\n        logger.info('[PromotionManager] Lost promotion race — following new leader', {\n          sessionId: this.options.sessionId, durationMs, attempt: this.attempts,\n        });\n        const newLeader = await readLeaderLock();\n        if (newLeader) {\n          const election: ElectionResult = { role: 'follower', leaderInfo: newLeader };\n          await this.startAsFollower(this.options, election, this.consolePort);\n        } else {\n          logger.error('[PromotionManager] No leader available after lost race');\n        }\n      }\n    } catch (err) {\n      logger.error('[PromotionManager] Promotion failed', {\n        error: err instanceof Error ? err.message : String(err),\n        durationMs: Date.now() - startMs, attempt: this.attempts,\n      });\n    } finally {\n      this.inProgress = false;\n    }\n  }\n}\n"]}

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

@@ -8,6 +8,13 @@
  *
  * @since v2.1.0 — Issue #1700
  */
+/**
+ * Pick a random puppet name from the pool, independent of the session
+ * name assignment. Used by the console token module (#1780) to generate
+ * a friendly default name for newly created tokens. Does not reserve the
+ * name — multiple callers can receive the same value.
+ */
+export declare function pickRandomPuppetName(): string;
 /**
  * Manages friendly session name assignment from the puppet name pool.
  */

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

@@ -1 +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"}
+{"version":3,"file":"SessionNames.d.ts","sourceRoot":"","sources":["../../../src/web/console/SessionNames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AA6GH;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C;AA8ED;;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

@@ -99,6 +99,15 @@ function shuffleArray(arr) {
 }
 /** Shuffled copy of the name pool — randomized on each process start */
 const PUPPET_NAMES = shuffleArray([...ALL_PUPPET_NAMES]);
+/**
+ * Pick a random puppet name from the pool, independent of the session
+ * name assignment. Used by the console token module (#1780) to generate
+ * a friendly default name for newly created tokens. Does not reserve the
+ * name — multiple callers can receive the same value.
+ */
+export function pickRandomPuppetName() {
+    return ALL_PUPPET_NAMES[randomInt(ALL_PUPPET_NAMES.length)];
+}
 /**
  * Canonical colors for each puppet character.
  * Adjusted from true canonical colors for UI readability in both light/dark themes.
@@ -254,4 +263,4 @@ export class SessionNamePool {
         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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SessionNames.js","sourceRoot":"","sources":["../../../src/web/console/SessionNames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE/C;;;GAGG;AACH,MAAM,gBAAgB,GAAsB;IAC1C,wBAAwB;IACxB,OAAO;IACP,MAAM;IACN,WAAW;IACX,YAAY;IACZ,YAAY;IACZ,SAAS;IACT,UAAU;IAEV,uBAAuB;IACvB,QAAQ;IACR,OAAO;IACP,QAAQ;IACR,OAAO;IACP,SAAS;IACT,OAAO;IACP,SAAS;IACT,SAAS;IAET,wBAAwB;IACxB,OAAO;IACP,OAAO;IAEP,kBAAkB;IAClB,OAAO;IACP,WAAW;IAEX,gBAAgB;IAChB,QAAQ;IACR,MAAM;IACN,OAAO;IACP,MAAM;IACN,OAAO;IAEP,0BAA0B;IAC1B,UAAU;IACV,UAAU;IACV,QAAQ;IACR,MAAM;IAEN,yBAAyB;IACzB,SAAS;IACT,QAAQ;IACR,WAAW;IACX,YAAY;IACZ,WAAW;IAEX,uBAAuB;IACvB,OAAO;IACP,SAAS;IACT,QAAQ;IACR,QAAQ;IAER,wBAAwB;IACxB,YAAY;IACZ,cAAc;IACd,WAAW;IACX,WAAW;IAEX,wBAAwB;IACxB,MAAM;IAEN,eAAe;IACf,OAAO;IACP,OAAO;IAEP,gBAAgB;IAChB,QAAQ;IACR,KAAK;IACL,SAAS;IACT,OAAO;IACP,UAAU;IACV,OAAO;IACP,MAAM;IACN,OAAO;IACP,OAAO;IACP,QAAQ;IACR,YAAY;IACZ,QAAQ;IACR,OAAO;IACP,OAAO;IACP,UAAU;CACX,CAAC;AAEF,2DAA2D;AAC3D,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;AAE/C,wEAAwE;AACxE,SAAS,YAAY,CAAI,GAAQ;IAC/B,KAAK,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACxC,MAAM,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3B,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACtC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,wEAAwE;AACxE,MAAM,YAAY,GAAa,YAAY,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC;AAEnE;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO,gBAAgB,CAAC,SAAS,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;AAC9D,CAAC;AAED;;;GAGG;AACH,MAAM,aAAa,GAA2B;IAC5C,OAAO,EAAS,SAAS,EAAE,sBAAsB;IACjD,MAAM,EAAU,SAAS,EAAE,aAAa;IACxC,WAAW,EAAK,SAAS,EAAE,iCAAiC;IAC5D,YAAY,EAAI,SAAS,EAAE,qDAAqD;IAChF,YAAY,EAAI,SAAS,EAAE,sCAAsC;IACjE,SAAS,EAAO,SAAS,EAAE,eAAe;IAC1C,UAAU,EAAM,SAAS,EAAE,kBAAkB;IAC7C,QAAQ,EAAQ,SAAS,EAAE,aAAa;IACxC,OAAO,EAAS,SAAS,EAAE,2BAA2B;IACtD,QAAQ,EAAQ,SAAS,EAAE,mBAAmB;IAC9C,OAAO,EAAS,SAAS,EAAE,aAAa;IACxC,SAAS,EAAO,SAAS,EAAE,cAAc;IACzC,OAAO,EAAS,SAAS,EAAE,2BAA2B;IACtD,SAAS,EAAO,SAAS,EAAE,mBAAmB;IAC9C,SAAS,EAAO,SAAS,EAAE,aAAa;IACxC,OAAO,EAAS,SAAS,EAAE,uBAAuB;IAClD,OAAO,EAAS,SAAS,EAAE,sBAAsB;IACjD,OAAO,EAAS,SAAS,EAAE,cAAc;IACzC,WAAW,EAAK,SAAS,EAAE,sBAAsB;IACjD,QAAQ,EAAQ,SAAS,EAAE,aAAa;IACxC,MAAM,EAAU,SAAS,EAAE,cAAc;IACzC,OAAO,EAAS,SAAS,EAAE,cAAc;IACzC,MAAM,EAAU,SAAS,EAAE,cAAc;IACzC,OAAO,EAAS,SAAS,EAAE,mBAAmB;IAC9C,UAAU,EAAM,SAAS,EAAE,YAAY;IACvC,UAAU,EAAM,SAAS,EAAE,wCAAwC;IACnE,QAAQ,EAAQ,SAAS,EAAE,SAAS;IACpC,MAAM,EAAU,SAAS,EAAE,cAAc;IACzC,SAAS,EAAO,SAAS,EAAE,gBAAgB;IAC3C,QAAQ,EAAQ,SAAS,EAAE,gDAAgD;IAC3E,WAAW,EAAK,SAAS,EAAE,aAAa;IACxC,YAAY,EAAI,SAAS,EAAE,aAAa;IACxC,WAAW,EAAK,SAAS,EAAE,iBAAiB;IAC5C,OAAO,EAAS,SAAS,EAAE,kDAAkD;IAC7E,SAAS,EAAO,SAAS,EAAE,eAAe;IAC1C,QAAQ,EAAQ,SAAS,EAAE,gBAAgB;IAC3C,QAAQ,EAAQ,SAAS,EAAE,wCAAwC;IACnE,YAAY,EAAI,SAAS,EAAE,eAAe;IAC1C,cAAc,EAAE,SAAS,EAAE,YAAY;IACvC,WAAW,EAAK,SAAS,EAAE,kBAAkB;IAC7C,WAAW,EAAK,SAAS,EAAE,cAAc;IACzC,MAAM,EAAU,SAAS,EAAE,gDAAgD;IAC3E,OAAO,EAAS,SAAS,EAAE,8CAA8C;IACzE,OAAO,EAAS,SAAS,EAAE,oDAAoD;IAE/E,gBAAgB;IAChB,QAAQ,EAAQ,SAAS,EAAE,cAAc;IACzC,KAAK,EAAW,SAAS,EAAE,WAAW;IACtC,SAAS,EAAO,SAAS,EAAE,YAAY;IACvC,OAAO,EAAS,SAAS,EAAE,cAAc;IACzC,UAAU,EAAM,SAAS,EAAE,aAAa;IACxC,OAAO,EAAS,SAAS,EAAE,4BAA4B;IACvD,MAAM,EAAU,SAAS,EAAE,kCAAkC;IAC7D,OAAO,EAAS,SAAS,EAAE,2BAA2B;IACtD,OAAO,EAAS,SAAS,EAAE,0BAA0B;IACrD,QAAQ,EAAQ,SAAS,EAAE,uCAAuC;IAClE,YAAY,EAAI,SAAS,EAAE,sBAAsB;IACjD,QAAQ,EAAQ,SAAS,EAAE,kBAAkB;IAC7C,OAAO,EAAS,SAAS,EAAE,qBAAqB;IAChD,OAAO,EAAS,SAAS,EAAE,YAAY;IACvC,UAAU,EAAM,SAAS,EAAE,aAAa;CACzC,CAAC;AAEF,gEAAgE;AAChE,MAAM,gBAAgB,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,YAAY;AAOjD;;GAEG;AACH,MAAM,OAAO,eAAe;IAC1B,oEAAoE;IACnD,QAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;IACtD,uCAAuC;IACtB,aAAa,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC3D,0CAA0C;IAClC,QAAQ,GAAoB,EAAE,CAAC;IAEvC;;;;;OAKG;IACH,MAAM,CAAC,SAAiB,EAAE,QAAQ,GAAG,KAAK;QACxC,oBAAoB;QACpB,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC9C,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAE9B,0BAA0B;QAC1B,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,yDAAyD;QACzD,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAC9D,MAAM,aAAa,GAAG,YAAY,CAAC,IAAI,CACrC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC;YAC7B,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC;YACxB,CAAC,CAAC,QAAQ,IAAI,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CACrD,CAAC;QAEF,IAAI,aAAa,EAAE,CAAC;YAClB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YAC5C,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;YACjD,MAAM,CAAC,KAAK,CAAC,4BAA4B,aAAa,QAAQ,SAAS,EAAE,CAAC,CAAC;YAC3E,OAAO,aAAa,CAAC;QACvB,CAAC;QAED,uEAAuE;QACvE,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAG,CAAC;YACtC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;YAC1C,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;YAC/C,MAAM,CAAC,KAAK,CAAC,4BAA4B,MAAM,CAAC,IAAI,QAAQ,SAAS,2BAA2B,CAAC,CAAC;YAClG,OAAO,MAAM,CAAC,IAAI,CAAC;QACrB,CAAC;QAED,sDAAsD;QACtD,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAClE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QACvC,MAAM,CAAC,IAAI,CAAC,uDAAuD,QAAQ,SAAS,SAAS,EAAE,CAAC,CAAC;QACjG,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,SAAiB;QACvB,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC1C,IAAI,CAAC,IAAI;YAAE,OAAO;QAElB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAChC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAEhC,+CAA+C;QAC/C,IAAI,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YAChC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACvD,CAAC;QAED,MAAM,CAAC,KAAK,CAAC,4BAA4B,IAAI,UAAU,SAAS,cAAc,gBAAgB,GAAG,IAAI,IAAI,CAAC,CAAC;IAC7G,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,SAAiB;QACvB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,SAAiB;QACxB,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC1C,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC/D,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAChC,CAAC;IAEO,cAAc;QACpB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,UAAU,CAAC,GAAG,gBAAgB,CAAC,CAAC;IACrF,CAAC;CACF","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 * Pick a random puppet name from the pool, independent of the session\n * name assignment. Used by the console token module (#1780) to generate\n * a friendly default name for newly created tokens. Does not reserve the\n * name — multiple callers can receive the same value.\n */\nexport function pickRandomPuppetName(): string {\n  return ALL_PUPPET_NAMES[randomInt(ALL_PUPPET_NAMES.length)];\n}\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"]}

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

@@ -16,7 +16,8 @@ import type { UnifiedLogEntry } from '../../logging/types.js';
 import type { MetricSnapshot } from '../../metrics/types.js';
 import type { MemoryLogSink } from '../../logging/sinks/MemoryLogSink.js';
 import type { MemoryMetricsSink } from '../../metrics/sinks/MemoryMetricsSink.js';
-import { type ElectionResult } from './LeaderElection.js';
+import { logger } from '../../utils/logger.js';
+import { detectLegacyLeader, type ElectionResult } from './LeaderElection.js';
 /**
  * Options for starting the unified console.
  */
@@ -42,6 +43,8 @@ export interface UnifiedConsoleOptions {
         logBroadcast?: (entry: UnifiedLogEntry) => void;
         metricsOnSnapshot?: (snapshot: MetricSnapshot) => void;
     }, metricsSink?: MemoryMetricsSink) => void;
+    /** Console port override from config file. Falls back to env var if not provided. */
+    port?: number;
 }
 /**
  * Result of starting the unified console.
@@ -54,6 +57,28 @@ export interface UnifiedConsoleResult {
     /** Cleanup function to call on shutdown */
     cleanup: () => Promise<void>;
 }
+/**
+ * Check for a running legacy (pre-authentication) DollhouseMCP console and
+ * log a WARN-level message if one is found (#1794).
+ *
+ * Extracted from `startUnifiedConsole` so the wiring can be integration-
+ * tested in isolation without spinning up a full web server and leader
+ * election. The implementation is fire-and-forget: detection failures
+ * are logged at DEBUG and never propagate, because a failure here must
+ * not block leader election of the authenticated console.
+ *
+ * @param currentPort - The port the authenticated console intends to
+ *                      bind to. Used in the warning message to help the
+ *                      user tell the two consoles apart.
+ * @param detect      - Optional injection point for the detection
+ *                      function. Defaults to `detectLegacyLeader`. Tests
+ *                      pass a stub.
+ * @param log         - Optional injection point for the logger. Defaults
+ *                      to the module logger. Tests pass a spy.
+ * @returns The legacy leader info from `detect()`, or null if detection
+ *          threw. Exposed so tests can assert the full result shape.
+ */
+export declare function warnIfLegacyConsolePresent(currentPort: number, detect?: typeof detectLegacyLeader, log?: typeof logger): Promise<Awaited<ReturnType<typeof detectLegacyLeader>> | null>;
 /**
  * Start the unified web console.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"UnifiedConsole.d.ts","sourceRoot":"","sources":["../../../src/web/console/UnifiedConsole.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;AAElF,OAAO,EAML,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAU7B;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB,4CAA4C;IAC5C,UAAU,EAAE,aAAa,CAAC;IAC1B,0BAA0B;IAC1B,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,qFAAqF;IACrF,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,0DAA0D;IAC1D,eAAe,EAAE,CAAC,IAAI,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;QAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,KAAK,IAAI,CAAC;IACzH,8DAA8D;IAC9D,iBAAiB,EAAE,CAAC,SAAS,EAAE;QAAE,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;QAAC,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,IAAI,CAAA;KAAE,EAAE,WAAW,CAAC,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACtL;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC5B,QAAQ,EAAE,cAAc,CAAC;IACzB,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAkBvG"}
+{"version":3,"file":"UnifiedConsole.d.ts","sourceRoot":"","sources":["../../../src/web/console/UnifiedConsole.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;AAClF,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAML,kBAAkB,EAClB,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAmB7B;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB,4CAA4C;IAC5C,UAAU,EAAE,aAAa,CAAC;IAC1B,0BAA0B;IAC1B,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,qFAAqF;IACrF,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,0DAA0D;IAC1D,eAAe,EAAE,CAAC,IAAI,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;QAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,KAAK,IAAI,CAAC;IACzH,8DAA8D;IAC9D,iBAAiB,EAAE,CAAC,SAAS,EAAE;QAAE,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;QAAC,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,IAAI,CAAA;KAAE,EAAE,WAAW,CAAC,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACrL,qFAAqF;IACrF,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC5B,QAAQ,EAAE,cAAc,CAAC;IACzB,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,0BAA0B,CAC9C,WAAW,EAAE,MAAM,EACnB,MAAM,GAAE,OAAO,kBAAuC,EACtD,GAAG,GAAE,OAAO,MAAe,GAC1B,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,GAAG,IAAI,CAAC,CAsBhE;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA8BvG"}