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

package/dist/generated/version.d.ts

@@ -2,8 +2,8 @@
  * Auto-generated file - DO NOT EDIT
  * Generated at build time by scripts/generate-version.js
  */
-export declare const PACKAGE_VERSION = "2.0.12-rc.2";
-export declare const BUILD_TIMESTAMP = "2026-04-08T21:04:11.080Z";
+export declare const PACKAGE_VERSION = "2.0.12-rc.3";
+export declare const BUILD_TIMESTAMP = "2026-04-09T02:37:11.426Z";
 export declare const BUILD_TYPE: 'npm' | 'git';
 export declare const PACKAGE_NAME = "@dollhousemcp/mcp-server";
 //# sourceMappingURL=version.d.ts.map

package/dist/generated/version.js

@@ -2,8 +2,8 @@
  * Auto-generated file - DO NOT EDIT
  * Generated at build time by scripts/generate-version.js
  */
-export const PACKAGE_VERSION = '2.0.12-rc.2';
-export const BUILD_TIMESTAMP = '2026-04-08T21:04:11.080Z';
+export const PACKAGE_VERSION = '2.0.12-rc.3';
+export const BUILD_TIMESTAMP = '2026-04-09T02:37:11.426Z';
 export const BUILD_TYPE = 'npm';
 export const PACKAGE_NAME = '@dollhousemcp/mcp-server';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nZW5lcmF0ZWQvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsYUFBYSxDQUFDO0FBQzdDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRywwQkFBMEIsQ0FBQztBQUMxRCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQWtCLEtBQUssQ0FBQztBQUMvQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF1dG8tZ2VuZXJhdGVkIGZpbGUgLSBETyBOT1QgRURJVFxuICogR2VuZXJhdGVkIGF0IGJ1aWxkIHRpbWUgYnkgc2NyaXB0cy9nZW5lcmF0ZS12ZXJzaW9uLmpzXG4gKi9cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9ICcyLjAuMTItcmMuMic7XG5leHBvcnQgY29uc3QgQlVJTERfVElNRVNUQU1QID0gJzIwMjYtMDQtMDhUMjE6MDQ6MTEuMDgwWic7XG5leHBvcnQgY29uc3QgQlVJTERfVFlQRTogJ25wbScgfCAnZ2l0JyA9ICducG0nO1xuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfTkFNRSA9ICdAZG9sbGhvdXNlbWNwL21jcC1zZXJ2ZXInO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nZW5lcmF0ZWQvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsYUFBYSxDQUFDO0FBQzdDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRywwQkFBMEIsQ0FBQztBQUMxRCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQWtCLEtBQUssQ0FBQztBQUMvQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF1dG8tZ2VuZXJhdGVkIGZpbGUgLSBETyBOT1QgRURJVFxuICogR2VuZXJhdGVkIGF0IGJ1aWxkIHRpbWUgYnkgc2NyaXB0cy9nZW5lcmF0ZS12ZXJzaW9uLmpzXG4gKi9cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9ICcyLjAuMTItcmMuMyc7XG5leHBvcnQgY29uc3QgQlVJTERfVElNRVNUQU1QID0gJzIwMjYtMDQtMDlUMDI6Mzc6MTEuNDI2Wic7XG5leHBvcnQgY29uc3QgQlVJTERfVFlQRTogJ25wbScgfCAnZ2l0JyA9ICducG0nO1xuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfTkFNRSA9ICdAZG9sbGhvdXNlbWNwL21jcC1zZXJ2ZXInO1xuIl19

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

@@ -0,0 +1,37 @@
+/**
+ * Stale process detection and recovery (#1850).
+ *
+ * Finds and kills zombie DollhouseMCP processes that squat on the console
+ * port after their session has ended. Used by bindAndListen in server.ts
+ * when EADDRINUSE occurs.
+ *
+ * Extracted to a standalone module so it can be tested without importing
+ * the full Express server and its dependency chain.
+ */
+/**
+ * Find the PID of the process listening on a given port.
+ * Uses lsof on macOS/Linux. Returns null if not found or on error.
+ *
+ * Timeout: 1s — lsof on localhost is typically <100ms. The 1s ceiling
+ * handles slow NFS-mounted /dev/fd or overloaded CI runners without
+ * delaying startup noticeably.
+ */
+export declare function findPidOnPort(port: number): Promise<number | null>;
+/**
+ * Kill a stale process holding a port. Sends SIGTERM, waits briefly,
+ * then SIGKILL if still alive. Only kills DollhouseMCP processes
+ * (verified by checking the command line and user ownership).
+ *
+ * Timeout: 1s for ps verification. Kill wait: 300ms × 10 polls = 3s
+ * before escalating to SIGKILL. Total worst case: ~4s.
+ */
+export declare function killStaleProcess(pid: number, port: number): Promise<boolean>;
+/**
+ * Detect and recover from a stale process squatting on the port.
+ * Compares the port holder's PID against the leader lock file to determine
+ * if it's a squatter. Returns true if the squatter was killed.
+ *
+ * Timeouts: lsof 1s, ps 1s, SIGTERM wait 3s — max ~5s total.
+ */
+export declare function recoverStalePort(port: number): Promise<boolean>;
+//# sourceMappingURL=StaleProcessRecovery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StaleProcessRecovery.d.ts","sourceRoot":"","sources":["../../../src/web/console/StaleProcessRecovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAkBH;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsBxE;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAuDlF;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAqBrE"}

package/dist/web/console/StaleProcessRecovery.js

