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

package/dist/web/console/UnifiedConsole.js

@@ -13,11 +13,63 @@
  * @since v2.1.0 — Issue #1700
  */
 import { logger } from '../../utils/logger.js';
-import { electLeader, isLeaderWebConsoleReachable, forceClaimLeadership, startHeartbeat, registerLeaderCleanup, } from './LeaderElection.js';
+import { electLeader, isLeaderWebConsoleReachable, forceClaimLeadership, startHeartbeat, registerLeaderCleanup, detectLegacyLeader, } from './LeaderElection.js';
 import { createIngestRoutes } from './IngestRoutes.js';
 import { LeaderForwardingLogSink, SessionHeartbeat, } from './LeaderForwardingSink.js';
-/** Fixed port for the unified console leader */
-const CONSOLE_PORT = 3939;
+import { PromotionManager } from './PromotionManager.js';
+import { ConsoleTokenStore } from './consoleToken.js';
+import { env } from '../../config/env.js';
+/**
+ * Default console port from the env var. Used as fallback when no port
+ * is provided via config file or options. The resolution hierarchy is:
+ *   1. options.port (from config file, resolved by the DI container)
+ *   2. DOLLHOUSE_WEB_CONSOLE_PORT env var
+ *   3. 41715 (hardcoded default in env.ts)
+ */
+const DEFAULT_CONSOLE_PORT = env.DOLLHOUSE_WEB_CONSOLE_PORT;
+/**
+ * Check for a running legacy (pre-authentication) DollhouseMCP console and
+ * log a WARN-level message if one is found (#1794).
+ *
+ * Extracted from `startUnifiedConsole` so the wiring can be integration-
+ * tested in isolation without spinning up a full web server and leader
+ * election. The implementation is fire-and-forget: detection failures
+ * are logged at DEBUG and never propagate, because a failure here must
+ * not block leader election of the authenticated console.
+ *
+ * @param currentPort - The port the authenticated console intends to
+ *                      bind to. Used in the warning message to help the
+ *                      user tell the two consoles apart.
+ * @param detect      - Optional injection point for the detection
+ *                      function. Defaults to `detectLegacyLeader`. Tests
+ *                      pass a stub.
+ * @param log         - Optional injection point for the logger. Defaults
+ *                      to the module logger. Tests pass a spy.
+ * @returns The legacy leader info from `detect()`, or null if detection
+ *          threw. Exposed so tests can assert the full result shape.
+ */
+export async function warnIfLegacyConsolePresent(currentPort, detect = detectLegacyLeader, log = logger) {
+    try {
+        const legacy = await detect();
+        if (legacy.legacyRunning) {
+            log.warn(`[UnifiedConsole] Legacy (pre-authentication) DollhouseMCP console detected ` +
+                `(pid=${legacy.pid}, port=${legacy.port}). Both consoles will run ` +
+                `independently on different ports with different security posture. ` +
+                `The authenticated console (this process) uses port ${currentPort}; ` +
+                `the legacy console uses port ${legacy.port ?? 3939}. ` +
+                `For consistent security, update the legacy installation to a ` +
+                `version with the authenticated console.`);
+        }
+        return legacy;
+    }
+    catch (err) {
+        // Best-effort — never block election on a detection failure
+        log.debug('[UnifiedConsole] Legacy leader detection failed', {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return null;
+    }
+}
 /**
  * Start the unified web console.
  *
@@ -25,29 +77,54 @@ const CONSOLE_PORT = 3939;
  * or sets up event forwarding (follower).
  */
 export async function startUnifiedConsole(options) {
-    let election = await electLeader(options.sessionId, CONSOLE_PORT);
+    // Resolve port: options (config file) → env var → default
+    const consolePort = options.port || DEFAULT_CONSOLE_PORT;
+    logger.debug(`[UnifiedConsole] Port resolved: ${consolePort}` +
+        (options.port ? ' (from config file)' : ` (from env/default)`));
+    // Legacy-leader detection (#1794) — warn the user if a pre-auth
+    // DollhouseMCP console is running alongside this authenticated one.
+    // They will coexist fine because of port + lock + token file isolation,
+    // but the user should know both exist so the differing security posture
+    // between them doesn't look like a bug.
+    await warnIfLegacyConsolePresent(consolePort);
+    let election = await electLeader(options.sessionId, consolePort);
     // If we lost the election, check if the leader is actually running a web console.
     // An MCP stdio process may hold leadership but not serve web routes.
     // In that case, force a takeover so the web console works properly.
     if (election.role === 'follower') {
         const reachable = await isLeaderWebConsoleReachable(election.leaderInfo);
         if (!reachable) {
-            election = await forceClaimLeadership(options.sessionId, CONSOLE_PORT);
+            election = await forceClaimLeadership(options.sessionId, consolePort);
         }
     }
     if (election.role === 'leader') {
-        return startAsLeader(options, election);
+        return startAsLeader(options, election, consolePort);
     }
     else {
-        return startAsFollower(options, election);
+        return startAsFollower(options, election, consolePort);
     }
 }
 /**
  * Start as the console leader.
- * Binds port 3939, mounts all routes including ingestion, starts heartbeat.
+ * Binds the resolved console port (config file → env var → default),
+ * mounts all routes including ingestion, starts heartbeat.
  */
-async function startAsLeader(options, election) {
+async function startAsLeader(options, election, consolePort = DEFAULT_CONSOLE_PORT) {
     const { startWebServer } = await import('../server.js');
+    const { pickRandomPuppetName } = await import('./SessionNames.js');
+    // Initialize the console token store (#1780). Creates the token file on
+    // first run, reads the existing tokens on subsequent runs. The token is
+    // persistent across restarts — only rotated on explicit request (Phase 2).
+    // Feature flag DOLLHOUSE_WEB_AUTH_ENABLED controls enforcement; the file
+    // is generated regardless so consumers can attach tokens preemptively.
+    const tokenStore = new ConsoleTokenStore(env.DOLLHOUSE_CONSOLE_TOKEN_FILE);
+    const primaryToken = await tokenStore.ensureInitialized(pickRandomPuppetName());
+    logger.info('[UnifiedConsole] Console token store initialized', {
+        tokenId: primaryToken.id,
+        tokenName: primaryToken.name,
+        file: tokenStore.getFilePath(),
+        authEnforced: env.DOLLHOUSE_WEB_AUTH_ENABLED,
+    });
     // Pre-create a placeholder broadcast that we'll wire up after the server starts
     let liveBroadcast;
     let liveMetricsOnSnapshot;
@@ -58,15 +135,41 @@ async function startAsLeader(options, election) {
     });
     // Register the leader as a session
     ingestResult.registerLeaderSession(options.sessionId, process.pid);
-    // Start the web server with ingest routes mounted before the SPA fallback
-    const webResult = await startWebServer({
+    // Register the web console itself so the session indicator is never empty (#1805)
+    ingestResult.registerConsoleSession();
+    // Start the web server with ingest routes mounted before the SPA fallback.
+    // If the port is occupied by a stale process, retry with exponential backoff.
+    const serverOpts = {
         portfolioDir: options.portfolioDir,
         memorySink: options.memorySink,
         metricsSink: options.metricsSink,
-        port: CONSOLE_PORT,
+        port: consolePort,
         additionalRouters: [ingestResult.router],
+        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];
+    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`);
+        }
+    }
     // Wire SSE broadcasts for this leader's own events
     options.wireSSEBroadcasts(webResult, options.metricsSink);
     // Now wire the live broadcast functions into the ingest routes
@@ -87,13 +190,13 @@ async function startAsLeader(options, election) {
     const stopHeartbeat = startHeartbeat(election.leaderInfo);
     registerLeaderCleanup();
     logger.info('[UnifiedConsole] Leader started', {
-        sessionId: options.sessionId, port: CONSOLE_PORT, pid: process.pid,
+        sessionId: options.sessionId, port: consolePort, pid: process.pid,
         role: 'leader', ingestRoutes: ['/api/ingest/logs', '/api/ingest/metrics', '/api/ingest/session', '/api/sessions'],
     });
     return {
         role: 'leader',
         election,
-        port: CONSOLE_PORT,
+        port: consolePort,
         cleanup: async () => {
             stopHeartbeat();
         },
@@ -103,13 +206,33 @@ async function startAsLeader(options, election) {
  * Start as a follower.
  * Registers forwarding sinks with the LogManager, starts session heartbeat.
  */
-async function startAsFollower(options, election) {
+async function startAsFollower(options, election, consolePort = DEFAULT_CONSOLE_PORT) {
     const leaderUrl = `http://127.0.0.1:${election.leaderInfo.port}`;
-    // Register a forwarding log sink
-    const forwardingSink = new LeaderForwardingLogSink(leaderUrl, options.sessionId);
+    // Read the console auth token (#1780) written by the leader. May be null
+    // if the file doesn't exist yet — the sinks handle that gracefully and
+    // simply omit the Bearer header, which is fine when auth is not enforced.
+    const { getPrimaryTokenFromFile } = await import('./consoleToken.js');
+    const authToken = await getPrimaryTokenFromFile(env.DOLLHOUSE_CONSOLE_TOKEN_FILE);
+    if (authToken) {
+        logger.debug('[UnifiedConsole] Follower loaded console auth token');
+    }
+    else {
+        logger.debug('[UnifiedConsole] No console auth token file found; follower will POST without Bearer header');
+    }
+    // Per-instance promotion manager — tracks its own attempt counter so
+    // multiple followers don't interfere with each other's promotion budgets.
+    const promotionMgr = new PromotionManager(options, consolePort, startAsLeader, startAsFollower);
+    // Declare sessionHeartbeat before the sink so the closure can capture it.
+    // Both are initialized before the callback could possibly fire (needs 5+ failed flushes).
+    let sessionHeartbeat;
+    // Register a forwarding log sink with leader-death callback (#1850).
+    const forwardingSink = new LeaderForwardingLogSink(leaderUrl, options.sessionId, authToken, () => {
+        promotionMgr.promote(forwardingSink, sessionHeartbeat)
+            .catch(err => logger.error('[UnifiedConsole] Promotion crashed', { error: String(err) }));
+    });
     options.registerLogSink(forwardingSink);
     // Start session heartbeat to the leader
-    const sessionHeartbeat = new SessionHeartbeat(leaderUrl, options.sessionId, process.pid);
+    sessionHeartbeat = new SessionHeartbeat(leaderUrl, options.sessionId, process.pid, authToken);
     await sessionHeartbeat.start();
     logger.info('[UnifiedConsole] Follower started', {
         sessionId: options.sessionId, pid: process.pid, role: 'follower',
@@ -125,4 +248,4 @@ async function startAsFollower(options, election) {
         },
     };
 }
-//# 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  type ElectionResult,\n} from './LeaderElection.js';\nimport { createIngestRoutes } from './IngestRoutes.js';\nimport {\n  LeaderForwardingLogSink,\n  SessionHeartbeat,\n} from './LeaderForwardingSink.js';\n\n/** Fixed port for the unified console leader */\nconst CONSOLE_PORT = 3939;\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}\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 * 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  let election = await electLeader(options.sessionId, CONSOLE_PORT);\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, CONSOLE_PORT);\n    }\n  }\n\n  if (election.role === 'leader') {\n    return startAsLeader(options, election);\n  } else {\n    return startAsFollower(options, election);\n  }\n}\n\n/**\n * Start as the console leader.\n * Binds port 3939, mounts all routes including ingestion, starts heartbeat.\n */\nasync function startAsLeader(\n  options: UnifiedConsoleOptions,\n  election: ElectionResult,\n): Promise<UnifiedConsoleResult> {\n  const { startWebServer } = await import('../server.js');\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  // Start the web server with ingest routes mounted before the SPA fallback\n  const webResult = await startWebServer({\n    portfolioDir: options.portfolioDir,\n    memorySink: options.memorySink,\n    metricsSink: options.metricsSink,\n    port: CONSOLE_PORT,\n    additionalRouters: [ingestResult.router],\n    ...(options.mcpAqlHandler ? { mcpAqlHandler: options.mcpAqlHandler } : {}),\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: CONSOLE_PORT, 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: CONSOLE_PORT,\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): Promise<UnifiedConsoleResult> {\n  const leaderUrl = `http://127.0.0.1:${election.leaderInfo.port}`;\n\n  // Register a forwarding log sink\n  const forwardingSink = new LeaderForwardingLogSink(leaderUrl, options.sessionId);\n  options.registerLogSink(forwardingSink);\n\n  // Start session heartbeat to the leader\n  const sessionHeartbeat = new SessionHeartbeat(leaderUrl, options.sessionId, process.pid);\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"]}
+//# 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"]}

package/dist/web/portDiscovery.d.ts

@@ -5,7 +5,8 @@
  * Claude Code windows, IDE instances, or agent sessions), each needs its
  * own web console port. This module handles:
  *
- * 1. Finding an available port starting from the default (3939)
+ * 1. Finding an available port starting from the configured default
+ *    (see `DOLLHOUSE_WEB_CONSOLE_PORT` in `src/config/env.ts`)
  * 2. Writing port discovery files so external tools know which port to use
  * 3. Cleaning up port files on process exit
  *
@@ -20,7 +21,7 @@
  * and a held server to prevent TOCTOU race conditions. The caller should
  * close the held server after binding their own Express app to the port.
  *
- * @param startPort - Port to try first (default: 3939)
+ * @param startPort - Port to try first (see `DOLLHOUSE_WEB_CONSOLE_PORT` for the default)
  * @param maxAttempts - Maximum ports to try (default: 10, configurable via DOLLHOUSE_MAX_PORT_ATTEMPTS)
  * @returns Object with port number and held server, or throws if all attempts fail
  */
@@ -51,7 +52,7 @@ export declare function registerPortCleanup(): void;
  * This is the recommended entry point for Container startup. Combines
  * port discovery, file writing, and cleanup registration in one call.
  *
- * @param defaultPort - Port to try first (default: 3939)
+ * @param defaultPort - Port to try first (see `DOLLHOUSE_WEB_CONSOLE_PORT` for the default)
  * @returns The port the server should bind to, or undefined if discovery failed
  */
 export declare function discoverAndBindPort(defaultPort?: number): Promise<number | undefined>;

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

@@ -1 +1 @@
-{"version":3,"file":"portDiscovery.d.ts","sourceRoot":"","sources":["../../src/web/portDiscovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAwCH;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,WAAW,GAAE,MAAqF,GACjG,OAAO,CAAC,MAAM,CAAC,CAuBjB;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CASjE;AAED;;GAEG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAIrD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAK1C;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CAAC,WAAW,GAAE,MAAa,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAYjG"}
+{"version":3,"file":"portDiscovery.d.ts","sourceRoot":"","sources":["../../src/web/portDiscovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAyCH;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,WAAW,GAAE,MAAqF,GACjG,OAAO,CAAC,MAAM,CAAC,CAuBjB;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CASjE;AAED;;GAEG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAIrD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAK1C;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,WAAW,GAAE,MAAuC,GACnD,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAY7B"}

package/dist/web/portDiscovery.js

@@ -5,7 +5,8 @@
  * Claude Code windows, IDE instances, or agent sessions), each needs its
  * own web console port. This module handles:
  *
- * 1. Finding an available port starting from the default (3939)
+ * 1. Finding an available port starting from the configured default
+ *    (see `DOLLHOUSE_WEB_CONSOLE_PORT` in `src/config/env.ts`)
  * 2. Writing port discovery files so external tools know which port to use
  * 3. Cleaning up port files on process exit
  *
@@ -17,6 +18,7 @@ import { createServer } from 'node:net';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { mkdir, writeFile, unlink } from 'node:fs/promises';
+import { env } from '../config/env.js';
 import { logger } from '../utils/logger.js';
 /** Default maximum port attempts before giving up */
 const DEFAULT_MAX_PORT_ATTEMPTS = 10;
@@ -54,7 +56,7 @@ function tryBindPort(port) {
  * and a held server to prevent TOCTOU race conditions. The caller should
  * close the held server after binding their own Express app to the port.
  *
- * @param startPort - Port to try first (default: 3939)
+ * @param startPort - Port to try first (see `DOLLHOUSE_WEB_CONSOLE_PORT` for the default)
  * @param maxAttempts - Maximum ports to try (default: 10, configurable via DOLLHOUSE_MAX_PORT_ATTEMPTS)
  * @returns Object with port number and held server, or throws if all attempts fail
  */
@@ -125,10 +127,10 @@ export function registerPortCleanup() {
  * This is the recommended entry point for Container startup. Combines
  * port discovery, file writing, and cleanup registration in one call.
  *
- * @param defaultPort - Port to try first (default: 3939)
+ * @param defaultPort - Port to try first (see `DOLLHOUSE_WEB_CONSOLE_PORT` for the default)
  * @returns The port the server should bind to, or undefined if discovery failed
  */
-export async function discoverAndBindPort(defaultPort = 3939) {
+export async function discoverAndBindPort(defaultPort = env.DOLLHOUSE_WEB_CONSOLE_PORT) {
     try {
         const port = await findAvailablePort(defaultPort);
         await writePortFile(port);
@@ -140,4 +142,4 @@ export async function discoverAndBindPort(defaultPort = 3939) {
         return undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portDiscovery.js","sourceRoot":"","sources":["../../src/web/portDiscovery.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Dynamic port allocation and port file discovery for the web console.\n *\n * When multiple DollhouseMCP sessions run simultaneously (e.g., multiple\n * Claude Code windows, IDE instances, or agent sessions), each needs its\n * own web console port. This module handles:\n *\n * 1. Finding an available port starting from the default (3939)\n * 2. Writing port discovery files so external tools know which port to use\n * 3. Cleaning up port files on process exit\n *\n * Port files are written to ~/.dollhouse/run/:\n * - permission-server-{pid}.port — per-process file (cleaned on exit)\n * - permission-server.port — latest port (convenience for scripts)\n */\n\nimport { createServer, type Server } from 'node:net';\nimport { homedir } from 'node:os';\nimport { join } from 'node:path';\nimport { mkdir, writeFile, unlink } from 'node:fs/promises';\nimport { logger } from '../utils/logger.js';\n\n/** Default maximum port attempts before giving up */\nconst DEFAULT_MAX_PORT_ATTEMPTS = 10;\n\n/** Directory for runtime state files (port discovery, PID files) */\nconst RUN_DIR = join(homedir(), '.dollhouse', 'run');\n\n/** Track port file path for cleanup */\nlet portFilePath: string | null = null;\n\n/**\n * Attempt to bind to a single port. Returns the port if successful, null if in use.\n * Keeps the server listening to prevent TOCTOU race conditions — caller must\n * close the returned server after their own server binds.\n */\nfunction tryBindPort(port: number): Promise<{ port: number; server: Server } | null> {\n  return new Promise((resolve) => {\n    const server = createServer();\n    server.once('error', (err: NodeJS.ErrnoException) => {\n      if (err.code === 'EADDRINUSE') {\n        resolve(null);\n      } else {\n        resolve(null);\n        logger.debug(`[PortDiscovery] Unexpected error on port ${port}: ${err.code}`);\n      }\n    });\n    server.once('listening', () => {\n      resolve({ port, server });\n    });\n    server.listen(port, '127.0.0.1');\n  });\n}\n\n/**\n * Find an available port starting from the given port.\n *\n * Tries sequential ports, logging each attempt. Returns both the port number\n * and a held server to prevent TOCTOU race conditions. The caller should\n * close the held server after binding their own Express app to the port.\n *\n * @param startPort - Port to try first (default: 3939)\n * @param maxAttempts - Maximum ports to try (default: 10, configurable via DOLLHOUSE_MAX_PORT_ATTEMPTS)\n * @returns Object with port number and held server, or throws if all attempts fail\n */\nexport async function findAvailablePort(\n  startPort: number,\n  maxAttempts: number = Number(process.env.DOLLHOUSE_MAX_PORT_ATTEMPTS) || DEFAULT_MAX_PORT_ATTEMPTS,\n): Promise<number> {\n  for (let attempt = 0; attempt < maxAttempts; attempt++) {\n    const port = startPort + attempt;\n    logger.debug(`[PortDiscovery] Trying port ${port} (attempt ${attempt + 1}/${maxAttempts})`);\n\n    const result = await tryBindPort(port);\n    if (result) {\n      // Close the probe server — there's a brief TOCTOU window here between\n      // closing and the caller binding, but it's negligible on localhost.\n      // A future improvement could return the server for the caller to adopt.\n      result.server.close();\n      if (attempt > 0) {\n        logger.info(`[PortDiscovery] Port ${startPort} in use, using ${port} (after ${attempt} skip${attempt > 1 ? 's' : ''})`);\n      }\n      return port;\n    }\n    logger.debug(`[PortDiscovery] Port ${port} in use, trying next`);\n  }\n\n  throw new Error(\n    `No available port found in range ${startPort}-${startPort + maxAttempts - 1} ` +\n    `after ${maxAttempts} attempts. Set DOLLHOUSE_MAX_PORT_ATTEMPTS to increase the range.`\n  );\n}\n\n/**\n * Write the active server port to a discoverable file.\n *\n * Creates two files:\n * - PID-keyed file for per-process cleanup\n * - Latest file for convenience (scripts can read this without knowing the PID)\n *\n * @param port - The port the web server is listening on\n * @returns Path to the PID-keyed port file\n */\nexport async function writePortFile(port: number): Promise<string> {\n  await mkdir(RUN_DIR, { recursive: true });\n  const pidFile = join(RUN_DIR, `permission-server-${process.pid}.port`);\n  const latestFile = join(RUN_DIR, 'permission-server.port');\n  await writeFile(pidFile, String(port), 'utf-8');\n  await writeFile(latestFile, String(port), 'utf-8');\n  portFilePath = pidFile;\n  logger.debug(`[PortDiscovery] Port file written: ${pidFile}`);\n  return pidFile;\n}\n\n/**\n * Clean up port file on shutdown.\n */\nexport async function cleanupPortFile(): Promise<void> {\n  if (portFilePath) {\n    try { await unlink(portFilePath); } catch { /* already gone */ }\n  }\n}\n\n/**\n * Register process exit handlers to clean up port files.\n * Should be called once after the web server successfully starts.\n */\nexport function registerPortCleanup(): void {\n  const exitCleanup = () => { cleanupPortFile().catch(() => {}); };\n  process.once('exit', exitCleanup);\n  process.once('SIGTERM', exitCleanup);\n  process.once('SIGINT', exitCleanup);\n}\n\n/**\n * Discover an available port, write discovery files, and register cleanup.\n *\n * This is the recommended entry point for Container startup. Combines\n * port discovery, file writing, and cleanup registration in one call.\n *\n * @param defaultPort - Port to try first (default: 3939)\n * @returns The port the server should bind to, or undefined if discovery failed\n */\nexport async function discoverAndBindPort(defaultPort: number = 3939): Promise<number | undefined> {\n  try {\n    const port = await findAvailablePort(defaultPort);\n\n    await writePortFile(port);\n    registerPortCleanup();\n\n    return port;\n  } catch (err) {\n    logger.warn('[PortDiscovery] Port discovery failed:', err);\n    return undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portDiscovery.js","sourceRoot":"","sources":["../../src/web/portDiscovery.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Dynamic port allocation and port file discovery for the web console.\n *\n * When multiple DollhouseMCP sessions run simultaneously (e.g., multiple\n * Claude Code windows, IDE instances, or agent sessions), each needs its\n * own web console port. This module handles:\n *\n * 1. Finding an available port starting from the configured default\n *    (see `DOLLHOUSE_WEB_CONSOLE_PORT` in `src/config/env.ts`)\n * 2. Writing port discovery files so external tools know which port to use\n * 3. Cleaning up port files on process exit\n *\n * Port files are written to ~/.dollhouse/run/:\n * - permission-server-{pid}.port — per-process file (cleaned on exit)\n * - permission-server.port — latest port (convenience for scripts)\n */\n\nimport { createServer, type Server } from 'node:net';\nimport { homedir } from 'node:os';\nimport { join } from 'node:path';\nimport { mkdir, writeFile, unlink } from 'node:fs/promises';\nimport { env } from '../config/env.js';\nimport { logger } from '../utils/logger.js';\n\n/** Default maximum port attempts before giving up */\nconst DEFAULT_MAX_PORT_ATTEMPTS = 10;\n\n/** Directory for runtime state files (port discovery, PID files) */\nconst RUN_DIR = join(homedir(), '.dollhouse', 'run');\n\n/** Track port file path for cleanup */\nlet portFilePath: string | null = null;\n\n/**\n * Attempt to bind to a single port. Returns the port if successful, null if in use.\n * Keeps the server listening to prevent TOCTOU race conditions — caller must\n * close the returned server after their own server binds.\n */\nfunction tryBindPort(port: number): Promise<{ port: number; server: Server } | null> {\n  return new Promise((resolve) => {\n    const server = createServer();\n    server.once('error', (err: NodeJS.ErrnoException) => {\n      if (err.code === 'EADDRINUSE') {\n        resolve(null);\n      } else {\n        resolve(null);\n        logger.debug(`[PortDiscovery] Unexpected error on port ${port}: ${err.code}`);\n      }\n    });\n    server.once('listening', () => {\n      resolve({ port, server });\n    });\n    server.listen(port, '127.0.0.1');\n  });\n}\n\n/**\n * Find an available port starting from the given port.\n *\n * Tries sequential ports, logging each attempt. Returns both the port number\n * and a held server to prevent TOCTOU race conditions. The caller should\n * close the held server after binding their own Express app to the port.\n *\n * @param startPort - Port to try first (see `DOLLHOUSE_WEB_CONSOLE_PORT` for the default)\n * @param maxAttempts - Maximum ports to try (default: 10, configurable via DOLLHOUSE_MAX_PORT_ATTEMPTS)\n * @returns Object with port number and held server, or throws if all attempts fail\n */\nexport async function findAvailablePort(\n  startPort: number,\n  maxAttempts: number = Number(process.env.DOLLHOUSE_MAX_PORT_ATTEMPTS) || DEFAULT_MAX_PORT_ATTEMPTS,\n): Promise<number> {\n  for (let attempt = 0; attempt < maxAttempts; attempt++) {\n    const port = startPort + attempt;\n    logger.debug(`[PortDiscovery] Trying port ${port} (attempt ${attempt + 1}/${maxAttempts})`);\n\n    const result = await tryBindPort(port);\n    if (result) {\n      // Close the probe server — there's a brief TOCTOU window here between\n      // closing and the caller binding, but it's negligible on localhost.\n      // A future improvement could return the server for the caller to adopt.\n      result.server.close();\n      if (attempt > 0) {\n        logger.info(`[PortDiscovery] Port ${startPort} in use, using ${port} (after ${attempt} skip${attempt > 1 ? 's' : ''})`);\n      }\n      return port;\n    }\n    logger.debug(`[PortDiscovery] Port ${port} in use, trying next`);\n  }\n\n  throw new Error(\n    `No available port found in range ${startPort}-${startPort + maxAttempts - 1} ` +\n    `after ${maxAttempts} attempts. Set DOLLHOUSE_MAX_PORT_ATTEMPTS to increase the range.`\n  );\n}\n\n/**\n * Write the active server port to a discoverable file.\n *\n * Creates two files:\n * - PID-keyed file for per-process cleanup\n * - Latest file for convenience (scripts can read this without knowing the PID)\n *\n * @param port - The port the web server is listening on\n * @returns Path to the PID-keyed port file\n */\nexport async function writePortFile(port: number): Promise<string> {\n  await mkdir(RUN_DIR, { recursive: true });\n  const pidFile = join(RUN_DIR, `permission-server-${process.pid}.port`);\n  const latestFile = join(RUN_DIR, 'permission-server.port');\n  await writeFile(pidFile, String(port), 'utf-8');\n  await writeFile(latestFile, String(port), 'utf-8');\n  portFilePath = pidFile;\n  logger.debug(`[PortDiscovery] Port file written: ${pidFile}`);\n  return pidFile;\n}\n\n/**\n * Clean up port file on shutdown.\n */\nexport async function cleanupPortFile(): Promise<void> {\n  if (portFilePath) {\n    try { await unlink(portFilePath); } catch { /* already gone */ }\n  }\n}\n\n/**\n * Register process exit handlers to clean up port files.\n * Should be called once after the web server successfully starts.\n */\nexport function registerPortCleanup(): void {\n  const exitCleanup = () => { cleanupPortFile().catch(() => {}); };\n  process.once('exit', exitCleanup);\n  process.once('SIGTERM', exitCleanup);\n  process.once('SIGINT', exitCleanup);\n}\n\n/**\n * Discover an available port, write discovery files, and register cleanup.\n *\n * This is the recommended entry point for Container startup. Combines\n * port discovery, file writing, and cleanup registration in one call.\n *\n * @param defaultPort - Port to try first (see `DOLLHOUSE_WEB_CONSOLE_PORT` for the default)\n * @returns The port the server should bind to, or undefined if discovery failed\n */\nexport async function discoverAndBindPort(\n  defaultPort: number = env.DOLLHOUSE_WEB_CONSOLE_PORT,\n): Promise<number | undefined> {\n  try {\n    const port = await findAvailablePort(defaultPort);\n\n    await writePortFile(port);\n    registerPortCleanup();\n\n    return port;\n  } catch (err) {\n    logger.warn('[PortDiscovery] Port discovery failed:', err);\n    return undefined;\n  }\n}\n"]}

package/dist/web/public/app.js

@@ -96,7 +96,7 @@ function safeParseYaml(content) {
       showGridMessage('loading', 'Loading portfolio…');
 
       // Load portfolio from local API
-      const portfolioRes = await fetch('/api/elements');
+      const portfolioRes = await DollhouseAuth.apiFetch('/api/elements');
       if (!portfolioRes.ok) throw new Error(`HTTP ${portfolioRes.status} fetching portfolio`);
       const portfolioData = await portfolioRes.json();
 
@@ -116,7 +116,7 @@ function safeParseYaml(content) {
       applyFilters();
 
       // Load community collection (non-blocking — portfolio shows immediately)
-      fetch('/api/collection')
+      DollhouseAuth.apiFetch('/api/collection')
         .then(r => r.ok ? r.json() : Promise.reject('not available'))
         .then(mergeCollectionData)
         .catch(() => { /* collection not available — portfolio-only mode */ });
@@ -537,7 +537,7 @@ function safeParseYaml(content) {
       if (el._content) {
         content = el._content;
       } else if (el._local) {
-        const res = await fetch(`/api/elements/${el.path}`);
+        const res = await DollhouseAuth.apiFetch(`/api/elements/${el.path}`);
         if (!res.ok) throw new Error(`HTTP ${res.status}`);
         content = await res.text();
       } else {
@@ -630,7 +630,7 @@ function safeParseYaml(content) {
     btn.textContent = '⏳ Installing…';
     btn.disabled = true;
     try {
-      const res = await fetch('/api/install', {
+      const res = await DollhouseAuth.apiFetch('/api/install', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ path: element.path, name: element.name, type: element.type }),
@@ -726,13 +726,13 @@ function safeParseYaml(content) {
       if (element._content) {
         content = element._content;
       } else if (element._local) {
-        const res = await fetch(`/api/elements/${element.path}`);
+        const res = await DollhouseAuth.apiFetch(`/api/elements/${element.path}`);
         if (!res.ok) throw new Error(`HTTP ${res.status}`);
         const data = await res.json();
         structured = data;
         content = data.raw;
       } else {
-        const res = await fetch(`/api/collection/content/${element.path}`);
+        const res = await DollhouseAuth.apiFetch(`/api/collection/content/${element.path}`);
         if (!res.ok) throw new Error(`HTTP ${res.status}`);
         const data = await res.json();
         structured = data;
@@ -1931,7 +1931,7 @@ function safeParseYaml(content) {
 
     // ── Tab switching ─────────────────────────────────────────────────────────
     const consoleTabs = document.getElementById('console-tabs');
-    const tabInits = { logs: false, metrics: false, permissions: false };
+    const tabInits = { logs: false, metrics: false, permissions: false, security: false };
 
     const TAB_KEY = 'dollhousemcp-active-tab';
     const SETUP_SEEN_KEY = 'dollhousemcp-setup-seen';
@@ -2069,6 +2069,7 @@ function safeParseYaml(content) {
       const savedTab = localStorage.getItem(TAB_KEY);
       if (savedTab) {
         switchToTab(savedTab);
+        lazyInitTab(savedTab, tabInits);
       } else if (!localStorage.getItem(SETUP_SEEN_KEY)) {
         localStorage.setItem(SETUP_SEEN_KEY, '1');
         switchToTab('setup');
@@ -2094,20 +2095,36 @@ function safeParseYaml(content) {
 
     function lazyInitTab(tab, tabInits, params) {
       const dc = globalThis.DollhouseConsole;
-      if (tab === 'logs' && dc?.logs) {
-        if (!tabInits.logs) { tabInits.logs = true; dc.logs.init(params); }
-        else if (dc.logs.refresh) { dc.logs.refresh(); }
-      }
-      if (tab === 'metrics' && dc?.metrics) {
-        if (!tabInits.metrics) { tabInits.metrics = true; dc.metrics.init(params); }
-        else if (dc.metrics.refresh) { dc.metrics.refresh(); }
-      }
-      if (tab === 'permissions' && dc?.permissions) {
-        if (!tabInits.permissions) { tabInits.permissions = true; dc.permissions.init(params); }
-        else if (dc.permissions.refresh) { dc.permissions.refresh(); }
+      const module = dc?.[tab];
+      if (!module) return;
+      if (!tabInits[tab]) {
+        tabInits[tab] = true;
+        module.init(params);
+      } else if (module.refresh) {
+        module.refresh();
       }
     }
 
+    // 401 recovery (#1792): when the cached token becomes stale (rotation,
+    // restart, file deletion), consoleAuth.js fires this event. Show a
+    // persistent, idempotent reload banner so the user knows why the UI
+    // stopped updating.
+    globalThis.addEventListener('dollhouse:session-expired', function () {
+      if (document.getElementById('session-expired-toast')) return;
+      const toast = document.createElement('div');
+      toast.id = 'session-expired-toast';
+      toast.setAttribute('role', 'alert');
+      toast.style.cssText = 'position:fixed;bottom:24px;left:50%;transform:translateX(-50%);'
+        + 'background:#b91c1c;color:#fff;padding:12px 24px;border-radius:8px;'
+        + 'font-size:14px;z-index:99999;display:flex;align-items:center;gap:12px;'
+        + 'box-shadow:0 4px 12px rgba(0,0,0,0.3);';
+      toast.innerHTML = 'Console session token changed\u2009\u2014\u2009'
+        + '<button style="background:#fff;color:#b91c1c;border:none;padding:6px 16px;'
+        + 'border-radius:4px;cursor:pointer;font-weight:600;font-size:14px"'
+        + ' onclick="location.reload()">Reload</button>';
+      document.body.appendChild(toast);
+    });
+
     init();
   });