@@ -0,0 +1,156 @@
+/**
+ * Stale process detection and recovery (#1850).
+ *
+ * Finds and kills zombie DollhouseMCP processes that squat on the console
+ * port after their session has ended. Used by bindAndListen in server.ts
+ * when EADDRINUSE occurs.
+ *
+ * Extracted to a standalone module so it can be tested without importing
+ * the full Express server and its dependency chain.
+ */
+// Use lazy import for logger to avoid pulling in the full env.ts/config chain
+// at module load time. This keeps the module independently testable.
+let _logger = null;
+async function getLogger() {
+    if (!_logger) {
+        try {
+            _logger = (await import('../../utils/logger.js')).logger;
+        }
+        catch { /* fallback below */ }
+    }
+    return _logger;
+}
+const logger = {
+    warn: async (...args) => { const l = await getLogger(); l ? l.warn(args[0], args[1]) : console.error('[WARN]', ...args); },
+    info: async (...args) => { const l = await getLogger(); l ? l.info(args[0], args[1]) : console.error('[INFO]', ...args); },
+    debug: async (...args) => { const l = await getLogger(); l ? l.debug(args[0], args[1]) : void 0; },
+};
+/**
+ * Find the PID of the process listening on a given port.
+ * Uses lsof on macOS/Linux. Returns null if not found or on error.
+ *
+ * Timeout: 1s — lsof on localhost is typically <100ms. The 1s ceiling
+ * handles slow NFS-mounted /dev/fd or overloaded CI runners without
+ * delaying startup noticeably.
+ */
+export async function findPidOnPort(port) {
+    const { execFile: execFileCb } = await import('node:child_process');
+    const { promisify } = await import('node:util');
+    const execFileAsync = promisify(execFileCb);
+    // Try lsof first (macOS + most Linux), fall back to fuser (minimal Linux/Docker)
+    for (const cmd of [
+        { bin: 'lsof', args: ['-ti', `:${port}`] },
+        { bin: 'fuser', args: [`${port}/tcp`] },
+    ]) {
+        try {
+            const { stdout, stderr } = await execFileAsync(cmd.bin, cmd.args, { timeout: 1000 });
+            // fuser outputs to stderr on some systems
+            const output = (stdout || stderr || '').trim();
+            const pids = output.split(/\s+/).map(Number).filter(n => !Number.isNaN(n) && n > 0);
+            const otherPid = pids.find(p => p !== process.pid);
+            if (otherPid)
+                return otherPid;
+        }
+        catch {
+            continue; // command not found or no results — try next
+        }
+    }
+    return null;
+}
+/**
+ * Kill a stale process holding a port. Sends SIGTERM, waits briefly,
+ * then SIGKILL if still alive. Only kills DollhouseMCP processes
+ * (verified by checking the command line and user ownership).
+ *
+ * Timeout: 1s for ps verification. Kill wait: 300ms × 10 polls = 3s
+ * before escalating to SIGKILL. Total worst case: ~4s.
+ */
+export async function killStaleProcess(pid, port) {
+    const { execFile: execFileCb } = await import('node:child_process');
+    const { promisify } = await import('node:util');
+    const execFileAsync = promisify(execFileCb);
+    // Security verification flow — three checks must pass before we kill:
+    // 1. Process must be owned by the current OS user (prevents cross-user kills)
+    // 2. Command line must match a DollhouseMCP binary path (prevents killing other services)
+    // 3. If both fail or ps can't run, we refuse — safe default is to not kill
+    try {
+        const { stdout } = await execFileAsync('ps', ['-p', String(pid), '-o', 'user=,command='], { timeout: 1000 });
+        // Check 1: User ownership — only kill our own processes
+        const currentUser = (await import('node:os')).userInfo().username;
+        if (!stdout.trim().startsWith(currentUser)) {
+            await logger.warn(`[WebUI] Port ${port} held by different user (pid ${pid}) — not killing`);
+            return false;
+        }
+        // Check 2: Binary identity — must be .bin/mcp-server, .bin/dollhousemcp,
+        // /bin/dollhousemcp (global install), or dist/index.js (direct node execution).
+        // NOT just 'mcp-server' anywhere in the path — that would match Jest workers
+        // running from within the mcp-server project directory.
+        const cmdLine = stdout.trim();
+        const isDollhouseBin = /(?:^|\/)dollhousemcp(?:\s|$)/.test(cmdLine) ||
+            cmdLine.includes('.bin/dollhousemcp');
+        const isMcpServerBin = cmdLine.includes('.bin/mcp-server') ||
+            cmdLine.includes('dist/index.js');
+        if (!isDollhouseBin && !isMcpServerBin) {
+            await logger.warn(`[WebUI] Port ${port} held by non-DollhouseMCP process (pid ${pid}) — not killing`, { cmdLine });
+            return false;
+        }
+        await logger.debug(`[WebUI] Verified stale process ${pid} is DollhouseMCP`, { cmdLine });
+    }
+    catch (err) {
+        // Check 3: If we can't verify, don't kill — safe default
+        await logger.debug(`[WebUI] Cannot verify process ${pid} — skipping kill`, {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return false;
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+        logger.warn(`[WebUI] Sent SIGTERM to stale process ${pid} on port ${port}`);
+        for (let i = 0; i < 10; i++) {
+            await new Promise(r => setTimeout(r, 300));
+            try {
+                process.kill(pid, 0);
+            }
+            catch {
+                return true;
+            }
+        }
+        process.kill(pid, 'SIGKILL');
+        logger.warn(`[WebUI] Sent SIGKILL to stale process ${pid} on port ${port}`);
+        await new Promise(r => setTimeout(r, 500));
+        return true;
+    }
+    catch {
+        return true; // process already dead
+    }
+}
+/**
+ * Detect and recover from a stale process squatting on the port.
+ * Compares the port holder's PID against the leader lock file to determine
+ * if it's a squatter. Returns true if the squatter was killed.
+ *
+ * Timeouts: lsof 1s, ps 1s, SIGTERM wait 3s — max ~5s total.
+ */
+export async function recoverStalePort(port) {
+    const stalePid = await findPidOnPort(port);
+    if (!stalePid)
+        return false;
+    try {
+        const { readLeaderLock } = await import('./LeaderElection.js');
+        const lock = await readLeaderLock();
+        if (lock?.pid === stalePid && lock?.port === port && lock.pid !== process.pid) {
+            logger.warn(`[WebUI] Port ${port} held by legitimate leader (pid ${stalePid}) — not killing`);
+            return false;
+        }
+    }
+    catch {
+        // Can't read lock file — treat port holder as squatter
+    }
+    const killed = await killStaleProcess(stalePid, port);
+    if (killed) {
+        logger.info(`[WebUI] Stale process ${stalePid} removed from port ${port}`);
+        await new Promise(r => setTimeout(r, 500));
+    }
+    return killed;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StaleProcessRecovery.js","sourceRoot":"","sources":["../../../src/web/console/StaleProcessRecovery.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Stale process detection and recovery (#1850).\n *\n * Finds and kills zombie DollhouseMCP processes that squat on the console\n * port after their session has ended. Used by bindAndListen in server.ts\n * when EADDRINUSE occurs.\n *\n * Extracted to a standalone module so it can be tested without importing\n * the full Express server and its dependency chain.\n */\n\n// Use lazy import for logger to avoid pulling in the full env.ts/config chain\n// at module load time. This keeps the module independently testable.\nlet _logger: typeof import('../../utils/logger.js').logger | null = null;\nasync function getLogger() {\n  if (!_logger) {\n    try { _logger = (await import('../../utils/logger.js')).logger; }\n    catch { /* fallback below */ }\n  }\n  return _logger;\n}\nconst logger = {\n  warn: async (...args: unknown[]) => { const l = await getLogger(); l ? l.warn(args[0] as string, args[1]) : console.error('[WARN]', ...args); },\n  info: async (...args: unknown[]) => { const l = await getLogger(); l ? l.info(args[0] as string, args[1]) : console.error('[INFO]', ...args); },\n  debug: async (...args: unknown[]) => { const l = await getLogger(); l ? l.debug(args[0] as string, args[1]) : void 0; },\n};\n\n/**\n * Find the PID of the process listening on a given port.\n * Uses lsof on macOS/Linux. Returns null if not found or on error.\n *\n * Timeout: 1s — lsof on localhost is typically <100ms. The 1s ceiling\n * handles slow NFS-mounted /dev/fd or overloaded CI runners without\n * delaying startup noticeably.\n */\nexport async function findPidOnPort(port: number): Promise<number | null> {\n  const { execFile: execFileCb } = await import('node:child_process');\n  const { promisify } = await import('node:util');\n  const execFileAsync = promisify(execFileCb);\n\n  // Try lsof first (macOS + most Linux), fall back to fuser (minimal Linux/Docker)\n  for (const cmd of [\n    { bin: 'lsof', args: ['-ti', `:${port}`] },\n    { bin: 'fuser', args: [`${port}/tcp`] },\n  ]) {\n    try {\n      const { stdout, stderr } = await execFileAsync(cmd.bin, cmd.args, { timeout: 1000 });\n      // fuser outputs to stderr on some systems\n      const output = (stdout || stderr || '').trim();\n      const pids = output.split(/\\s+/).map(Number).filter(n => !Number.isNaN(n) && n > 0);\n      const otherPid = pids.find(p => p !== process.pid);\n      if (otherPid) return otherPid;\n    } catch {\n      continue; // command not found or no results — try next\n    }\n  }\n  return null;\n}\n\n/**\n * Kill a stale process holding a port. Sends SIGTERM, waits briefly,\n * then SIGKILL if still alive. Only kills DollhouseMCP processes\n * (verified by checking the command line and user ownership).\n *\n * Timeout: 1s for ps verification. Kill wait: 300ms × 10 polls = 3s\n * before escalating to SIGKILL. Total worst case: ~4s.\n */\nexport async function killStaleProcess(pid: number, port: number): Promise<boolean> {\n  const { execFile: execFileCb } = await import('node:child_process');\n  const { promisify } = await import('node:util');\n  const execFileAsync = promisify(execFileCb);\n\n  // Security verification flow — three checks must pass before we kill:\n  // 1. Process must be owned by the current OS user (prevents cross-user kills)\n  // 2. Command line must match a DollhouseMCP binary path (prevents killing other services)\n  // 3. If both fail or ps can't run, we refuse — safe default is to not kill\n  try {\n    const { stdout } = await execFileAsync('ps', ['-p', String(pid), '-o', 'user=,command='], { timeout: 1000 });\n\n    // Check 1: User ownership — only kill our own processes\n    const currentUser = (await import('node:os')).userInfo().username;\n    if (!stdout.trim().startsWith(currentUser)) {\n      await logger.warn(`[WebUI] Port ${port} held by different user (pid ${pid}) — not killing`);\n      return false;\n    }\n\n    // Check 2: Binary identity — must be .bin/mcp-server, .bin/dollhousemcp,\n    // /bin/dollhousemcp (global install), or dist/index.js (direct node execution).\n    // NOT just 'mcp-server' anywhere in the path — that would match Jest workers\n    // running from within the mcp-server project directory.\n    const cmdLine = stdout.trim();\n    const isDollhouseBin = /(?:^|\\/)dollhousemcp(?:\\s|$)/.test(cmdLine) ||\n      cmdLine.includes('.bin/dollhousemcp');\n    const isMcpServerBin = cmdLine.includes('.bin/mcp-server') ||\n      cmdLine.includes('dist/index.js');\n    if (!isDollhouseBin && !isMcpServerBin) {\n      await logger.warn(`[WebUI] Port ${port} held by non-DollhouseMCP process (pid ${pid}) — not killing`, { cmdLine });\n      return false;\n    }\n    await logger.debug(`[WebUI] Verified stale process ${pid} is DollhouseMCP`, { cmdLine });\n  } catch (err) {\n    // Check 3: If we can't verify, don't kill — safe default\n    await logger.debug(`[WebUI] Cannot verify process ${pid} — skipping kill`, {\n      error: err instanceof Error ? err.message : String(err),\n    });\n    return false;\n  }\n\n  try {\n    process.kill(pid, 'SIGTERM');\n    logger.warn(`[WebUI] Sent SIGTERM to stale process ${pid} on port ${port}`);\n    for (let i = 0; i < 10; i++) {\n      await new Promise(r => setTimeout(r, 300));\n      try { process.kill(pid, 0); } catch { return true; }\n    }\n    process.kill(pid, 'SIGKILL');\n    logger.warn(`[WebUI] Sent SIGKILL to stale process ${pid} on port ${port}`);\n    await new Promise(r => setTimeout(r, 500));\n    return true;\n  } catch {\n    return true; // process already dead\n  }\n}\n\n/**\n * Detect and recover from a stale process squatting on the port.\n * Compares the port holder's PID against the leader lock file to determine\n * if it's a squatter. Returns true if the squatter was killed.\n *\n * Timeouts: lsof 1s, ps 1s, SIGTERM wait 3s — max ~5s total.\n */\nexport async function recoverStalePort(port: number): Promise<boolean> {\n  const stalePid = await findPidOnPort(port);\n  if (!stalePid) return false;\n\n  try {\n    const { readLeaderLock } = await import('./LeaderElection.js');\n    const lock = await readLeaderLock();\n    if (lock?.pid === stalePid && lock?.port === port && lock.pid !== process.pid) {\n      logger.warn(`[WebUI] Port ${port} held by legitimate leader (pid ${stalePid}) — not killing`);\n      return false;\n    }\n  } catch {\n    // Can't read lock file — treat port holder as squatter\n  }\n\n  const killed = await killStaleProcess(stalePid, port);\n  if (killed) {\n    logger.info(`[WebUI] Stale process ${stalePid} removed from port ${port}`);\n    await new Promise(r => setTimeout(r, 500));\n  }\n  return killed;\n}\n"]}

package/dist/web/console/UnifiedConsole.js

@@ -148,27 +148,11 @@ async function startAsLeader(options, election, consolePort = DEFAULT_CONSOLE_PO
         tokenStore,
         ...(options.mcpAqlHandler ? { mcpAqlHandler: options.mcpAqlHandler } : {}),
     };
-    const BIND_RETRY_DELAYS = env.DOLLHOUSE_CONSOLE_BIND_RETRY_DELAYS?.length
-        ? env.DOLLHOUSE_CONSOLE_BIND_RETRY_DELAYS
-        : [1000, 2000, 4000];
+    // bindAndListen now handles EADDRINUSE by finding and killing the stale
+    // process on the port, then retrying. No external retry loop needed.
     const webResult = await startWebServer(serverOpts);
-    // If the port is occupied, retry the bind only — don't recreate the Express
-    // app and routes (startWebServer early-returns when serverRunning is false
-    // but the app is already configured). We call retryBind on the existing app.
-    if (webResult.bindResult && !webResult.bindResult.success && webResult.bindResult.error === 'EADDRINUSE' && webResult.app) {
-        const { retryBind } = await import('../server.js');
-        for (let i = 0; i < BIND_RETRY_DELAYS.length; i++) {
-            logger.warn(`[UnifiedConsole] Port ${consolePort} occupied — retry ${i + 1}/${BIND_RETRY_DELAYS.length} in ${BIND_RETRY_DELAYS[i]}ms`);
-            await new Promise(r => setTimeout(r, BIND_RETRY_DELAYS[i]));
-            const retryResult = await retryBind(webResult.app, consolePort, serverOpts);
-            if (retryResult.success) {
-                webResult.bindResult = retryResult;
-                break;
-            }
-        }
-        if (webResult.bindResult && !webResult.bindResult.success) {
-            logger.error(`[UnifiedConsole] Leader failed to bind port ${consolePort} after ${BIND_RETRY_DELAYS.length} retries — console unavailable`);
-        }
+    if (webResult.bindResult && !webResult.bindResult.success) {
+        logger.error(`[UnifiedConsole] Leader failed to bind port ${consolePort} — console unavailable`);
     }
     // Wire SSE broadcasts for this leader's own events
     options.wireSSEBroadcasts(webResult, options.metricsSink);
@@ -248,4 +232,4 @@ async function startAsFollower(options, election, consolePort = DEFAULT_CONSOLE_
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UnifiedConsole.js","sourceRoot":"","sources":["../../../src/web/console/UnifiedConsole.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unified web console orchestrator.\n *\n * Ties together leader election, console startup, follower wiring,\n * and session lifecycle management. This is the main entry point\n * called by the DI container during deferred setup.\n *\n * Flow:\n * 1. Run leader election (read lock file, claim or follow)\n * 2. If leader: start web server on fixed port, mount ingest routes, start heartbeat\n * 3. If follower: register forwarding sinks with LogManager, start session heartbeat\n *\n * @since v2.1.0 — Issue #1700\n */\n\nimport type { UnifiedLogEntry } from '../../logging/types.js';\nimport type { MetricSnapshot } from '../../metrics/types.js';\nimport type { MemoryLogSink } from '../../logging/sinks/MemoryLogSink.js';\nimport type { MemoryMetricsSink } from '../../metrics/sinks/MemoryMetricsSink.js';\nimport { logger } from '../../utils/logger.js';\nimport {\n  electLeader,\n  isLeaderWebConsoleReachable,\n  forceClaimLeadership,\n  startHeartbeat,\n  registerLeaderCleanup,\n  detectLegacyLeader,\n  type ElectionResult,\n} from './LeaderElection.js';\nimport { createIngestRoutes } from './IngestRoutes.js';\nimport {\n  LeaderForwardingLogSink,\n  SessionHeartbeat,\n} from './LeaderForwardingSink.js';\nimport { PromotionManager } from './PromotionManager.js';\nimport { ConsoleTokenStore } from './consoleToken.js';\nimport { env } from '../../config/env.js';\n\n/**\n * Default console port from the env var. Used as fallback when no port\n * is provided via config file or options. The resolution hierarchy is:\n *   1. options.port (from config file, resolved by the DI container)\n *   2. DOLLHOUSE_WEB_CONSOLE_PORT env var\n *   3. 41715 (hardcoded default in env.ts)\n */\nconst DEFAULT_CONSOLE_PORT = env.DOLLHOUSE_WEB_CONSOLE_PORT;\n\n/**\n * Options for starting the unified console.\n */\nexport interface UnifiedConsoleOptions {\n  /** This process's unique session ID */\n  sessionId: string;\n  /** Portfolio base directory (for startWebServer) */\n  portfolioDir: string;\n  /** Log memory sink (for console history) */\n  memorySink: MemoryLogSink;\n  /** Metrics memory sink */\n  metricsSink?: MemoryMetricsSink;\n  /** MCP-AQL handler for permission routes (typed as any to avoid circular imports) */\n  mcpAqlHandler?: any;\n  /** Callback to register a log sink with the LogManager */\n  registerLogSink: (sink: { write(entry: UnifiedLogEntry): void; flush(): Promise<void>; close(): Promise<void> }) => void;\n  /** Callback to wire SSE broadcasts after web server starts */\n  wireSSEBroadcasts: (webResult: { logBroadcast?: (entry: UnifiedLogEntry) => void; metricsOnSnapshot?: (snapshot: MetricSnapshot) => void }, metricsSink?: MemoryMetricsSink) => void;\n  /** Console port override from config file. Falls back to env var if not provided. */\n  port?: number;\n}\n\n/**\n * Result of starting the unified console.\n */\nexport interface UnifiedConsoleResult {\n  role: 'leader' | 'follower';\n  election: ElectionResult;\n  /** Port the console is running on (leader only) */\n  port?: number;\n  /** Cleanup function to call on shutdown */\n  cleanup: () => Promise<void>;\n}\n\n/**\n * Check for a running legacy (pre-authentication) DollhouseMCP console and\n * log a WARN-level message if one is found (#1794).\n *\n * Extracted from `startUnifiedConsole` so the wiring can be integration-\n * tested in isolation without spinning up a full web server and leader\n * election. The implementation is fire-and-forget: detection failures\n * are logged at DEBUG and never propagate, because a failure here must\n * not block leader election of the authenticated console.\n *\n * @param currentPort - The port the authenticated console intends to\n *                      bind to. Used in the warning message to help the\n *                      user tell the two consoles apart.\n * @param detect      - Optional injection point for the detection\n *                      function. Defaults to `detectLegacyLeader`. Tests\n *                      pass a stub.\n * @param log         - Optional injection point for the logger. Defaults\n *                      to the module logger. Tests pass a spy.\n * @returns The legacy leader info from `detect()`, or null if detection\n *          threw. Exposed so tests can assert the full result shape.\n */\nexport async function warnIfLegacyConsolePresent(\n  currentPort: number,\n  detect: typeof detectLegacyLeader = detectLegacyLeader,\n  log: typeof logger = logger,\n): Promise<Awaited<ReturnType<typeof detectLegacyLeader>> | null> {\n  try {\n    const legacy = await detect();\n    if (legacy.legacyRunning) {\n      log.warn(\n        `[UnifiedConsole] Legacy (pre-authentication) DollhouseMCP console detected ` +\n        `(pid=${legacy.pid}, port=${legacy.port}). Both consoles will run ` +\n        `independently on different ports with different security posture. ` +\n        `The authenticated console (this process) uses port ${currentPort}; ` +\n        `the legacy console uses port ${legacy.port ?? 3939}. ` +\n        `For consistent security, update the legacy installation to a ` +\n        `version with the authenticated console.`,\n      );\n    }\n    return legacy;\n  } catch (err) {\n    // Best-effort — never block election on a detection failure\n    log.debug('[UnifiedConsole] Legacy leader detection failed', {\n      error: err instanceof Error ? err.message : String(err),\n    });\n    return null;\n  }\n}\n\n/**\n * Start the unified web console.\n *\n * Runs leader election, then either starts the full console (leader)\n * or sets up event forwarding (follower).\n */\nexport async function startUnifiedConsole(options: UnifiedConsoleOptions): Promise<UnifiedConsoleResult> {\n  // Resolve port: options (config file) → env var → default\n  const consolePort = options.port || DEFAULT_CONSOLE_PORT;\n  logger.debug(`[UnifiedConsole] Port resolved: ${consolePort}` +\n    (options.port ? ' (from config file)' : ` (from env/default)`));\n\n  // Legacy-leader detection (#1794) — warn the user if a pre-auth\n  // DollhouseMCP console is running alongside this authenticated one.\n  // They will coexist fine because of port + lock + token file isolation,\n  // but the user should know both exist so the differing security posture\n  // between them doesn't look like a bug.\n  await warnIfLegacyConsolePresent(consolePort);\n\n  let election = await electLeader(options.sessionId, consolePort);\n\n  // If we lost the election, check if the leader is actually running a web console.\n  // An MCP stdio process may hold leadership but not serve web routes.\n  // In that case, force a takeover so the web console works properly.\n  if (election.role === 'follower') {\n    const reachable = await isLeaderWebConsoleReachable(election.leaderInfo);\n    if (!reachable) {\n      election = await forceClaimLeadership(options.sessionId, consolePort);\n    }\n  }\n\n  if (election.role === 'leader') {\n    return startAsLeader(options, election, consolePort);\n  } else {\n    return startAsFollower(options, election, consolePort);\n  }\n}\n\n/**\n * Start as the console leader.\n * Binds the resolved console port (config file → env var → default),\n * mounts all routes including ingestion, starts heartbeat.\n */\nasync function startAsLeader(\n  options: UnifiedConsoleOptions,\n  election: ElectionResult,\n  consolePort: number = DEFAULT_CONSOLE_PORT,\n): Promise<UnifiedConsoleResult> {\n  const { startWebServer } = await import('../server.js');\n  const { pickRandomPuppetName } = await import('./SessionNames.js');\n\n  // Initialize the console token store (#1780). Creates the token file on\n  // first run, reads the existing tokens on subsequent runs. The token is\n  // persistent across restarts — only rotated on explicit request (Phase 2).\n  // Feature flag DOLLHOUSE_WEB_AUTH_ENABLED controls enforcement; the file\n  // is generated regardless so consumers can attach tokens preemptively.\n  const tokenStore = new ConsoleTokenStore(env.DOLLHOUSE_CONSOLE_TOKEN_FILE);\n  const primaryToken = await tokenStore.ensureInitialized(pickRandomPuppetName());\n  logger.info('[UnifiedConsole] Console token store initialized', {\n    tokenId: primaryToken.id,\n    tokenName: primaryToken.name,\n    file: tokenStore.getFilePath(),\n    authEnforced: env.DOLLHOUSE_WEB_AUTH_ENABLED,\n  });\n\n  // Pre-create a placeholder broadcast that we'll wire up after the server starts\n  let liveBroadcast: ((entry: UnifiedLogEntry) => void) | undefined;\n  let liveMetricsOnSnapshot: ((snapshot: MetricSnapshot) => void) | undefined;\n\n  // Create ingestion routes with a deferred broadcast (wired after server starts)\n  const ingestResult = createIngestRoutes({\n    logBroadcast: (entry) => liveBroadcast?.(entry),\n    metricsOnSnapshot: (snapshot) => liveMetricsOnSnapshot?.(snapshot),\n  });\n\n  // Register the leader as a session\n  ingestResult.registerLeaderSession(options.sessionId, process.pid);\n\n  // Register the web console itself so the session indicator is never empty (#1805)\n  ingestResult.registerConsoleSession();\n\n  // Start the web server with ingest routes mounted before the SPA fallback.\n  // If the port is occupied by a stale process, retry with exponential backoff.\n  const serverOpts = {\n    portfolioDir: options.portfolioDir,\n    memorySink: options.memorySink,\n    metricsSink: options.metricsSink,\n    port: consolePort,\n    additionalRouters: [ingestResult.router],\n    tokenStore,\n    ...(options.mcpAqlHandler ? { mcpAqlHandler: options.mcpAqlHandler } : {}),\n  };\n  const BIND_RETRY_DELAYS = env.DOLLHOUSE_CONSOLE_BIND_RETRY_DELAYS?.length\n    ? env.DOLLHOUSE_CONSOLE_BIND_RETRY_DELAYS\n    : [1000, 2000, 4000];\n  const webResult = await startWebServer(serverOpts);\n\n  // If the port is occupied, retry the bind only — don't recreate the Express\n  // app and routes (startWebServer early-returns when serverRunning is false\n  // but the app is already configured). We call retryBind on the existing app.\n  if (webResult.bindResult && !webResult.bindResult.success && webResult.bindResult.error === 'EADDRINUSE' && webResult.app) {\n    const { retryBind } = await import('../server.js');\n    for (let i = 0; i < BIND_RETRY_DELAYS.length; i++) {\n      logger.warn(`[UnifiedConsole] Port ${consolePort} occupied — retry ${i + 1}/${BIND_RETRY_DELAYS.length} in ${BIND_RETRY_DELAYS[i]}ms`);\n      await new Promise(r => setTimeout(r, BIND_RETRY_DELAYS[i]));\n      const retryResult = await retryBind(webResult.app, consolePort, serverOpts);\n      if (retryResult.success) {\n        webResult.bindResult = retryResult;\n        break;\n      }\n    }\n    if (webResult.bindResult && !webResult.bindResult.success) {\n      logger.error(`[UnifiedConsole] Leader failed to bind port ${consolePort} after ${BIND_RETRY_DELAYS.length} retries — console unavailable`);\n    }\n  }\n\n  // Wire SSE broadcasts for this leader's own events\n  options.wireSSEBroadcasts(webResult, options.metricsSink);\n\n  // Now wire the live broadcast functions into the ingest routes\n  if (webResult.logBroadcast) {\n    const originalBroadcast = webResult.logBroadcast;\n    // Stamp leader's own entries with session ID\n    liveBroadcast = (entry: UnifiedLogEntry) => {\n      const stamped: UnifiedLogEntry = {\n        ...entry,\n        data: { ...entry.data, _sessionId: options.sessionId },\n      };\n      originalBroadcast(stamped);\n    };\n  }\n  liveMetricsOnSnapshot = webResult.metricsOnSnapshot;\n\n  logger.info('[UnifiedConsole] Ingestion routes mounted');\n\n  // Start heartbeat and register cleanup\n  const stopHeartbeat = startHeartbeat(election.leaderInfo);\n  registerLeaderCleanup();\n\n  logger.info('[UnifiedConsole] Leader started', {\n    sessionId: options.sessionId, port: consolePort, pid: process.pid,\n    role: 'leader', ingestRoutes: ['/api/ingest/logs', '/api/ingest/metrics', '/api/ingest/session', '/api/sessions'],\n  });\n\n  return {\n    role: 'leader',\n    election,\n    port: consolePort,\n    cleanup: async () => {\n      stopHeartbeat();\n    },\n  };\n}\n\n/**\n * Start as a follower.\n * Registers forwarding sinks with the LogManager, starts session heartbeat.\n */\nasync function startAsFollower(\n  options: UnifiedConsoleOptions,\n  election: ElectionResult,\n  consolePort: number = DEFAULT_CONSOLE_PORT,\n): Promise<UnifiedConsoleResult> {\n  const leaderUrl = `http://127.0.0.1:${election.leaderInfo.port}`;\n\n  // Read the console auth token (#1780) written by the leader. May be null\n  // if the file doesn't exist yet — the sinks handle that gracefully and\n  // simply omit the Bearer header, which is fine when auth is not enforced.\n  const { getPrimaryTokenFromFile } = await import('./consoleToken.js');\n  const authToken = await getPrimaryTokenFromFile(env.DOLLHOUSE_CONSOLE_TOKEN_FILE);\n  if (authToken) {\n    logger.debug('[UnifiedConsole] Follower loaded console auth token');\n  } else {\n    logger.debug('[UnifiedConsole] No console auth token file found; follower will POST without Bearer header');\n  }\n\n  // Per-instance promotion manager — tracks its own attempt counter so\n  // multiple followers don't interfere with each other's promotion budgets.\n  const promotionMgr = new PromotionManager(options, consolePort, startAsLeader, startAsFollower);\n\n  // Declare sessionHeartbeat before the sink so the closure can capture it.\n  // Both are initialized before the callback could possibly fire (needs 5+ failed flushes).\n  let sessionHeartbeat: SessionHeartbeat;\n\n  // Register a forwarding log sink with leader-death callback (#1850).\n  const forwardingSink = new LeaderForwardingLogSink(leaderUrl, options.sessionId, authToken, () => {\n    promotionMgr.promote(forwardingSink, sessionHeartbeat)\n      .catch(err => logger.error('[UnifiedConsole] Promotion crashed', { error: String(err) }));\n  });\n  options.registerLogSink(forwardingSink);\n\n  // Start session heartbeat to the leader\n  sessionHeartbeat = new SessionHeartbeat(leaderUrl, options.sessionId, process.pid, authToken);\n  await sessionHeartbeat.start();\n\n  logger.info('[UnifiedConsole] Follower started', {\n    sessionId: options.sessionId, pid: process.pid, role: 'follower',\n    leaderSession: election.leaderInfo.sessionId, leaderPid: election.leaderInfo.pid,\n    leaderPort: election.leaderInfo.port, leaderUrl,\n  });\n\n  return {\n    role: 'follower',\n    election,\n    cleanup: async () => {\n      await sessionHeartbeat.stop();\n      await forwardingSink.close();\n    },\n  };\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UnifiedConsole.js","sourceRoot":"","sources":["../../../src/web/console/UnifiedConsole.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unified web console orchestrator.\n *\n * Ties together leader election, console startup, follower wiring,\n * and session lifecycle management. This is the main entry point\n * called by the DI container during deferred setup.\n *\n * Flow:\n * 1. Run leader election (read lock file, claim or follow)\n * 2. If leader: start web server on fixed port, mount ingest routes, start heartbeat\n * 3. If follower: register forwarding sinks with LogManager, start session heartbeat\n *\n * @since v2.1.0 — Issue #1700\n */\n\nimport type { UnifiedLogEntry } from '../../logging/types.js';\nimport type { MetricSnapshot } from '../../metrics/types.js';\nimport type { MemoryLogSink } from '../../logging/sinks/MemoryLogSink.js';\nimport type { MemoryMetricsSink } from '../../metrics/sinks/MemoryMetricsSink.js';\nimport { logger } from '../../utils/logger.js';\nimport {\n  electLeader,\n  isLeaderWebConsoleReachable,\n  forceClaimLeadership,\n  startHeartbeat,\n  registerLeaderCleanup,\n  detectLegacyLeader,\n  type ElectionResult,\n} from './LeaderElection.js';\nimport { createIngestRoutes } from './IngestRoutes.js';\nimport {\n  LeaderForwardingLogSink,\n  SessionHeartbeat,\n} from './LeaderForwardingSink.js';\nimport { PromotionManager } from './PromotionManager.js';\nimport { ConsoleTokenStore } from './consoleToken.js';\nimport { env } from '../../config/env.js';\n\n/**\n * Default console port from the env var. Used as fallback when no port\n * is provided via config file or options. The resolution hierarchy is:\n *   1. options.port (from config file, resolved by the DI container)\n *   2. DOLLHOUSE_WEB_CONSOLE_PORT env var\n *   3. 41715 (hardcoded default in env.ts)\n */\nconst DEFAULT_CONSOLE_PORT = env.DOLLHOUSE_WEB_CONSOLE_PORT;\n\n/**\n * Options for starting the unified console.\n */\nexport interface UnifiedConsoleOptions {\n  /** This process's unique session ID */\n  sessionId: string;\n  /** Portfolio base directory (for startWebServer) */\n  portfolioDir: string;\n  /** Log memory sink (for console history) */\n  memorySink: MemoryLogSink;\n  /** Metrics memory sink */\n  metricsSink?: MemoryMetricsSink;\n  /** MCP-AQL handler for permission routes (typed as any to avoid circular imports) */\n  mcpAqlHandler?: any;\n  /** Callback to register a log sink with the LogManager */\n  registerLogSink: (sink: { write(entry: UnifiedLogEntry): void; flush(): Promise<void>; close(): Promise<void> }) => void;\n  /** Callback to wire SSE broadcasts after web server starts */\n  wireSSEBroadcasts: (webResult: { logBroadcast?: (entry: UnifiedLogEntry) => void; metricsOnSnapshot?: (snapshot: MetricSnapshot) => void }, metricsSink?: MemoryMetricsSink) => void;\n  /** Console port override from config file. Falls back to env var if not provided. */\n  port?: number;\n}\n\n/**\n * Result of starting the unified console.\n */\nexport interface UnifiedConsoleResult {\n  role: 'leader' | 'follower';\n  election: ElectionResult;\n  /** Port the console is running on (leader only) */\n  port?: number;\n  /** Cleanup function to call on shutdown */\n  cleanup: () => Promise<void>;\n}\n\n/**\n * Check for a running legacy (pre-authentication) DollhouseMCP console and\n * log a WARN-level message if one is found (#1794).\n *\n * Extracted from `startUnifiedConsole` so the wiring can be integration-\n * tested in isolation without spinning up a full web server and leader\n * election. The implementation is fire-and-forget: detection failures\n * are logged at DEBUG and never propagate, because a failure here must\n * not block leader election of the authenticated console.\n *\n * @param currentPort - The port the authenticated console intends to\n *                      bind to. Used in the warning message to help the\n *                      user tell the two consoles apart.\n * @param detect      - Optional injection point for the detection\n *                      function. Defaults to `detectLegacyLeader`. Tests\n *                      pass a stub.\n * @param log         - Optional injection point for the logger. Defaults\n *                      to the module logger. Tests pass a spy.\n * @returns The legacy leader info from `detect()`, or null if detection\n *          threw. Exposed so tests can assert the full result shape.\n */\nexport async function warnIfLegacyConsolePresent(\n  currentPort: number,\n  detect: typeof detectLegacyLeader = detectLegacyLeader,\n  log: typeof logger = logger,\n): Promise<Awaited<ReturnType<typeof detectLegacyLeader>> | null> {\n  try {\n    const legacy = await detect();\n    if (legacy.legacyRunning) {\n      log.warn(\n        `[UnifiedConsole] Legacy (pre-authentication) DollhouseMCP console detected ` +\n        `(pid=${legacy.pid}, port=${legacy.port}). Both consoles will run ` +\n        `independently on different ports with different security posture. ` +\n        `The authenticated console (this process) uses port ${currentPort}; ` +\n        `the legacy console uses port ${legacy.port ?? 3939}. ` +\n        `For consistent security, update the legacy installation to a ` +\n        `version with the authenticated console.`,\n      );\n    }\n    return legacy;\n  } catch (err) {\n    // Best-effort — never block election on a detection failure\n    log.debug('[UnifiedConsole] Legacy leader detection failed', {\n      error: err instanceof Error ? err.message : String(err),\n    });\n    return null;\n  }\n}\n\n/**\n * Start the unified web console.\n *\n * Runs leader election, then either starts the full console (leader)\n * or sets up event forwarding (follower).\n */\nexport async function startUnifiedConsole(options: UnifiedConsoleOptions): Promise<UnifiedConsoleResult> {\n  // Resolve port: options (config file) → env var → default\n  const consolePort = options.port || DEFAULT_CONSOLE_PORT;\n  logger.debug(`[UnifiedConsole] Port resolved: ${consolePort}` +\n    (options.port ? ' (from config file)' : ` (from env/default)`));\n\n  // Legacy-leader detection (#1794) — warn the user if a pre-auth\n  // DollhouseMCP console is running alongside this authenticated one.\n  // They will coexist fine because of port + lock + token file isolation,\n  // but the user should know both exist so the differing security posture\n  // between them doesn't look like a bug.\n  await warnIfLegacyConsolePresent(consolePort);\n\n  let election = await electLeader(options.sessionId, consolePort);\n\n  // If we lost the election, check if the leader is actually running a web console.\n  // An MCP stdio process may hold leadership but not serve web routes.\n  // In that case, force a takeover so the web console works properly.\n  if (election.role === 'follower') {\n    const reachable = await isLeaderWebConsoleReachable(election.leaderInfo);\n    if (!reachable) {\n      election = await forceClaimLeadership(options.sessionId, consolePort);\n    }\n  }\n\n  if (election.role === 'leader') {\n    return startAsLeader(options, election, consolePort);\n  } else {\n    return startAsFollower(options, election, consolePort);\n  }\n}\n\n/**\n * Start as the console leader.\n * Binds the resolved console port (config file → env var → default),\n * mounts all routes including ingestion, starts heartbeat.\n */\nasync function startAsLeader(\n  options: UnifiedConsoleOptions,\n  election: ElectionResult,\n  consolePort: number = DEFAULT_CONSOLE_PORT,\n): Promise<UnifiedConsoleResult> {\n  const { startWebServer } = await import('../server.js');\n  const { pickRandomPuppetName } = await import('./SessionNames.js');\n\n  // Initialize the console token store (#1780). Creates the token file on\n  // first run, reads the existing tokens on subsequent runs. The token is\n  // persistent across restarts — only rotated on explicit request (Phase 2).\n  // Feature flag DOLLHOUSE_WEB_AUTH_ENABLED controls enforcement; the file\n  // is generated regardless so consumers can attach tokens preemptively.\n  const tokenStore = new ConsoleTokenStore(env.DOLLHOUSE_CONSOLE_TOKEN_FILE);\n  const primaryToken = await tokenStore.ensureInitialized(pickRandomPuppetName());\n  logger.info('[UnifiedConsole] Console token store initialized', {\n    tokenId: primaryToken.id,\n    tokenName: primaryToken.name,\n    file: tokenStore.getFilePath(),\n    authEnforced: env.DOLLHOUSE_WEB_AUTH_ENABLED,\n  });\n\n  // Pre-create a placeholder broadcast that we'll wire up after the server starts\n  let liveBroadcast: ((entry: UnifiedLogEntry) => void) | undefined;\n  let liveMetricsOnSnapshot: ((snapshot: MetricSnapshot) => void) | undefined;\n\n  // Create ingestion routes with a deferred broadcast (wired after server starts)\n  const ingestResult = createIngestRoutes({\n    logBroadcast: (entry) => liveBroadcast?.(entry),\n    metricsOnSnapshot: (snapshot) => liveMetricsOnSnapshot?.(snapshot),\n  });\n\n  // Register the leader as a session\n  ingestResult.registerLeaderSession(options.sessionId, process.pid);\n\n  // Register the web console itself so the session indicator is never empty (#1805)\n  ingestResult.registerConsoleSession();\n\n  // Start the web server with ingest routes mounted before the SPA fallback.\n  // If the port is occupied by a stale process, retry with exponential backoff.\n  const serverOpts = {\n    portfolioDir: options.portfolioDir,\n    memorySink: options.memorySink,\n    metricsSink: options.metricsSink,\n    port: consolePort,\n    additionalRouters: [ingestResult.router],\n    tokenStore,\n    ...(options.mcpAqlHandler ? { mcpAqlHandler: options.mcpAqlHandler } : {}),\n  };\n  // bindAndListen now handles EADDRINUSE by finding and killing the stale\n  // process on the port, then retrying. No external retry loop needed.\n  const webResult = await startWebServer(serverOpts);\n\n  if (webResult.bindResult && !webResult.bindResult.success) {\n    logger.error(`[UnifiedConsole] Leader failed to bind port ${consolePort} — console unavailable`);\n  }\n\n  // Wire SSE broadcasts for this leader's own events\n  options.wireSSEBroadcasts(webResult, options.metricsSink);\n\n  // Now wire the live broadcast functions into the ingest routes\n  if (webResult.logBroadcast) {\n    const originalBroadcast = webResult.logBroadcast;\n    // Stamp leader's own entries with session ID\n    liveBroadcast = (entry: UnifiedLogEntry) => {\n      const stamped: UnifiedLogEntry = {\n        ...entry,\n        data: { ...entry.data, _sessionId: options.sessionId },\n      };\n      originalBroadcast(stamped);\n    };\n  }\n  liveMetricsOnSnapshot = webResult.metricsOnSnapshot;\n\n  logger.info('[UnifiedConsole] Ingestion routes mounted');\n\n  // Start heartbeat and register cleanup\n  const stopHeartbeat = startHeartbeat(election.leaderInfo);\n  registerLeaderCleanup();\n\n  logger.info('[UnifiedConsole] Leader started', {\n    sessionId: options.sessionId, port: consolePort, pid: process.pid,\n    role: 'leader', ingestRoutes: ['/api/ingest/logs', '/api/ingest/metrics', '/api/ingest/session', '/api/sessions'],\n  });\n\n  return {\n    role: 'leader',\n    election,\n    port: consolePort,\n    cleanup: async () => {\n      stopHeartbeat();\n    },\n  };\n}\n\n/**\n * Start as a follower.\n * Registers forwarding sinks with the LogManager, starts session heartbeat.\n */\nasync function startAsFollower(\n  options: UnifiedConsoleOptions,\n  election: ElectionResult,\n  consolePort: number = DEFAULT_CONSOLE_PORT,\n): Promise<UnifiedConsoleResult> {\n  const leaderUrl = `http://127.0.0.1:${election.leaderInfo.port}`;\n\n  // Read the console auth token (#1780) written by the leader. May be null\n  // if the file doesn't exist yet — the sinks handle that gracefully and\n  // simply omit the Bearer header, which is fine when auth is not enforced.\n  const { getPrimaryTokenFromFile } = await import('./consoleToken.js');\n  const authToken = await getPrimaryTokenFromFile(env.DOLLHOUSE_CONSOLE_TOKEN_FILE);\n  if (authToken) {\n    logger.debug('[UnifiedConsole] Follower loaded console auth token');\n  } else {\n    logger.debug('[UnifiedConsole] No console auth token file found; follower will POST without Bearer header');\n  }\n\n  // Per-instance promotion manager — tracks its own attempt counter so\n  // multiple followers don't interfere with each other's promotion budgets.\n  const promotionMgr = new PromotionManager(options, consolePort, startAsLeader, startAsFollower);\n\n  // Declare sessionHeartbeat before the sink so the closure can capture it.\n  // Both are initialized before the callback could possibly fire (needs 5+ failed flushes).\n  let sessionHeartbeat: SessionHeartbeat;\n\n  // Register a forwarding log sink with leader-death callback (#1850).\n  const forwardingSink = new LeaderForwardingLogSink(leaderUrl, options.sessionId, authToken, () => {\n    promotionMgr.promote(forwardingSink, sessionHeartbeat)\n      .catch(err => logger.error('[UnifiedConsole] Promotion crashed', { error: String(err) }));\n  });\n  options.registerLogSink(forwardingSink);\n\n  // Start session heartbeat to the leader\n  sessionHeartbeat = new SessionHeartbeat(leaderUrl, options.sessionId, process.pid, authToken);\n  await sessionHeartbeat.start();\n\n  logger.info('[UnifiedConsole] Follower started', {\n    sessionId: options.sessionId, pid: process.pid, role: 'follower',\n    leaderSession: election.leaderInfo.sessionId, leaderPid: election.leaderInfo.pid,\n    leaderPort: election.leaderInfo.port, leaderUrl,\n  });\n\n  return {\n    role: 'follower',\n    election,\n    cleanup: async () => {\n      await sessionHeartbeat.stop();\n      await forwardingSink.close();\n    },\n  };\n}\n\n"]}

package/dist/web/server.d.ts

@@ -104,12 +104,7 @@ export interface BrowserOpenResult {
  * @returns Hooks for DI wiring (log broadcast, metrics onSnapshot)
  */
 export declare function startWebServer(options: WebServerOptions): Promise<WebServerResult>;
-/**
- * Retry binding an already-configured Express app to a port.
- * Used by UnifiedConsole when EADDRINUSE occurs — avoids recreating
- * the Express app and all its routes on each retry attempt.
- */
-export declare function retryBind(app: import('express').Express, port: number, options: WebServerOptions): Promise<BindResult>;
+export { findPidOnPort, killStaleProcess, recoverStalePort } from './console/StaleProcessRecovery.js';
 /**
  * Open the portfolio browser from within the MCP server process.
  *

package/dist/web/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/web/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAiBH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAyCnE,qEAAqE;AACrE,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAQxC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,0FAA0F;IAC1F,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,YAAY,EAAE,MAAM,CAAC;IACrB,qEAAqE;IACrE,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,kFAAkF;IAClF,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,6FAA6F;IAC7F,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,gFAAgF;IAChF,iBAAiB,CAAC,EAAE,OAAO,SAAS,EAAE,MAAM,EAAE,CAAC;IAC/C;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,kFAAkF;IAClF,GAAG,CAAC,EAAE,OAAO,SAAS,EAAE,OAAO,CAAC;IAChC,2EAA2E;IAC3E,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,qBAAqB,EAAE,eAAe,KAAK,IAAI,CAAC;IAC9E,iFAAiF;IACjF,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,qBAAqB,EAAE,cAAc,KAAK,IAAI,CAAC;IACrF,yCAAyC;IACzC,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,4EAA4E;IAC5E,cAAc,EAAE,OAAO,CAAC;IACxB,kDAAkD;IAClD,aAAa,EAAE,OAAO,CAAC;IACvB,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAsCD;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAuNxF;AA2DD;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,OAAO,SAAS,EAAE,OAAO,EAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,UAAU,CAAC,CAErB;AAmDD;;;;;;;;;;;;GAYG;AACH;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,WAAW,CAAC,EAAE,iBAAiB,CAAC;CACjC;AAmDD,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CA4BlG"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/web/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAiBH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAyCnE,qEAAqE;AACrE,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAQxC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,0FAA0F;IAC1F,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,YAAY,EAAE,MAAM,CAAC;IACrB,qEAAqE;IACrE,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,kFAAkF;IAClF,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,6FAA6F;IAC7F,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,gFAAgF;IAChF,iBAAiB,CAAC,EAAE,OAAO,SAAS,EAAE,MAAM,EAAE,CAAC;IAC/C;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,kFAAkF;IAClF,GAAG,CAAC,EAAE,OAAO,SAAS,EAAE,OAAO,CAAC;IAChC,2EAA2E;IAC3E,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,qBAAqB,EAAE,eAAe,KAAK,IAAI,CAAC;IAC9E,iFAAiF;IACjF,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,qBAAqB,EAAE,cAAc,KAAK,IAAI,CAAC;IACrF,yCAAyC;IACzC,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,4EAA4E;IAC5E,cAAc,EAAE,OAAO,CAAC;IACxB,kDAAkD;IAClD,aAAa,EAAE,OAAO,CAAC;IACvB,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAsCD;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAuNxF;AA6DD,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AA2DtG;;;;;;;;;;;;GAYG;AACH;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,WAAW,CAAC,EAAE,iBAAiB,CAAC;CACjC;AAmDD,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CA4BlG"}

package/dist/web/server.js

@@ -370,20 +370,13 @@ function printStartupBanner(port, tokenStore) {
     }
     console.error(`  Type "q" or "quit" to exit.\n`);
 }
+// Stale process recovery — extracted to StaleProcessRecovery.ts for independent testing (#1850).
+import { recoverStalePort } from './console/StaleProcessRecovery.js';
+export { findPidOnPort, killStaleProcess, recoverStalePort } from './console/StaleProcessRecovery.js';
 /**
- * Retry binding an already-configured Express app to a port.
- * Used by UnifiedConsole when EADDRINUSE occurs — avoids recreating
- * the Express app and all its routes on each retry attempt.
+ * Attempt a single port bind. Returns a BindResult without any recovery logic.
  */
-export async function retryBind(app, port, options) {
-    return bindAndListen(app, port, options);
-}
-/**
- * Bind the Express app to 127.0.0.1:port and handle success/conflict paths.
- * Returns a BindResult so the caller can detect and handle port conflicts
- * (e.g., retry after killing a stale process).
- */
-async function bindAndListen(app, port, options) {
+function attemptBind(app, port, options) {
     return new Promise((resolve) => {
         const httpServer = app.listen(port, '127.0.0.1', () => {
             serverRunning = true;
@@ -396,26 +389,37 @@ async function bindAndListen(app, port, options) {
             resolve({ success: true });
         });
         httpServer.on('error', (err) => {
-            resolve(handleListenError(err, port, options.openBrowser));
+            if (err.code === 'EADDRINUSE') {
+                resolve({ success: false, error: 'EADDRINUSE', detail: `Port ${port} already in use` });
+            }
+            else {
+                logger.error(`[WebUI] Failed to bind port ${port}: ${err.message}`);
+                resolve({ success: false, error: 'OTHER', detail: err.message });
+            }
         });
     });
 }
 /**
- * Handle errors from app.listen(). Returns a BindResult describing the failure.
- * EADDRINUSE is logged at WARN (not INFO) so it's visible in production logs.
+ * Bind the Express app to 127.0.0.1:port. On EADDRINUSE, attempt to find
+ * and kill the stale DollhouseMCP process holding the port, then retry once.
  */
-function handleListenError(err, port, openBrowser) {
-    if (err.code === 'EADDRINUSE') {
-        const url = `http://${CONSOLE_HOST}:${port}`;
-        logger.warn(`[WebUI] Port ${port} already in use — another process holds this port`);
-        console.error(`\n  DollhouseMCP Management Console (existing instance)\n  ${url}\n`);
-        if (openBrowser) {
-            openInBrowser(url);
-        }
-        return { success: false, error: 'EADDRINUSE', detail: `Port ${port} already in use` };
+async function bindAndListen(app, port, options) {
+    const result = await attemptBind(app, port, options);
+    if (result.success || result.error !== 'EADDRINUSE')
+        return result;
+    // Port occupied — attempt stale process recovery and retry
+    if (await recoverStalePort(port)) {
+        const retryResult = await attemptBind(app, port, options);
+        if (retryResult.success)
+            return retryResult;
+    }
+    // Still can't bind — fall through with warning
+    logger.warn(`[WebUI] Port ${port} already in use — another process holds this port`);
+    console.error(`\n  DollhouseMCP Management Console (existing instance)\n  http://${CONSOLE_HOST}:${port}\n`);
+    if (options.openBrowser) {
+        openInBrowser(`http://${CONSOLE_HOST}:${port}`);
     }
-    logger.error(`[WebUI] Failed to bind port ${port}: ${err.message}`);
-    return { success: false, error: 'OTHER', detail: err.message };
+    return result;
 }
 /**
  * Self-provision sinks, token store, and ingest routes, then start the web
@@ -489,4 +493,4 @@ export async function openPortfolioBrowser(options) {
         ...(browserResult.error ? { warning: `Browser could not be opened automatically: ${browserResult.error}. Open ${url} manually.` } : {}),
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/web/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,OAAO,MAAM,SAAS,CAAC;AAC9B,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,EAAE,eAAe,EAAwB,MAAM,uBAAuB,CAAC;AAC9E,OAAO,EAAE,mBAAmB,EAA4B,MAAM,2BAA2B,CAAC;AAC1F,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAKvC,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,oBAAoB,GAAG;IAC3B,aAAa;IACb,oBAAoB;IACpB,iBAAiB;IACjB,mBAAmB;IACnB,oBAAoB;CACrB,CAAC;AAEF,iFAAiF;AACjF,MAAM,sBAAsB,GAAG,mBAAmB,CAAC;AAEnD,MAAM,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAC1D;;;;;GAKG;AACH,MAAM,YAAY,GAAG,GAAG,CAAC,0BAA0B,CAAC;AACpD,MAAM,YAAY,GAAG,qBAAqB,CAAC;AAC3C,MAAM,uBAAuB,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;AAC3D,mGAAmG;AACnG,MAAM,gBAAgB,GAAG,KAAK,CAAC;AAE/B,kEAAkE;AAClE,IAAI,aAAa,GAAG,KAAK,CAAC;AAC1B,IAAI,UAAU,GAAG,YAAY,CAAC;AAC9B,+EAA+E;AAC/E,IAAI,gBAAgB,GAAsC,IAAI,CAAC;AAC/D,mGAAmG;AACnG,IAAI,gBAAgB,GAA6B,IAAI,CAAC;AAEtD,qEAAqE;AACrE,MAAM,UAAU,kBAAkB;IAChC,OAAO,aAAa,CAAC;AACvB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB;IAC/B,IAAI,gBAAgB,EAAE,CAAC;QACrB,gBAAgB,CAAC,KAAK,EAAE,CAAC;QACzB,gBAAgB,GAAG,IAAI,CAAC;IAC1B,CAAC;IACD,aAAa,GAAG,KAAK,CAAC;IACtB,UAAU,GAAG,YAAY,CAAC;IAC1B,gBAAgB,GAAG,IAAI,CAAC;AAC1B,CAAC;AA0ED;;;;;;;;;;GAUG;AACH,SAAS,aAAa,CAAC,GAAW;IAChC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,MAAM,IAAI,GAAG,QAAQ,EAAE,CAAC;QACxB,MAAM,GAAG,GAAG,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM;YACpC,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO;gBAC5B,CAAC,CAAC,UAAU,CAAC;QAEf,8EAA8E;QAC9E,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;QAC3B,qEAAqE;QACrE,IAAI,CAAC,4DAA4D,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YAC/E,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,kCAAkC,EAAE,CAAC,CAAC;YACvE,OAAO;QACT,CAAC;QACD,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE;YAC9B,IAAI,GAAG,EAAE,CAAC;gBACR,MAAM,CAAC,IAAI,CAAC,wCAAwC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;gBACnE,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;YAClD,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;YAC7B,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,OAAyB;IAC5D,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,YAAY,CAAC;IAC1C,MAAM,MAAM,GAAoB,EAAE,CAAC;IAEnC,IAAI,aAAa,EAAE,CAAC;QAClB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;YACxB,aAAa,CAAC,UAAU,YAAY,IAAI,UAAU,EAAE,CAAC,CAAC;QACxD,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,GAAG,GAAG,OAAO,EAAE,CAAC;IACtB,MAAM,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;IAE5B,mBAAmB;IACnB,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE;QAC1B,GAAG,CAAC,SAAS,CAAC,wBAAwB,EAAE,SAAS,CAAC,CAAC;QACnD,GAAG,CAAC,SAAS,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;QACzC,GAAG,CAAC,SAAS,CAAC,kBAAkB,EAAE,eAAe,CAAC,CAAC;QACnD,GAAG,CAAC,SAAS,CAAC,iBAAiB,EAAE,aAAa,CAAC,CAAC;QAChD,GAAG,CAAC,SAAS,CAAC,6BAA6B,EAAE,UAAU,YAAY,IAAI,IAAI,EAAE,CAAC,CAAC;QAC/E,GAAG,CAAC,SAAS,CAAC,yBAAyB,EAAE;YACvC,oBAAoB;YACpB,yDAAyD;YACzD,wEAAwE;YACxE,sBAAsB;YACtB,8CAA8C;YAC9C,iBAAiB;SAClB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QACd,IAAI,EAAE,CAAC;IACT,CAAC,CAAC,CAAC;IAEH,2EAA2E;IAC3E,4EAA4E;IAC5E,gFAAgF;IAChF,kFAAkF;IAClF,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;QACvB,MAAM,cAAc,GAAG,oBAAoB,CAAC;YAC1C,KAAK,EAAE,OAAO,CAAC,UAAU;YACzB,OAAO,EAAE,GAAG,CAAC,0BAA0B;YACvC,kBAAkB,EAAE,oBAAoB;YACxC,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QAChC,MAAM,CAAC,IAAI,CACT,2CAA2C,GAAG,CAAC,0BAA0B,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,yBAAyB,EAAE,CACtH,CAAC;QAEF,yEAAyE;QACzE,yEAAyE;QACzE,uEAAuE;QACvE,sEAAsE;QACtE,wEAAwE;QACxE,gCAAgC;QAChC,GAAG,CAAC,GAAG,CAAC,mBAAmB,EAAE,gBAAgB,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;QAC9E,MAAM,CAAC,IAAI,CAAC,mEAAmE,CAAC,CAAC;QAEjF,0EAA0E;QAC1E,0EAA0E;QAC1E,iEAAiE;QACjE,GAAG,CAAC,GAAG,CAAC,oBAAoB,EAAE,iBAAiB,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;QAChF,MAAM,CAAC,IAAI,CAAC,qEAAqE,CAAC,CAAC;IACrF,CAAC;IAED,mFAAmF;IACnF,8FAA8F;IAC9F,MAAM,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC;IAC5F,MAAM,EAAE,cAAc,EAAE,iBAAiB,EAAE,cAAc,EAAE,mBAAmB,EAAE,aAAa,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,GAAG,iBAAiB,EAAE,CAAC;IAC7M,GAAG,CAAC,IAAI,CAAC,oBAAoB,EAAE,eAAe,EAAE,cAAc,CAAC,CAAC;IAChE,GAAG,CAAC,IAAI,CAAC,wBAAwB,EAAE,eAAe,EAAE,iBAAiB,CAAC,CAAC;IACvE,GAAG,CAAC,GAAG,CAAC,oBAAoB,EAAE,cAAc,CAAC,CAAC;IAC9C,GAAG,CAAC,GAAG,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC;IAChD,GAAG,CAAC,GAAG,CAAC,mBAAmB,EAAE,aAAa,CAAC,CAAC;IAC5C,GAAG,CAAC,GAAG,CAAC,oBAAoB,EAAE,iBAAiB,CAAC,CAAC;IACjD,GAAG,CAAC,IAAI,CAAC,oBAAoB,EAAE,eAAe,EAAE,iBAAiB,CAAC,CAAC;IACnE,GAAG,CAAC,IAAI,CAAC,2BAA2B,EAAE,eAAe,EAAE,oBAAoB,CAAC,CAAC;IAC7E,GAAG,CAAC,IAAI,CAAC,2BAA2B,EAAE,eAAe,EAAE,yBAAyB,CAAC,CAAC;IAClF,MAAM,CAAC,IAAI,CAAC,4CAA4C,CAAC,CAAC;IAE1D,0EAA0E;IAC1E,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;QAC1B,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,sBAAsB,CAAC,OAAO,CAAC,aAAa,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;QAErF,oFAAoF;QACpF,MAAM,EAAE,wBAAwB,EAAE,GAAG,MAAM,MAAM,CAAC,8BAA8B,CAAC,CAAC;QAClF,MAAM,UAAU,GAAG,CAAC,MAAM,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QACtD,wBAAwB,CAAC,UAAU,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;QAC5D,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAE5B,MAAM,CAAC,IAAI,CAAC,8DAA8D,CAAC,CAAC;IAC9E,CAAC;SAAM,CAAC;QACN,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;QACvD,MAAM,CAAC,IAAI,CAAC,kFAAkF,CAAC,CAAC;IAClG,CAAC;IAED,sEAAsE;IACtE,2CAA2C;IAC3C,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAEzC,oFAAoF;IACpF,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC,CAAC;IAC9D,KAAK,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;QAC/C,MAAM,CAAC,IAAI,CAAC,6CAA8C,GAAa,CAAC,OAAO,EAAE,CAAC,CAAC;IACrF,CAAC,CAAC,CAAC;IACH,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;IAE5C;;;;OAIG;IACH,GAAG,CAAC,GAAG,CAAC,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;QACxC,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAC;YACtC,MAAM,KAAK,GAAG,KAAK;iBAChB,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,uBAAuB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;iBAC1E,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;YAC/C,GAAG,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC3C,CAAC;QAAC,MAAM,CAAC;YACP,GAAG,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,4FAA4F;IAC5F,OAAO,CAAC,iBAAiB,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAE9D,wBAAwB;IACxB,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC5C,mEAAmE;IACnE,qEAAqE;IACrE,kEAAkE;IAClE,qDAAqD;IACrD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IACjF,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE;QAChC,KAAK,EAAE,KAAK;QACZ,mEAAmE;QACnE,iEAAiE;QACjE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACpE,CAAC,CAAC,CAAC;IAEJ,qDAAqD;IACrD,mFAAmF;IACnF,6EAA6E;IAC7E,+EAA+E;IAC/E,kEAAkE;IAClE,IAAI,eAAe,GAAkB,IAAI,CAAC;IAC1C,IAAI,gBAAgB,GAAkB,IAAI,CAAC;IAC3C,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;IAEpD,MAAM,eAAe,GAAG,KAAK,IAAqB,EAAE;QAClD,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,EAAE,oBAAoB,EAAE,IAAI,EAAE,CAAC;QACpE,2DAA2D;QAC3D,iFAAiF;QACjF,IAAI,CAAC,OAAO,IAAI,eAAe,KAAK,IAAI,IAAI,gBAAgB,KAAK,UAAU,EAAE,CAAC;YAC5E,OAAO,eAAe,CAAC;QACzB,CAAC;QACD,MAAM,QAAQ,GAAG,MAAM,UAAU,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;QACzD,2EAA2E;QAC3E,wEAAwE;QACxE,4EAA4E;QAC5E,MAAM,YAAY,GAAG,UAAU;aAC5B,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC;aACxB,UAAU,CAAC,GAAG,EAAE,QAAQ,CAAC;aACzB,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC;aACxB,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC;aACvB,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAC3B,eAAe,GAAG,QAAQ,CAAC,UAAU,CAAC,sBAAsB,EAAE,YAAY,CAAC,CAAC;QAC5E,gBAAgB,GAAG,UAAU,CAAC;QAC9B,OAAO,eAAe,CAAC;IACzB,CAAC,CAAC;IAEF,GAAG,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE;QACrC,MAAM,cAAc,GAAG,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACjD,IAAI,cAAc,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;YACvC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,wBAAwB,cAAc,EAAE,EAAE,CAAC,CAAC;YAC1E,OAAO;QACT,CAAC;QACD,IAAI,cAAc,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;YACzC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,mBAAmB,cAAc,EAAE,EAAE,CAAC,CAAC;YACrE,OAAO;QACT,CAAC;QACD,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,MAAM,eAAe,EAAE,CAAC;YACrC,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,0BAA0B,CAAC,CAAC;YAC1D,qEAAqE;YACrE,mEAAmE;YACnE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;YACjF,GAAG,CAAC,SAAS,CAAC,eAAe,EAAE,OAAO;gBACpC,CAAC,CAAC,qCAAqC;gBACvC,CAAC,CAAC,qBAAqB,CAAC,CAAC;YAC3B,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,CAAC,KAAK,CAAC,wCAAyC,GAAa,CAAC,OAAO,EAAE,CAAC,CAAC;YAC/E,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;QACjD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,uFAAuF;IACvF,kFAAkF;IAClF,kFAAkF;IAClF,6DAA6D;IAC7D,GAAG,CAAC,GAAG,CAAC,CAAC,GAAU,EAAE,IAA+B,EAAE,GAA+B,EAAE,KAAqC,EAAE,EAAE;QAC9H,MAAM,MAAM,GAAI,GAAW,CAAC,MAAM,IAAK,GAAW,CAAC,UAAU,IAAI,GAAG,CAAC;QACrE,MAAM,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;QACnD,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;YACrB,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;QAClD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,6DAA6D;IAC7D,kFAAkF;IAClF,MAAM,CAAC,UAAU,GAAG,MAAM,aAAa,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAE5D,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,SAAS,kBAAkB,CACzB,GAA8B,EAC9B,OAAyB,EACzB,MAAuB;IAEvB,IAAI,SAAsC,CAAC;IAC3C,IAAI,aAA8C,CAAC;IAEnD,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;QACvB,SAAS,GAAG,eAAe,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAChD,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;QAClC,MAAM,CAAC,YAAY,GAAG,SAAS,CAAC,SAAS,CAAC;QAC1C,MAAM,CAAC,IAAI,CAAC,gDAAgD,CAAC,CAAC;IAChE,CAAC;IAED,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;QACxB,aAAa,GAAG,mBAAmB,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QACzD,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;QACtC,MAAM,CAAC,iBAAiB,GAAG,aAAa,CAAC,UAAU,CAAC;QACpD,MAAM,CAAC,IAAI,CAAC,gDAAgD,CAAC,CAAC;IAChE,CAAC;IAED,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;QACvB,MAAM,YAAY,GAAG,kBAAkB,CAAC;YACtC,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,cAAc,EAAE,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;YAC3D,kBAAkB,EAAE,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;SACxE,CAAC,CAAC;QACH,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAChC,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,kBAAkB,CAAC,IAAY,EAAE,UAAyC;IACjF,MAAM,GAAG,GAAG,UAAU,YAAY,IAAI,IAAI,EAAE,CAAC;IAC7C,MAAM,WAAW,GAAG,oBAAoB,IAAI,EAAE,CAAC;IAC/C,MAAM,CAAC,IAAI,CAAC,yCAAyC,GAAG,EAAE,CAAC,CAAC;IAC5D,OAAO,CAAC,KAAK,CAAC,0CAA0C,GAAG,OAAO,WAAW,eAAe,CAAC,CAAC;IAC9F,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,oBAAoB,UAAU,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,CAAC,KAAK,CAAC,iCAAiC,CAAC,CAAC;AACnD,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,GAA8B,EAC9B,IAAY,EACZ,OAAyB;IAEzB,OAAO,aAAa,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AAC3C,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,aAAa,CAC1B,GAA8B,EAC9B,IAAY,EACZ,OAAyB;IAEzB,OAAO,IAAI,OAAO,CAAa,CAAC,OAAO,EAAE,EAAE;QACzC,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,EAAE;YACpD,aAAa,GAAG,IAAI,CAAC;YACrB,UAAU,GAAG,IAAI,CAAC;YAClB,gBAAgB,GAAG,UAAU,CAAC;YAC9B,kBAAkB,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;YAC7C,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;gBACxB,aAAa,CAAC,UAAU,YAAY,IAAI,IAAI,EAAE,CAAC,CAAC;YAClD,CAAC;YACD,OAAO,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAA0B,EAAE,EAAE;YACpD,OAAO,CAAC,iBAAiB,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,SAAS,iBAAiB,CACxB,GAA0B,EAC1B,IAAY,EACZ,WAAgC;IAEhC,IAAI,GAAG,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;QAC9B,MAAM,GAAG,GAAG,UAAU,YAAY,IAAI,IAAI,EAAE,CAAC;QAC7C,MAAM,CAAC,IAAI,CAAC,gBAAgB,IAAI,mDAAmD,CAAC,CAAC;QACrF,OAAO,CAAC,KAAK,CAAC,8DAA8D,GAAG,IAAI,CAAC,CAAC;QACrF,IAAI,WAAW,EAAE,CAAC;YAChB,aAAa,CAAC,GAAG,CAAC,CAAC;QACrB,CAAC;QACD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,IAAI,iBAAiB,EAAE,CAAC;IACxF,CAAC;IACD,MAAM,CAAC,KAAK,CAAC,+BAA+B,IAAI,KAAK,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;IACpE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC;AACjE,CAAC;AA4BD;;;;GAIG;AACH,KAAK,UAAU,mBAAmB,CAAC,OAA2B,EAAE,IAAY;IAC1E,IAAI,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IACpC,IAAI,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAEtC,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,GAAG,MAAM,MAAM,CAAC,mCAAmC,CAAC,CAAC;QACrF,UAAU,GAAG,IAAI,OAAO,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,CAAC,CAAC;IACxH,CAAC;IACD,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,MAAM,EAAE,iBAAiB,EAAE,WAAW,EAAE,GAAG,MAAM,MAAM,CAAC,uCAAuC,CAAC,CAAC;QACjG,WAAW,GAAG,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC;IACrC,CAAC;IAED,gFAAgF;IAChF,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtB,MAAM,EAAE,iBAAiB,EAAE,UAAU,EAAE,GAAG,MAAM,MAAM,CAAC,2BAA2B,CAAC,CAAC;QACpF,MAAM,EAAE,oBAAoB,EAAE,GAAG,MAAM,MAAM,CAAC,2BAA2B,CAAC,CAAC;QAC3E,gBAAgB,GAAG,IAAI,UAAU,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;QACpE,IAAI,CAAC;YAAC,MAAM,gBAAgB,CAAC,iBAAiB,CAAC,oBAAoB,EAAE,CAAC,CAAC;QAAC,CAAC;QACzE,OAAO,GAAG,EAAE,CAAC;YAAC,MAAM,CAAC,IAAI,CAAC,qDAAqD,EAAE,GAAG,CAAC,CAAC;QAAC,CAAC;IAC1F,CAAC;IAED,uFAAuF;IACvF,IAAI,aAA2F,CAAC;IAChG,MAAM,EAAE,kBAAkB,EAAE,GAAG,MAAM,MAAM,CAAC,2BAA2B,CAAC,CAAC;IACzE,MAAM,YAAY,GAAG,kBAAkB,CAAC;QACtC,YAAY,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC;KAChD,CAAC,CAAC;IACH,YAAY,CAAC,sBAAsB,EAAE,CAAC;IAEtC,MAAM,SAAS,GAAG,MAAM,cAAc,CAAC;QACrC,YAAY,EAAE,OAAO,CAAC,YAAY;QAClC,IAAI;QACJ,WAAW,EAAE,KAAK;QAClB,aAAa,EAAE,OAAO,CAAC,aAAa;QACpC,UAAU;QACV,WAAW;QACX,UAAU,EAAE,gBAAgB;QAC5B,iBAAiB,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC;KACzC,CAAC,CAAC;IAEH,aAAa,GAAG,SAAS,CAAC,YAAY,CAAC;AACzC,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,OAA2B;IACpE,MAAM,UAAU,GAAG,OAAO,CAAC,IAAI,IAAI,YAAY,CAAC;IAChD,MAAM,OAAO,GAAG,UAAU,YAAY,IAAI,UAAU,EAAE,CAAC;IAEvD,wDAAwD;IACxD,IAAI,GAAG,GAAG,OAAO,CAAC;IAClB,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;QAChB,MAAM,EAAE,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACtF,GAAG,GAAG,GAAG,OAAO,KAAK,OAAO,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;IAC1D,CAAC;SAAM,IAAI,OAAO,CAAC,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1E,MAAM,EAAE,GAAG,IAAI,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC7D,GAAG,GAAG,GAAG,OAAO,eAAe,EAAE,EAAE,CAAC;IACtC,CAAC;IAED,MAAM,cAAc,GAAG,aAAa,CAAC;IAErC,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,MAAM,mBAAmB,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IACjD,CAAC;IAED,MAAM,aAAa,GAAG,MAAM,aAAa,CAAC,GAAG,CAAC,CAAC;IAE/C,OAAO;QACL,GAAG;QACH,cAAc;QACd,aAAa,EAAE,aAAa,CAAC,OAAO;QACpC,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,8CAA8C,aAAa,CAAC,KAAK,UAAU,GAAG,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACxI,CAAC;AACJ,CAAC","sourcesContent":["/**\n * DollhouseMCP Web UI Server\n *\n * Lightweight Express server for browsing portfolio elements in a browser.\n * Bound to 127.0.0.1 only (localhost). Read-only for V1.\n *\n * Can be started standalone (`--web` flag) or from within the MCP server\n * process via `openPortfolioBrowser()`.\n *\n * @see https://github.com/DollhouseMCP/mcp-server-v2-refactor/issues/704\n * @see https://github.com/DollhouseMCP/mcp-server-v2-refactor/issues/774\n */\n\nimport express from 'express';\nimport { join, dirname, extname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { execFile } from 'node:child_process';\nimport { platform } from 'node:os';\nimport { mkdir, readdir, readFile as readFileFs } from 'node:fs/promises';\nimport { createApiRoutes, createGatewayApiRoutes } from './routes.js';\nimport { createLogRoutes, type LogRoutesResult } from './routes/logRoutes.js';\nimport { createMetricsRoutes, type MetricsRoutesResult } from './routes/metricsRoutes.js';\nimport { createHealthRoutes } from './routes/healthRoutes.js';\nimport { createSetupRoutes } from './routes/setupRoutes.js';\nimport { createTotpRoutes } from './routes/totpRoutes.js';\nimport { createTokenRoutes } from './routes/tokenRoutes.js';\nimport { logger } from '../utils/logger.js';\nimport { env } from '../config/env.js';\nimport type { MCPAQLHandler } from '../handlers/mcp-aql/MCPAQLHandler.js';\nimport type { MemoryLogSink } from '../logging/sinks/MemoryLogSink.js';\nimport type { MemoryMetricsSink } from '../metrics/sinks/MemoryMetricsSink.js';\nimport type { ConsoleTokenStore } from './console/consoleToken.js';\nimport { createAuthMiddleware } from './middleware/authMiddleware.js';\n\n/**\n * Public path prefixes that never require authentication (#1780).\n * These endpoints return safe metadata or act as health probes — requiring\n * tokens on them would break monitoring and client detection without adding\n * real security value.\n */\nconst PUBLIC_PATH_PREFIXES = [\n  '/api/health',\n  '/api/setup/version',\n  '/api/setup/mcpb',\n  '/api/setup/detect',\n  '/api/setup/license',\n];\n\n/** Placeholder in index.html that is replaced with the current console token. */\nconst TOKEN_META_PLACEHOLDER = '{{CONSOLE_TOKEN}}';\n\nconst __dirname = dirname(fileURLToPath(import.meta.url));\n/**\n * Default port for standalone `startWebServer` calls. Reads from the\n * `DOLLHOUSE_WEB_CONSOLE_PORT` env var so there is a single source of\n * truth (see `src/config/env.ts`). Callers passing an explicit `port` in\n * `WebServerOptions` override this default.\n */\nconst DEFAULT_PORT = env.DOLLHOUSE_WEB_CONSOLE_PORT;\nconst CONSOLE_HOST = 'dollhouse.localhost';\nconst ALLOWED_PAGE_EXTENSIONS = new Set(['.html', '.htm']);\n/** Max JSON body for setup routes (install/open-config). Ingest routes use their own 1mb limit. */\nconst SETUP_BODY_LIMIT = '1kb';\n\n/** Track whether the web server is already running in-process. */\nlet serverRunning = false;\nlet serverPort = DEFAULT_PORT;\n/** Active HTTP server instance — tracked so _resetServerState can close it. */\nlet activeHttpServer: import('node:http').Server | null = null;\n/** Cached token store for openPortfolioBrowser — prevents duplicate instances on the same file. */\nlet cachedTokenStore: ConsoleTokenStore | null = null;\n\n/** Check whether the web server has been started in this process. */\nexport function isWebServerRunning(): boolean {\n  return serverRunning;\n}\n\n/**\n * Reset module-level server state. Exported for testing only —\n * allows tests to exercise startWebServer/bindAndListen without\n * interference from prior runs in the same process.\n * @internal\n */\nexport function _resetServerState(): void {\n  if (activeHttpServer) {\n    activeHttpServer.close();\n    activeHttpServer = null;\n  }\n  serverRunning = false;\n  serverPort = DEFAULT_PORT;\n  cachedTokenStore = null;\n}\n\n/**\n * Options for starting the web server.\n */\nexport interface WebServerOptions {\n  /** Port to bind to (defaults to `DOLLHOUSE_WEB_CONSOLE_PORT`, see `src/config/env.ts`) */\n  port?: number;\n  /** Path to the portfolio directory (e.g., ~/.dollhouse/portfolio) */\n  portfolioDir: string;\n  /** Open the browser automatically after starting (default: false) */\n  openBrowser?: boolean;\n  /**\n   * MCPAQLHandler for routing through the MCP-AQL pipeline.\n   * When provided, API routes use the gateway (validated, cached, gatekeeper-checked).\n   * When absent, falls back to direct filesystem access (legacy behavior).\n   * Issue #796: Web MCP-AQL Gateway.\n   */\n  mcpAqlHandler?: MCPAQLHandler;\n  /** MemoryLogSink for log routes (optional — logs tab disabled if not provided) */\n  memorySink?: MemoryLogSink;\n  /** MemoryMetricsSink for metrics routes (optional — metrics tab disabled if not provided) */\n  metricsSink?: MemoryMetricsSink;\n  /** Additional routers to mount before the SPA fallback (e.g., ingest routes) */\n  additionalRouters?: import('express').Router[];\n  /**\n   * Console token store (#1780). When provided, the server will:\n   *   1. Mount Bearer token auth middleware before protected routers.\n   *   2. Inject the primary token into index.html so the browser client\n   *      can attach it to fetch calls and EventSource URLs.\n   *   3. Append the token file location to the startup banner.\n   * Auth enforcement is still gated on DOLLHOUSE_WEB_AUTH_ENABLED — the\n   * middleware is a pass-through when the flag is false (the Phase 1 default).\n   */\n  tokenStore?: ConsoleTokenStore;\n}\n\n/**\n * Result of attempting to bind the HTTP server to a port.\n */\nexport interface BindResult {\n  success: boolean;\n  error?: 'EADDRINUSE' | 'OTHER';\n  detail?: string;\n}\n\n/**\n * Result of starting the web server, including hooks for DI wiring.\n */\nexport interface WebServerResult {\n  /** Express app instance — for mounting additional routes (e.g., ingest routes) */\n  app?: import('express').Express;\n  /** Log broadcast function — call with each entry to push to SSE clients */\n  logBroadcast?: (entry: import('../logging/types.js').UnifiedLogEntry) => void;\n  /** Metrics snapshot function — call with each snapshot to push to SSE clients */\n  metricsOnSnapshot?: (snapshot: import('../metrics/types.js').MetricSnapshot) => void;\n  /** Result of the port binding attempt */\n  bindResult?: BindResult;\n}\n\n/**\n * Result of attempting to open the browser.\n */\nexport interface BrowserOpenResult {\n  /** The URL the server is running on */\n  url: string;\n  /** Whether the server was already running (true) or just started (false) */\n  alreadyRunning: boolean;\n  /** Whether the browser was successfully opened */\n  browserOpened: boolean;\n  /** Warning message if the browser could not be opened */\n  warning?: string;\n}\n\n/**\n * Open a URL in the system's default browser.\n *\n * Platform-aware:\n * - macOS: `open`\n * - Linux: `xdg-open`\n * - Windows: `start`\n *\n * @param url - The URL to open\n * @returns Promise that resolves to true if the browser opened, false with error message if not\n */\nfunction openInBrowser(url: string): Promise<{ success: boolean; error?: string }> {\n  return new Promise((resolve) => {\n    const plat = platform();\n    const cmd = plat === 'darwin' ? 'open'\n      : plat === 'win32' ? 'start'\n      : 'xdg-open';\n\n    // Security: use execFile with URL as argument array, not string interpolation\n    const urlStr = String(url);\n    // Accept localhost, 127.0.0.1, and *.localhost subdomains (RFC 6761)\n    if (!/^https?:\\/\\/(localhost|127\\.0\\.0\\.1|[\\w-]+\\.localhost)[:/]/.test(urlStr)) {\n      resolve({ success: false, error: 'URL must be a localhost HTTP URL' });\n      return;\n    }\n    execFile(cmd, [urlStr], (err) => {\n      if (err) {\n        logger.warn(`[WebUI] Could not auto-open browser: ${err.message}`);\n        resolve({ success: false, error: err.message });\n      } else {\n        resolve({ success: true });\n      }\n    });\n  });\n}\n\n/**\n * Start the portfolio web server.\n *\n * Binds to 127.0.0.1 only (localhost). Serves the portfolio browser\n * frontend and API routes for reading elements.\n *\n * Idempotent: if the server is already running, optionally opens the\n * browser without starting a second instance.\n *\n * @param options - Server configuration\n * @returns Hooks for DI wiring (log broadcast, metrics onSnapshot)\n */\nexport async function startWebServer(options: WebServerOptions): Promise<WebServerResult> {\n  const port = options.port || DEFAULT_PORT;\n  const result: WebServerResult = {};\n\n  if (serverRunning) {\n    if (options.openBrowser) {\n      openInBrowser(`http://${CONSOLE_HOST}:${serverPort}`);\n    }\n    return result;\n  }\n\n  const app = express();\n  result.app = app;\n  app.disable('x-powered-by');\n\n  // Security headers\n  app.use((_req, res, next) => {\n    res.setHeader('X-Content-Type-Options', 'nosniff');\n    res.setHeader('X-Frame-Options', 'DENY');\n    res.setHeader('X-XSS-Protection', '1; mode=block');\n    res.setHeader('Referrer-Policy', 'no-referrer');\n    res.setHeader('Access-Control-Allow-Origin', `http://${CONSOLE_HOST}:${port}`);\n    res.setHeader('Content-Security-Policy', [\n      \"default-src 'self'\",\n      \"script-src 'self' cdn.jsdelivr.net cdnjs.cloudflare.com\",\n      \"style-src 'self' 'unsafe-inline' cdnjs.cloudflare.com cdn.jsdelivr.net\",\n      \"img-src 'self' data:\",\n      \"connect-src 'self' raw.githubusercontent.com\",\n      \"font-src 'self'\",\n    ].join('; '));\n    next();\n  });\n\n  // Console token authentication middleware (#1780). Mounted before any /api\n  // routes so every protected endpoint goes through it. When the feature flag\n  // DOLLHOUSE_WEB_AUTH_ENABLED is false (Phase 1 default) this is a pass-through.\n  // Public endpoints in PUBLIC_PATH_PREFIXES always bypass auth regardless of flag.\n  if (options.tokenStore) {\n    const authMiddleware = createAuthMiddleware({\n      store: options.tokenStore,\n      enabled: env.DOLLHOUSE_WEB_AUTH_ENABLED,\n      publicPathPrefixes: PUBLIC_PATH_PREFIXES,\n      label: 'api',\n    });\n    app.use('/api', authMiddleware);\n    logger.info(\n      `[WebUI] Console auth middleware mounted ${env.DOLLHOUSE_WEB_AUTH_ENABLED ? 'ENFORCING' : 'pass-through (flag off)'}`,\n    );\n\n    // TOTP enrollment routes (#1794). Mounted AFTER the /api auth middleware\n    // because the router adds its own always-on auth guard — the global auth\n    // middleware at /api is a pass-through during Phase 1 rollout, but the\n    // TOTP router enforces regardless of DOLLHOUSE_WEB_AUTH_ENABLED so an\n    // attacker with local port access cannot pre-enroll a second factor and\n    // lock the legitimate user out.\n    app.use('/api/console/totp', createTotpRoutes({ store: options.tokenStore }));\n    logger.info('[WebUI] TOTP routes mounted at /api/console/totp (always-on auth)');\n\n    // Token management routes (#1795). Mounted alongside the TOTP router with\n    // the same always-on auth pattern. Currently hosts the rotation endpoint;\n    // future token management operations (list, revoke) go here too.\n    app.use('/api/console/token', createTokenRoutes({ store: options.tokenStore }));\n    logger.info('[WebUI] Token routes mounted at /api/console/token (always-on auth)');\n  }\n\n  // Setup routes: auto-install DollhouseMCP to MCP clients (mount BEFORE API routes)\n  // Body limit scoped to setup routes only — ingest routes need 1mb for follower log forwarding\n  const setupJsonParser = express.json({ limit: SETUP_BODY_LIMIT, type: 'application/json' });\n  const { installHandler, openConfigHandler, versionHandler, mcpbRedirectHandler, detectHandler, getLicenseHandler, setLicenseHandler, verifyLicenseHandler, resendVerificationHandler } = createSetupRoutes();\n  app.post('/api/setup/install', setupJsonParser, installHandler);\n  app.post('/api/setup/open-config', setupJsonParser, openConfigHandler);\n  app.get('/api/setup/version', versionHandler);\n  app.get('/api/setup/mcpb', mcpbRedirectHandler);\n  app.get('/api/setup/detect', detectHandler);\n  app.get('/api/setup/license', getLicenseHandler);\n  app.post('/api/setup/license', setupJsonParser, setLicenseHandler);\n  app.post('/api/setup/license/verify', setupJsonParser, verifyLicenseHandler);\n  app.post('/api/setup/license/resend', setupJsonParser, resendVerificationHandler);\n  logger.info('[WebUI] Setup routes mounted at /api/setup');\n\n  // API routes — use MCP-AQL gateway when handler is available (Issue #796)\n  if (options.mcpAqlHandler) {\n    app.use('/api', createGatewayApiRoutes(options.mcpAqlHandler, options.portfolioDir));\n\n    // Permission evaluation routes (POST /evaluate_permission, GET /permissions/status)\n    const { registerPermissionRoutes } = await import('./routes/permissionRoutes.js');\n    const permRouter = (await import('express')).Router();\n    registerPermissionRoutes(permRouter, options.mcpAqlHandler);\n    app.use('/api', permRouter);\n\n    logger.info('[WebUI] API routes using MCP-AQL Gateway + permission routes');\n  } else {\n    app.use('/api', createApiRoutes(options.portfolioDir));\n    logger.warn('[WebUI] API routes using direct filesystem access (no MCP-AQL handler available)');\n  }\n\n  // Console routes: logs, metrics, health — extracted to keep cognitive\n  // complexity of startWebServer manageable.\n  mountConsoleRoutes(app, options, result);\n\n  // Serve ~/.dollhouse/pages/ at /pages/ — dashboards, generated content, stack views\n  const pagesDir = join(dirname(options.portfolioDir), 'pages');\n  mkdir(pagesDir, { recursive: true }).catch(err => {\n    logger.warn(`[WebUI] Could not create pages directory: ${(err as Error).message}`);\n  });\n  app.use('/pages', express.static(pagesDir));\n\n  /**\n   * GET /api/pages\n   * Lists available HTML pages in ~/.dollhouse/pages/.\n   * Returns page names and their URLs for the management console.\n   */\n  app.get('/api/pages', async (_req, res) => {\n    try {\n      const files = await readdir(pagesDir);\n      const pages = files\n        .filter(f => !f.startsWith('.') && ALLOWED_PAGE_EXTENSIONS.has(extname(f)))\n        .map(f => ({ name: f, url: `/pages/${f}` }));\n      res.json({ pages, directory: pagesDir });\n    } catch {\n      res.json({ pages: [], directory: pagesDir });\n    }\n  });\n\n  // Additional routers (e.g., unified console ingest routes) — must mount before SPA fallback\n  options.additionalRouters?.forEach(router => app.use(router));\n\n  // Static frontend files\n  const publicDir = join(__dirname, 'public');\n  // Serve static assets but skip index.html — the SPA fallback below\n  // handles it with token injection (replaces {{CONSOLE_TOKEN}} in the\n  // meta tag). Without this, express.static serves the raw template\n  // and the browser never gets the auth token (#1780).\n  const isDebug = Boolean(process.env.DOLLHOUSE_DEBUG || process.env.ENABLE_DEBUG);\n  app.use(express.static(publicDir, {\n    index: false,\n    // In debug mode, disable caching on all static assets (JS, CSS) so\n    // UI changes are picked up on normal reload without Cmd+Shift+R.\n    ...(isDebug ? { etag: false, lastModified: false, maxAge: 0 } : {}),\n  }));\n\n  // SPA fallback with console token injection (#1780).\n  // Reads index.html on first request, substitutes the {{CONSOLE_TOKEN}} placeholder\n  // with the current token value, and caches the rendered string. The cache is\n  // auto-invalidated when the primary token changes (rotation), so a page reload\n  // after rotation picks up the new token without a server restart.\n  let cachedIndexHtml: string | null = null;\n  let cachedTokenValue: string | null = null;\n  const indexHtmlPath = join(publicDir, 'index.html');\n\n  const renderIndexHtml = async (): Promise<string> => {\n    const tokenValue = options.tokenStore?.getPrimaryTokenValue() ?? '';\n    // Auto-invalidate cache when the token changes (rotation).\n    // In debug mode, always re-read from disk so UI changes are picked up on reload.\n    if (!isDebug && cachedIndexHtml !== null && cachedTokenValue === tokenValue) {\n      return cachedIndexHtml;\n    }\n    const template = await readFileFs(indexHtmlPath, 'utf8');\n    // Defensive HTML attribute escape. Tokens are strict 64-char lowercase hex\n    // today so no escaping is actually needed, but if the token format ever\n    // changes this prevents an HTML-injection regression from landing silently.\n    const escapedToken = tokenValue\n      .replaceAll('&', '&amp;')\n      .replaceAll('\"', '&quot;')\n      .replaceAll(\"'\", '&#39;')\n      .replaceAll('<', '&lt;')\n      .replaceAll('>', '&gt;');\n    cachedIndexHtml = template.replaceAll(TOKEN_META_PLACEHOLDER, escapedToken);\n    cachedTokenValue = tokenValue;\n    return cachedIndexHtml;\n  };\n\n  app.get('/{*path}', async (req, res) => {\n    const normalizedPath = req.path.normalize('NFC');\n    if (normalizedPath.startsWith('/api/')) {\n      res.status(404).json({ error: `API route not found: ${normalizedPath}` });\n      return;\n    }\n    if (normalizedPath.startsWith('/pages/')) {\n      res.status(404).json({ error: `Page not found: ${normalizedPath}` });\n      return;\n    }\n    try {\n      const html = await renderIndexHtml();\n      res.setHeader('Content-Type', 'text/html; charset=utf-8');\n      // In debug mode, prevent browser caching so UI changes are picked up\n      // immediately. In production, allow short caching for performance.\n      const isDebug = Boolean(process.env.DOLLHOUSE_DEBUG || process.env.ENABLE_DEBUG);\n      res.setHeader('Cache-Control', isDebug\n        ? 'no-cache, no-store, must-revalidate'\n        : 'private, max-age=60');\n      res.send(html);\n    } catch (err) {\n      logger.error(`[WebUI] Failed to render index.html: ${(err as Error).message}`);\n      res.status(500).send('Failed to load console');\n    }\n  });\n\n  // Global error handler — catch Express errors and route to logger instead of terminal.\n  // Without this, Express dumps stack traces to stderr (visible in --web terminal).\n  // All errors still appear in the management console's Logs tab via MemoryLogSink.\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  app.use((err: Error, _req: import('express').Request, res: import('express').Response, _next: import('express').NextFunction) => {\n    const status = (err as any).status || (err as any).statusCode || 500;\n    logger.warn(`[WebUI] ${err.name}: ${err.message}`);\n    if (!res.headersSent) {\n      res.status(status).json({ error: err.message });\n    }\n  });\n\n  // Bind to localhost only — handle port conflicts gracefully.\n  // Extracted to a helper to keep startWebServer's cognitive complexity manageable.\n  result.bindResult = await bindAndListen(app, port, options);\n\n  return result;\n}\n\n/**\n * Mount the logs, metrics, and health routes. These are only mounted when the\n * corresponding sinks are provided (memory log sink for logs+health, metrics\n * sink for the metrics tab). Extracted from startWebServer to cap the main\n * function's cognitive complexity.\n */\nfunction mountConsoleRoutes(\n  app: import('express').Express,\n  options: WebServerOptions,\n  result: WebServerResult,\n): void {\n  let logRoutes: LogRoutesResult | undefined;\n  let metricsRoutes: MetricsRoutesResult | undefined;\n\n  if (options.memorySink) {\n    logRoutes = createLogRoutes(options.memorySink);\n    app.use('/api', logRoutes.router);\n    result.logBroadcast = logRoutes.broadcast;\n    logger.info('[WebUI] Log viewer routes mounted at /api/logs');\n  }\n\n  if (options.metricsSink) {\n    metricsRoutes = createMetricsRoutes(options.metricsSink);\n    app.use('/api', metricsRoutes.router);\n    result.metricsOnSnapshot = metricsRoutes.onSnapshot;\n    logger.info('[WebUI] Metrics routes mounted at /api/metrics');\n  }\n\n  if (options.memorySink) {\n    const healthRouter = createHealthRoutes({\n      memorySink: options.memorySink,\n      metricsSink: options.metricsSink,\n      logClientCount: logRoutes ? logRoutes.clientCount : () => 0,\n      metricsClientCount: metricsRoutes ? metricsRoutes.clientCount : () => 0,\n    });\n    app.use('/api', healthRouter);\n  }\n}\n\n/**\n * Print the startup banner to stderr.\n *\n * NOTE: Use stderr for terminal output, not stdout. In MCP stdio mode, stdout\n * is reserved for JSON-RPC messages — any non-JSON output corrupts the protocol.\n * stderr is safe for human-readable messages in both MCP and standalone modes.\n */\nfunction printStartupBanner(port: number, tokenStore: ConsoleTokenStore | undefined): void {\n  const url = `http://${CONSOLE_HOST}:${port}`;\n  const fallbackUrl = `http://127.0.0.1:${port}`;\n  logger.info(`[WebUI] Management console running at ${url}`);\n  console.error(`\\n  DollhouseMCP Management Console\\n  ${url}\\n  ${fallbackUrl} (fallback)\\n`);\n  if (tokenStore) {\n    console.error(`  Session token: ${tokenStore.getFilePath()}\\n`);\n  }\n  console.error(`  Type \"q\" or \"quit\" to exit.\\n`);\n}\n\n/**\n * Retry binding an already-configured Express app to a port.\n * Used by UnifiedConsole when EADDRINUSE occurs — avoids recreating\n * the Express app and all its routes on each retry attempt.\n */\nexport async function retryBind(\n  app: import('express').Express,\n  port: number,\n  options: WebServerOptions,\n): Promise<BindResult> {\n  return bindAndListen(app, port, options);\n}\n\n/**\n * Bind the Express app to 127.0.0.1:port and handle success/conflict paths.\n * Returns a BindResult so the caller can detect and handle port conflicts\n * (e.g., retry after killing a stale process).\n */\nasync function bindAndListen(\n  app: import('express').Express,\n  port: number,\n  options: WebServerOptions,\n): Promise<BindResult> {\n  return new Promise<BindResult>((resolve) => {\n    const httpServer = app.listen(port, '127.0.0.1', () => {\n      serverRunning = true;\n      serverPort = port;\n      activeHttpServer = httpServer;\n      printStartupBanner(port, options.tokenStore);\n      if (options.openBrowser) {\n        openInBrowser(`http://${CONSOLE_HOST}:${port}`);\n      }\n      resolve({ success: true });\n    });\n    httpServer.on('error', (err: NodeJS.ErrnoException) => {\n      resolve(handleListenError(err, port, options.openBrowser));\n    });\n  });\n}\n\n/**\n * Handle errors from app.listen(). Returns a BindResult describing the failure.\n * EADDRINUSE is logged at WARN (not INFO) so it's visible in production logs.\n */\nfunction handleListenError(\n  err: NodeJS.ErrnoException,\n  port: number,\n  openBrowser: boolean | undefined,\n): BindResult {\n  if (err.code === 'EADDRINUSE') {\n    const url = `http://${CONSOLE_HOST}:${port}`;\n    logger.warn(`[WebUI] Port ${port} already in use — another process holds this port`);\n    console.error(`\\n  DollhouseMCP Management Console (existing instance)\\n  ${url}\\n`);\n    if (openBrowser) {\n      openInBrowser(url);\n    }\n    return { success: false, error: 'EADDRINUSE', detail: `Port ${port} already in use` };\n  }\n  logger.error(`[WebUI] Failed to bind port ${port}: ${err.message}`);\n  return { success: false, error: 'OTHER', detail: err.message };\n}\n\n/**\n * Open the portfolio browser from within the MCP server process.\n *\n * Starts the web server if not already running, then opens the system\n * browser to the portfolio UI. Returns a result object indicating\n * whether the server started and the browser opened successfully.\n *\n * Called by the `open_portfolio_browser` MCP-AQL operation (Issue #774).\n *\n * @param portfolioDir - Path to the portfolio directory (e.g., ~/.dollhouse/portfolio)\n * @param port - Port to bind to (defaults to `DOLLHOUSE_WEB_CONSOLE_PORT`)\n * @returns Result with URL, server status, and browser open status\n */\n/**\n * Options for opening the portfolio browser.\n */\nexport interface OpenBrowserOptions {\n  portfolioDir: string;\n  port?: number;\n  mcpAqlHandler?: MCPAQLHandler;\n  tab?: string;\n  urlParams?: Record<string, string>;\n  memorySink?: MemoryLogSink;\n  metricsSink?: MemoryMetricsSink;\n}\n\n/**\n * Self-provision sinks, token store, and ingest routes, then start the web\n * server. Extracted from openPortfolioBrowser to keep cognitive complexity\n * manageable (SonarCloud S3776).\n */\nasync function startFallbackServer(options: OpenBrowserOptions, port: number): Promise<void> {\n  let memorySink = options.memorySink;\n  let metricsSink = options.metricsSink;\n\n  if (!memorySink) {\n    const { MemoryLogSink: LogSink } = await import('../logging/sinks/MemoryLogSink.js');\n    memorySink = new LogSink({ appCapacity: 10000, securityCapacity: 5000, perfCapacity: 2000, telemetryCapacity: 1000 });\n  }\n  if (!metricsSink) {\n    const { MemoryMetricsSink: MetricsSink } = await import('../metrics/sinks/MemoryMetricsSink.js');\n    metricsSink = new MetricsSink(240);\n  }\n\n  // Reuse cached token store — two instances on the same file can race on writes.\n  if (!cachedTokenStore) {\n    const { ConsoleTokenStore: TokenStore } = await import('./console/consoleToken.js');\n    const { pickRandomPuppetName } = await import('./console/SessionNames.js');\n    cachedTokenStore = new TokenStore(env.DOLLHOUSE_CONSOLE_TOKEN_FILE);\n    try { await cachedTokenStore.ensureInitialized(pickRandomPuppetName()); }\n    catch (err) { logger.warn('[WebUI] Failed to init token store for browser open', err); }\n  }\n\n  // logBroadcast is deferred — wired after startWebServer returns the real broadcast fn.\n  let liveBroadcast: ((entry: import('../logging/types.js').UnifiedLogEntry) => void) | undefined;\n  const { createIngestRoutes } = await import('./console/IngestRoutes.js');\n  const ingestResult = createIngestRoutes({\n    logBroadcast: (entry) => liveBroadcast?.(entry),\n  });\n  ingestResult.registerConsoleSession();\n\n  const webResult = await startWebServer({\n    portfolioDir: options.portfolioDir,\n    port,\n    openBrowser: false,\n    mcpAqlHandler: options.mcpAqlHandler,\n    memorySink,\n    metricsSink,\n    tokenStore: cachedTokenStore,\n    additionalRouters: [ingestResult.router],\n  });\n\n  liveBroadcast = webResult.logBroadcast;\n}\n\nexport async function openPortfolioBrowser(options: OpenBrowserOptions): Promise<BrowserOpenResult> {\n  const targetPort = options.port || DEFAULT_PORT;\n  const baseUrl = `http://${CONSOLE_HOST}:${targetPort}`;\n\n  // Build URL with optional tab hash and query parameters\n  let url = baseUrl;\n  if (options.tab) {\n    const qs = options.urlParams ? new URLSearchParams(options.urlParams).toString() : '';\n    url = `${baseUrl}/#${options.tab}${qs ? '?' + qs : ''}`;\n  } else if (options.urlParams && Object.keys(options.urlParams).length > 0) {\n    const qs = new URLSearchParams(options.urlParams).toString();\n    url = `${baseUrl}/#portfolio?${qs}`;\n  }\n\n  const alreadyRunning = serverRunning;\n\n  if (!serverRunning) {\n    await startFallbackServer(options, targetPort);\n  }\n\n  const browserResult = await openInBrowser(url);\n\n  return {\n    url,\n    alreadyRunning,\n    browserOpened: browserResult.success,\n    ...(browserResult.error ? { warning: `Browser could not be opened automatically: ${browserResult.error}. Open ${url} manually.` } : {}),\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/web/server.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * DollhouseMCP Web UI Server\n *\n * Lightweight Express server for browsing portfolio elements in a browser.\n * Bound to 127.0.0.1 only (localhost). Read-only for V1.\n *\n * Can be started standalone (`--web` flag) or from within the MCP server\n * process via `openPortfolioBrowser()`.\n *\n * @see https://github.com/DollhouseMCP/mcp-server-v2-refactor/issues/704\n * @see https://github.com/DollhouseMCP/mcp-server-v2-refactor/issues/774\n */\n\nimport express from 'express';\nimport { join, dirname, extname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { execFile } from 'node:child_process';\nimport { platform } from 'node:os';\nimport { mkdir, readdir, readFile as readFileFs } from 'node:fs/promises';\nimport { createApiRoutes, createGatewayApiRoutes } from './routes.js';\nimport { createLogRoutes, type LogRoutesResult } from './routes/logRoutes.js';\nimport { createMetricsRoutes, type MetricsRoutesResult } from './routes/metricsRoutes.js';\nimport { createHealthRoutes } from './routes/healthRoutes.js';\nimport { createSetupRoutes } from './routes/setupRoutes.js';\nimport { createTotpRoutes } from './routes/totpRoutes.js';\nimport { createTokenRoutes } from './routes/tokenRoutes.js';\nimport { logger } from '../utils/logger.js';\nimport { env } from '../config/env.js';\nimport type { MCPAQLHandler } from '../handlers/mcp-aql/MCPAQLHandler.js';\nimport type { MemoryLogSink } from '../logging/sinks/MemoryLogSink.js';\nimport type { MemoryMetricsSink } from '../metrics/sinks/MemoryMetricsSink.js';\nimport type { ConsoleTokenStore } from './console/consoleToken.js';\nimport { createAuthMiddleware } from './middleware/authMiddleware.js';\n\n/**\n * Public path prefixes that never require authentication (#1780).\n * These endpoints return safe metadata or act as health probes — requiring\n * tokens on them would break monitoring and client detection without adding\n * real security value.\n */\nconst PUBLIC_PATH_PREFIXES = [\n  '/api/health',\n  '/api/setup/version',\n  '/api/setup/mcpb',\n  '/api/setup/detect',\n  '/api/setup/license',\n];\n\n/** Placeholder in index.html that is replaced with the current console token. */\nconst TOKEN_META_PLACEHOLDER = '{{CONSOLE_TOKEN}}';\n\nconst __dirname = dirname(fileURLToPath(import.meta.url));\n/**\n * Default port for standalone `startWebServer` calls. Reads from the\n * `DOLLHOUSE_WEB_CONSOLE_PORT` env var so there is a single source of\n * truth (see `src/config/env.ts`). Callers passing an explicit `port` in\n * `WebServerOptions` override this default.\n */\nconst DEFAULT_PORT = env.DOLLHOUSE_WEB_CONSOLE_PORT;\nconst CONSOLE_HOST = 'dollhouse.localhost';\nconst ALLOWED_PAGE_EXTENSIONS = new Set(['.html', '.htm']);\n/** Max JSON body for setup routes (install/open-config). Ingest routes use their own 1mb limit. */\nconst SETUP_BODY_LIMIT = '1kb';\n\n/** Track whether the web server is already running in-process. */\nlet serverRunning = false;\nlet serverPort = DEFAULT_PORT;\n/** Active HTTP server instance — tracked so _resetServerState can close it. */\nlet activeHttpServer: import('node:http').Server | null = null;\n/** Cached token store for openPortfolioBrowser — prevents duplicate instances on the same file. */\nlet cachedTokenStore: ConsoleTokenStore | null = null;\n\n/** Check whether the web server has been started in this process. */\nexport function isWebServerRunning(): boolean {\n  return serverRunning;\n}\n\n/**\n * Reset module-level server state. Exported for testing only —\n * allows tests to exercise startWebServer/bindAndListen without\n * interference from prior runs in the same process.\n * @internal\n */\nexport function _resetServerState(): void {\n  if (activeHttpServer) {\n    activeHttpServer.close();\n    activeHttpServer = null;\n  }\n  serverRunning = false;\n  serverPort = DEFAULT_PORT;\n  cachedTokenStore = null;\n}\n\n/**\n * Options for starting the web server.\n */\nexport interface WebServerOptions {\n  /** Port to bind to (defaults to `DOLLHOUSE_WEB_CONSOLE_PORT`, see `src/config/env.ts`) */\n  port?: number;\n  /** Path to the portfolio directory (e.g., ~/.dollhouse/portfolio) */\n  portfolioDir: string;\n  /** Open the browser automatically after starting (default: false) */\n  openBrowser?: boolean;\n  /**\n   * MCPAQLHandler for routing through the MCP-AQL pipeline.\n   * When provided, API routes use the gateway (validated, cached, gatekeeper-checked).\n   * When absent, falls back to direct filesystem access (legacy behavior).\n   * Issue #796: Web MCP-AQL Gateway.\n   */\n  mcpAqlHandler?: MCPAQLHandler;\n  /** MemoryLogSink for log routes (optional — logs tab disabled if not provided) */\n  memorySink?: MemoryLogSink;\n  /** MemoryMetricsSink for metrics routes (optional — metrics tab disabled if not provided) */\n  metricsSink?: MemoryMetricsSink;\n  /** Additional routers to mount before the SPA fallback (e.g., ingest routes) */\n  additionalRouters?: import('express').Router[];\n  /**\n   * Console token store (#1780). When provided, the server will:\n   *   1. Mount Bearer token auth middleware before protected routers.\n   *   2. Inject the primary token into index.html so the browser client\n   *      can attach it to fetch calls and EventSource URLs.\n   *   3. Append the token file location to the startup banner.\n   * Auth enforcement is still gated on DOLLHOUSE_WEB_AUTH_ENABLED — the\n   * middleware is a pass-through when the flag is false (the Phase 1 default).\n   */\n  tokenStore?: ConsoleTokenStore;\n}\n\n/**\n * Result of attempting to bind the HTTP server to a port.\n */\nexport interface BindResult {\n  success: boolean;\n  error?: 'EADDRINUSE' | 'OTHER';\n  detail?: string;\n}\n\n/**\n * Result of starting the web server, including hooks for DI wiring.\n */\nexport interface WebServerResult {\n  /** Express app instance — for mounting additional routes (e.g., ingest routes) */\n  app?: import('express').Express;\n  /** Log broadcast function — call with each entry to push to SSE clients */\n  logBroadcast?: (entry: import('../logging/types.js').UnifiedLogEntry) => void;\n  /** Metrics snapshot function — call with each snapshot to push to SSE clients */\n  metricsOnSnapshot?: (snapshot: import('../metrics/types.js').MetricSnapshot) => void;\n  /** Result of the port binding attempt */\n  bindResult?: BindResult;\n}\n\n/**\n * Result of attempting to open the browser.\n */\nexport interface BrowserOpenResult {\n  /** The URL the server is running on */\n  url: string;\n  /** Whether the server was already running (true) or just started (false) */\n  alreadyRunning: boolean;\n  /** Whether the browser was successfully opened */\n  browserOpened: boolean;\n  /** Warning message if the browser could not be opened */\n  warning?: string;\n}\n\n/**\n * Open a URL in the system's default browser.\n *\n * Platform-aware:\n * - macOS: `open`\n * - Linux: `xdg-open`\n * - Windows: `start`\n *\n * @param url - The URL to open\n * @returns Promise that resolves to true if the browser opened, false with error message if not\n */\nfunction openInBrowser(url: string): Promise<{ success: boolean; error?: string }> {\n  return new Promise((resolve) => {\n    const plat = platform();\n    const cmd = plat === 'darwin' ? 'open'\n      : plat === 'win32' ? 'start'\n      : 'xdg-open';\n\n    // Security: use execFile with URL as argument array, not string interpolation\n    const urlStr = String(url);\n    // Accept localhost, 127.0.0.1, and *.localhost subdomains (RFC 6761)\n    if (!/^https?:\\/\\/(localhost|127\\.0\\.0\\.1|[\\w-]+\\.localhost)[:/]/.test(urlStr)) {\n      resolve({ success: false, error: 'URL must be a localhost HTTP URL' });\n      return;\n    }\n    execFile(cmd, [urlStr], (err) => {\n      if (err) {\n        logger.warn(`[WebUI] Could not auto-open browser: ${err.message}`);\n        resolve({ success: false, error: err.message });\n      } else {\n        resolve({ success: true });\n      }\n    });\n  });\n}\n\n/**\n * Start the portfolio web server.\n *\n * Binds to 127.0.0.1 only (localhost). Serves the portfolio browser\n * frontend and API routes for reading elements.\n *\n * Idempotent: if the server is already running, optionally opens the\n * browser without starting a second instance.\n *\n * @param options - Server configuration\n * @returns Hooks for DI wiring (log broadcast, metrics onSnapshot)\n */\nexport async function startWebServer(options: WebServerOptions): Promise<WebServerResult> {\n  const port = options.port || DEFAULT_PORT;\n  const result: WebServerResult = {};\n\n  if (serverRunning) {\n    if (options.openBrowser) {\n      openInBrowser(`http://${CONSOLE_HOST}:${serverPort}`);\n    }\n    return result;\n  }\n\n  const app = express();\n  result.app = app;\n  app.disable('x-powered-by');\n\n  // Security headers\n  app.use((_req, res, next) => {\n    res.setHeader('X-Content-Type-Options', 'nosniff');\n    res.setHeader('X-Frame-Options', 'DENY');\n    res.setHeader('X-XSS-Protection', '1; mode=block');\n    res.setHeader('Referrer-Policy', 'no-referrer');\n    res.setHeader('Access-Control-Allow-Origin', `http://${CONSOLE_HOST}:${port}`);\n    res.setHeader('Content-Security-Policy', [\n      \"default-src 'self'\",\n      \"script-src 'self' cdn.jsdelivr.net cdnjs.cloudflare.com\",\n      \"style-src 'self' 'unsafe-inline' cdnjs.cloudflare.com cdn.jsdelivr.net\",\n      \"img-src 'self' data:\",\n      \"connect-src 'self' raw.githubusercontent.com\",\n      \"font-src 'self'\",\n    ].join('; '));\n    next();\n  });\n\n  // Console token authentication middleware (#1780). Mounted before any /api\n  // routes so every protected endpoint goes through it. When the feature flag\n  // DOLLHOUSE_WEB_AUTH_ENABLED is false (Phase 1 default) this is a pass-through.\n  // Public endpoints in PUBLIC_PATH_PREFIXES always bypass auth regardless of flag.\n  if (options.tokenStore) {\n    const authMiddleware = createAuthMiddleware({\n      store: options.tokenStore,\n      enabled: env.DOLLHOUSE_WEB_AUTH_ENABLED,\n      publicPathPrefixes: PUBLIC_PATH_PREFIXES,\n      label: 'api',\n    });\n    app.use('/api', authMiddleware);\n    logger.info(\n      `[WebUI] Console auth middleware mounted ${env.DOLLHOUSE_WEB_AUTH_ENABLED ? 'ENFORCING' : 'pass-through (flag off)'}`,\n    );\n\n    // TOTP enrollment routes (#1794). Mounted AFTER the /api auth middleware\n    // because the router adds its own always-on auth guard — the global auth\n    // middleware at /api is a pass-through during Phase 1 rollout, but the\n    // TOTP router enforces regardless of DOLLHOUSE_WEB_AUTH_ENABLED so an\n    // attacker with local port access cannot pre-enroll a second factor and\n    // lock the legitimate user out.\n    app.use('/api/console/totp', createTotpRoutes({ store: options.tokenStore }));\n    logger.info('[WebUI] TOTP routes mounted at /api/console/totp (always-on auth)');\n\n    // Token management routes (#1795). Mounted alongside the TOTP router with\n    // the same always-on auth pattern. Currently hosts the rotation endpoint;\n    // future token management operations (list, revoke) go here too.\n    app.use('/api/console/token', createTokenRoutes({ store: options.tokenStore }));\n    logger.info('[WebUI] Token routes mounted at /api/console/token (always-on auth)');\n  }\n\n  // Setup routes: auto-install DollhouseMCP to MCP clients (mount BEFORE API routes)\n  // Body limit scoped to setup routes only — ingest routes need 1mb for follower log forwarding\n  const setupJsonParser = express.json({ limit: SETUP_BODY_LIMIT, type: 'application/json' });\n  const { installHandler, openConfigHandler, versionHandler, mcpbRedirectHandler, detectHandler, getLicenseHandler, setLicenseHandler, verifyLicenseHandler, resendVerificationHandler } = createSetupRoutes();\n  app.post('/api/setup/install', setupJsonParser, installHandler);\n  app.post('/api/setup/open-config', setupJsonParser, openConfigHandler);\n  app.get('/api/setup/version', versionHandler);\n  app.get('/api/setup/mcpb', mcpbRedirectHandler);\n  app.get('/api/setup/detect', detectHandler);\n  app.get('/api/setup/license', getLicenseHandler);\n  app.post('/api/setup/license', setupJsonParser, setLicenseHandler);\n  app.post('/api/setup/license/verify', setupJsonParser, verifyLicenseHandler);\n  app.post('/api/setup/license/resend', setupJsonParser, resendVerificationHandler);\n  logger.info('[WebUI] Setup routes mounted at /api/setup');\n\n  // API routes — use MCP-AQL gateway when handler is available (Issue #796)\n  if (options.mcpAqlHandler) {\n    app.use('/api', createGatewayApiRoutes(options.mcpAqlHandler, options.portfolioDir));\n\n    // Permission evaluation routes (POST /evaluate_permission, GET /permissions/status)\n    const { registerPermissionRoutes } = await import('./routes/permissionRoutes.js');\n    const permRouter = (await import('express')).Router();\n    registerPermissionRoutes(permRouter, options.mcpAqlHandler);\n    app.use('/api', permRouter);\n\n    logger.info('[WebUI] API routes using MCP-AQL Gateway + permission routes');\n  } else {\n    app.use('/api', createApiRoutes(options.portfolioDir));\n    logger.warn('[WebUI] API routes using direct filesystem access (no MCP-AQL handler available)');\n  }\n\n  // Console routes: logs, metrics, health — extracted to keep cognitive\n  // complexity of startWebServer manageable.\n  mountConsoleRoutes(app, options, result);\n\n  // Serve ~/.dollhouse/pages/ at /pages/ — dashboards, generated content, stack views\n  const pagesDir = join(dirname(options.portfolioDir), 'pages');\n  mkdir(pagesDir, { recursive: true }).catch(err => {\n    logger.warn(`[WebUI] Could not create pages directory: ${(err as Error).message}`);\n  });\n  app.use('/pages', express.static(pagesDir));\n\n  /**\n   * GET /api/pages\n   * Lists available HTML pages in ~/.dollhouse/pages/.\n   * Returns page names and their URLs for the management console.\n   */\n  app.get('/api/pages', async (_req, res) => {\n    try {\n      const files = await readdir(pagesDir);\n      const pages = files\n        .filter(f => !f.startsWith('.') && ALLOWED_PAGE_EXTENSIONS.has(extname(f)))\n        .map(f => ({ name: f, url: `/pages/${f}` }));\n      res.json({ pages, directory: pagesDir });\n    } catch {\n      res.json({ pages: [], directory: pagesDir });\n    }\n  });\n\n  // Additional routers (e.g., unified console ingest routes) — must mount before SPA fallback\n  options.additionalRouters?.forEach(router => app.use(router));\n\n  // Static frontend files\n  const publicDir = join(__dirname, 'public');\n  // Serve static assets but skip index.html — the SPA fallback below\n  // handles it with token injection (replaces {{CONSOLE_TOKEN}} in the\n  // meta tag). Without this, express.static serves the raw template\n  // and the browser never gets the auth token (#1780).\n  const isDebug = Boolean(process.env.DOLLHOUSE_DEBUG || process.env.ENABLE_DEBUG);\n  app.use(express.static(publicDir, {\n    index: false,\n    // In debug mode, disable caching on all static assets (JS, CSS) so\n    // UI changes are picked up on normal reload without Cmd+Shift+R.\n    ...(isDebug ? { etag: false, lastModified: false, maxAge: 0 } : {}),\n  }));\n\n  // SPA fallback with console token injection (#1780).\n  // Reads index.html on first request, substitutes the {{CONSOLE_TOKEN}} placeholder\n  // with the current token value, and caches the rendered string. The cache is\n  // auto-invalidated when the primary token changes (rotation), so a page reload\n  // after rotation picks up the new token without a server restart.\n  let cachedIndexHtml: string | null = null;\n  let cachedTokenValue: string | null = null;\n  const indexHtmlPath = join(publicDir, 'index.html');\n\n  const renderIndexHtml = async (): Promise<string> => {\n    const tokenValue = options.tokenStore?.getPrimaryTokenValue() ?? '';\n    // Auto-invalidate cache when the token changes (rotation).\n    // In debug mode, always re-read from disk so UI changes are picked up on reload.\n    if (!isDebug && cachedIndexHtml !== null && cachedTokenValue === tokenValue) {\n      return cachedIndexHtml;\n    }\n    const template = await readFileFs(indexHtmlPath, 'utf8');\n    // Defensive HTML attribute escape. Tokens are strict 64-char lowercase hex\n    // today so no escaping is actually needed, but if the token format ever\n    // changes this prevents an HTML-injection regression from landing silently.\n    const escapedToken = tokenValue\n      .replaceAll('&', '&amp;')\n      .replaceAll('\"', '&quot;')\n      .replaceAll(\"'\", '&#39;')\n      .replaceAll('<', '&lt;')\n      .replaceAll('>', '&gt;');\n    cachedIndexHtml = template.replaceAll(TOKEN_META_PLACEHOLDER, escapedToken);\n    cachedTokenValue = tokenValue;\n    return cachedIndexHtml;\n  };\n\n  app.get('/{*path}', async (req, res) => {\n    const normalizedPath = req.path.normalize('NFC');\n    if (normalizedPath.startsWith('/api/')) {\n      res.status(404).json({ error: `API route not found: ${normalizedPath}` });\n      return;\n    }\n    if (normalizedPath.startsWith('/pages/')) {\n      res.status(404).json({ error: `Page not found: ${normalizedPath}` });\n      return;\n    }\n    try {\n      const html = await renderIndexHtml();\n      res.setHeader('Content-Type', 'text/html; charset=utf-8');\n      // In debug mode, prevent browser caching so UI changes are picked up\n      // immediately. In production, allow short caching for performance.\n      const isDebug = Boolean(process.env.DOLLHOUSE_DEBUG || process.env.ENABLE_DEBUG);\n      res.setHeader('Cache-Control', isDebug\n        ? 'no-cache, no-store, must-revalidate'\n        : 'private, max-age=60');\n      res.send(html);\n    } catch (err) {\n      logger.error(`[WebUI] Failed to render index.html: ${(err as Error).message}`);\n      res.status(500).send('Failed to load console');\n    }\n  });\n\n  // Global error handler — catch Express errors and route to logger instead of terminal.\n  // Without this, Express dumps stack traces to stderr (visible in --web terminal).\n  // All errors still appear in the management console's Logs tab via MemoryLogSink.\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  app.use((err: Error, _req: import('express').Request, res: import('express').Response, _next: import('express').NextFunction) => {\n    const status = (err as any).status || (err as any).statusCode || 500;\n    logger.warn(`[WebUI] ${err.name}: ${err.message}`);\n    if (!res.headersSent) {\n      res.status(status).json({ error: err.message });\n    }\n  });\n\n  // Bind to localhost only — handle port conflicts gracefully.\n  // Extracted to a helper to keep startWebServer's cognitive complexity manageable.\n  result.bindResult = await bindAndListen(app, port, options);\n\n  return result;\n}\n\n/**\n * Mount the logs, metrics, and health routes. These are only mounted when the\n * corresponding sinks are provided (memory log sink for logs+health, metrics\n * sink for the metrics tab). Extracted from startWebServer to cap the main\n * function's cognitive complexity.\n */\nfunction mountConsoleRoutes(\n  app: import('express').Express,\n  options: WebServerOptions,\n  result: WebServerResult,\n): void {\n  let logRoutes: LogRoutesResult | undefined;\n  let metricsRoutes: MetricsRoutesResult | undefined;\n\n  if (options.memorySink) {\n    logRoutes = createLogRoutes(options.memorySink);\n    app.use('/api', logRoutes.router);\n    result.logBroadcast = logRoutes.broadcast;\n    logger.info('[WebUI] Log viewer routes mounted at /api/logs');\n  }\n\n  if (options.metricsSink) {\n    metricsRoutes = createMetricsRoutes(options.metricsSink);\n    app.use('/api', metricsRoutes.router);\n    result.metricsOnSnapshot = metricsRoutes.onSnapshot;\n    logger.info('[WebUI] Metrics routes mounted at /api/metrics');\n  }\n\n  if (options.memorySink) {\n    const healthRouter = createHealthRoutes({\n      memorySink: options.memorySink,\n      metricsSink: options.metricsSink,\n      logClientCount: logRoutes ? logRoutes.clientCount : () => 0,\n      metricsClientCount: metricsRoutes ? metricsRoutes.clientCount : () => 0,\n    });\n    app.use('/api', healthRouter);\n  }\n}\n\n/**\n * Print the startup banner to stderr.\n *\n * NOTE: Use stderr for terminal output, not stdout. In MCP stdio mode, stdout\n * is reserved for JSON-RPC messages — any non-JSON output corrupts the protocol.\n * stderr is safe for human-readable messages in both MCP and standalone modes.\n */\nfunction printStartupBanner(port: number, tokenStore: ConsoleTokenStore | undefined): void {\n  const url = `http://${CONSOLE_HOST}:${port}`;\n  const fallbackUrl = `http://127.0.0.1:${port}`;\n  logger.info(`[WebUI] Management console running at ${url}`);\n  console.error(`\\n  DollhouseMCP Management Console\\n  ${url}\\n  ${fallbackUrl} (fallback)\\n`);\n  if (tokenStore) {\n    console.error(`  Session token: ${tokenStore.getFilePath()}\\n`);\n  }\n  console.error(`  Type \"q\" or \"quit\" to exit.\\n`);\n}\n\n// Stale process recovery — extracted to StaleProcessRecovery.ts for independent testing (#1850).\nimport { recoverStalePort } from './console/StaleProcessRecovery.js';\nexport { findPidOnPort, killStaleProcess, recoverStalePort } from './console/StaleProcessRecovery.js';\n\n/**\n * Attempt a single port bind. Returns a BindResult without any recovery logic.\n */\nfunction attemptBind(\n  app: import('express').Express,\n  port: number,\n  options: WebServerOptions,\n): Promise<BindResult> {\n  return new Promise<BindResult>((resolve) => {\n    const httpServer = app.listen(port, '127.0.0.1', () => {\n      serverRunning = true;\n      serverPort = port;\n      activeHttpServer = httpServer;\n      printStartupBanner(port, options.tokenStore);\n      if (options.openBrowser) {\n        openInBrowser(`http://${CONSOLE_HOST}:${port}`);\n      }\n      resolve({ success: true });\n    });\n    httpServer.on('error', (err: NodeJS.ErrnoException) => {\n      if (err.code === 'EADDRINUSE') {\n        resolve({ success: false, error: 'EADDRINUSE', detail: `Port ${port} already in use` });\n      } else {\n        logger.error(`[WebUI] Failed to bind port ${port}: ${err.message}`);\n        resolve({ success: false, error: 'OTHER', detail: err.message });\n      }\n    });\n  });\n}\n\n/**\n * Bind the Express app to 127.0.0.1:port. On EADDRINUSE, attempt to find\n * and kill the stale DollhouseMCP process holding the port, then retry once.\n */\nasync function bindAndListen(\n  app: import('express').Express,\n  port: number,\n  options: WebServerOptions,\n): Promise<BindResult> {\n  const result = await attemptBind(app, port, options);\n  if (result.success || result.error !== 'EADDRINUSE') return result;\n\n  // Port occupied — attempt stale process recovery and retry\n  if (await recoverStalePort(port)) {\n    const retryResult = await attemptBind(app, port, options);\n    if (retryResult.success) return retryResult;\n  }\n\n  // Still can't bind — fall through with warning\n  logger.warn(`[WebUI] Port ${port} already in use — another process holds this port`);\n  console.error(`\\n  DollhouseMCP Management Console (existing instance)\\n  http://${CONSOLE_HOST}:${port}\\n`);\n  if (options.openBrowser) {\n    openInBrowser(`http://${CONSOLE_HOST}:${port}`);\n  }\n  return result;\n}\n\n/**\n * Open the portfolio browser from within the MCP server process.\n *\n * Starts the web server if not already running, then opens the system\n * browser to the portfolio UI. Returns a result object indicating\n * whether the server started and the browser opened successfully.\n *\n * Called by the `open_portfolio_browser` MCP-AQL operation (Issue #774).\n *\n * @param portfolioDir - Path to the portfolio directory (e.g., ~/.dollhouse/portfolio)\n * @param port - Port to bind to (defaults to `DOLLHOUSE_WEB_CONSOLE_PORT`)\n * @returns Result with URL, server status, and browser open status\n */\n/**\n * Options for opening the portfolio browser.\n */\nexport interface OpenBrowserOptions {\n  portfolioDir: string;\n  port?: number;\n  mcpAqlHandler?: MCPAQLHandler;\n  tab?: string;\n  urlParams?: Record<string, string>;\n  memorySink?: MemoryLogSink;\n  metricsSink?: MemoryMetricsSink;\n}\n\n/**\n * Self-provision sinks, token store, and ingest routes, then start the web\n * server. Extracted from openPortfolioBrowser to keep cognitive complexity\n * manageable (SonarCloud S3776).\n */\nasync function startFallbackServer(options: OpenBrowserOptions, port: number): Promise<void> {\n  let memorySink = options.memorySink;\n  let metricsSink = options.metricsSink;\n\n  if (!memorySink) {\n    const { MemoryLogSink: LogSink } = await import('../logging/sinks/MemoryLogSink.js');\n    memorySink = new LogSink({ appCapacity: 10000, securityCapacity: 5000, perfCapacity: 2000, telemetryCapacity: 1000 });\n  }\n  if (!metricsSink) {\n    const { MemoryMetricsSink: MetricsSink } = await import('../metrics/sinks/MemoryMetricsSink.js');\n    metricsSink = new MetricsSink(240);\n  }\n\n  // Reuse cached token store — two instances on the same file can race on writes.\n  if (!cachedTokenStore) {\n    const { ConsoleTokenStore: TokenStore } = await import('./console/consoleToken.js');\n    const { pickRandomPuppetName } = await import('./console/SessionNames.js');\n    cachedTokenStore = new TokenStore(env.DOLLHOUSE_CONSOLE_TOKEN_FILE);\n    try { await cachedTokenStore.ensureInitialized(pickRandomPuppetName()); }\n    catch (err) { logger.warn('[WebUI] Failed to init token store for browser open', err); }\n  }\n\n  // logBroadcast is deferred — wired after startWebServer returns the real broadcast fn.\n  let liveBroadcast: ((entry: import('../logging/types.js').UnifiedLogEntry) => void) | undefined;\n  const { createIngestRoutes } = await import('./console/IngestRoutes.js');\n  const ingestResult = createIngestRoutes({\n    logBroadcast: (entry) => liveBroadcast?.(entry),\n  });\n  ingestResult.registerConsoleSession();\n\n  const webResult = await startWebServer({\n    portfolioDir: options.portfolioDir,\n    port,\n    openBrowser: false,\n    mcpAqlHandler: options.mcpAqlHandler,\n    memorySink,\n    metricsSink,\n    tokenStore: cachedTokenStore,\n    additionalRouters: [ingestResult.router],\n  });\n\n  liveBroadcast = webResult.logBroadcast;\n}\n\nexport async function openPortfolioBrowser(options: OpenBrowserOptions): Promise<BrowserOpenResult> {\n  const targetPort = options.port || DEFAULT_PORT;\n  const baseUrl = `http://${CONSOLE_HOST}:${targetPort}`;\n\n  // Build URL with optional tab hash and query parameters\n  let url = baseUrl;\n  if (options.tab) {\n    const qs = options.urlParams ? new URLSearchParams(options.urlParams).toString() : '';\n    url = `${baseUrl}/#${options.tab}${qs ? '?' + qs : ''}`;\n  } else if (options.urlParams && Object.keys(options.urlParams).length > 0) {\n    const qs = new URLSearchParams(options.urlParams).toString();\n    url = `${baseUrl}/#portfolio?${qs}`;\n  }\n\n  const alreadyRunning = serverRunning;\n\n  if (!serverRunning) {\n    await startFallbackServer(options, targetPort);\n  }\n\n  const browserResult = await openInBrowser(url);\n\n  return {\n    url,\n    alreadyRunning,\n    browserOpened: browserResult.success,\n    ...(browserResult.error ? { warning: `Browser could not be opened automatically: ${browserResult.error}. Open ${url} manually.` } : {}),\n  };\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dollhousemcp/mcp-server",
-  "version": "2.0.12-rc.2",
+  "version": "2.0.12-rc.3",
   "description": "DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.",
   "type": "module",
   "main": "dist/index.js",

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.DollhouseMCP/mcp-server",
   "title": "DollhouseMCP",
   "description": "OSS to create Personas, Skills, Templates, Agents, and Memories to customize your AI experience.",
-  "version": "2.0.12-rc.2",
+  "version": "2.0.12-rc.3",
   "homepage": "https://dollhousemcp.com",
   "repository": {
     "type": "git",
@@ -29,7 +29,7 @@
     {
       "registryType": "npm",
       "identifier": "@dollhousemcp/mcp-server",
-      "version": "2.0.12-rc.2",
+      "version": "2.0.12-rc.3",
       "transport": {
         "type": "stdio"
       }