@dollhousemcp/mcp-server 2.0.19 → 2.0.20

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [2.0.20] - 2026-04-16
+
+Point release for console leader bind authority and follower registration recovery.
+
 ## [2.0.19] - 2026-04-16
 
 Point release for deadlock relief recovery and version-aware web console leadership.

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.19";
-export declare const BUILD_TIMESTAMP = "2026-04-16T13:32:30.783Z";
+export declare const PACKAGE_VERSION = "2.0.20";
+export declare const BUILD_TIMESTAMP = "2026-04-16T14:53:41.093Z";
 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.19';
-export const BUILD_TIMESTAMP = '2026-04-16T13:32:30.783Z';
+export const PACKAGE_VERSION = '2.0.20';
+export const BUILD_TIMESTAMP = '2026-04-16T14:53:41.093Z';
 export const BUILD_TYPE = 'npm';
 export const PACKAGE_NAME = '@dollhousemcp/mcp-server';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nZW5lcmF0ZWQvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsUUFBUSxDQUFDO0FBQ3hDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRywwQkFBMEIsQ0FBQztBQUMxRCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQWtCLEtBQUssQ0FBQztBQUMvQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF1dG8tZ2VuZXJhdGVkIGZpbGUgLSBETyBOT1QgRURJVFxuICogR2VuZXJhdGVkIGF0IGJ1aWxkIHRpbWUgYnkgc2NyaXB0cy9nZW5lcmF0ZS12ZXJzaW9uLmpzXG4gKi9cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9ICcyLjAuMTknO1xuZXhwb3J0IGNvbnN0IEJVSUxEX1RJTUVTVEFNUCA9ICcyMDI2LTA0LTE2VDEzOjMyOjMwLjc4M1onO1xuZXhwb3J0IGNvbnN0IEJVSUxEX1RZUEU6ICducG0nIHwgJ2dpdCcgPSAnbnBtJztcbmV4cG9ydCBjb25zdCBQQUNLQUdFX05BTUUgPSAnQGRvbGxob3VzZW1jcC9tY3Atc2VydmVyJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nZW5lcmF0ZWQvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsUUFBUSxDQUFDO0FBQ3hDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRywwQkFBMEIsQ0FBQztBQUMxRCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQWtCLEtBQUssQ0FBQztBQUMvQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF1dG8tZ2VuZXJhdGVkIGZpbGUgLSBETyBOT1QgRURJVFxuICogR2VuZXJhdGVkIGF0IGJ1aWxkIHRpbWUgYnkgc2NyaXB0cy9nZW5lcmF0ZS12ZXJzaW9uLmpzXG4gKi9cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9ICcyLjAuMjAnO1xuZXhwb3J0IGNvbnN0IEJVSUxEX1RJTUVTVEFNUCA9ICcyMDI2LTA0LTE2VDE0OjUzOjQxLjA5M1onO1xuZXhwb3J0IGNvbnN0IEJVSUxEX1RZUEU6ICducG0nIHwgJ2dpdCcgPSAnbnBtJztcbmV4cG9ydCBjb25zdCBQQUNLQUdFX05BTUUgPSAnQGRvbGxob3VzZW1jcC9tY3Atc2VydmVyJztcbiJdfQ==

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

@@ -8,6 +8,16 @@
  * Extracted to a standalone module so it can be tested without importing
  * the full Express server and its dependency chain.
  */
+export interface KillStaleProcessOutcome {
+    killed: boolean;
+    reason: 'inspect_failed' | 'different_user' | 'not_dollhouse_process' | 'active_host_parent' | 'terminated' | 'already_dead' | 'still_alive' | 'signal_failed';
+    pid: number;
+    parentPid?: number;
+    command?: string;
+    parentCommand?: string;
+    detail?: string;
+}
+export declare function isRecognizedMcpHostParent(command: string): boolean;
 /**
  * Find the PID of the process listening on a given port.
  * Uses lsof on macOS/Linux. Returns null if not found or on error.
@@ -26,6 +36,7 @@ export declare function findPidOnPort(port: number): Promise<number | null>;
  * before escalating to SIGKILL. Total worst case: ~4s.
  */
 export declare function killStaleProcess(pid: number, port: number): Promise<boolean>;
+export declare function killStaleProcessDetailed(pid: number, port: number): Promise<KillStaleProcessOutcome>;
 /**
  * Detect and recover from a stale process squatting on the port.
  * Compares the port holder's PID against the leader lock file to determine

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

@@ -1 +1 @@
-{"version":3,"file":"StaleProcessRecovery.d.ts","sourceRoot":"","sources":["../../../src/web/console/StaleProcessRecovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AA6BH;;;;;;;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,CAwDlF;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CA6BrE"}
+{"version":3,"file":"StaleProcessRecovery.d.ts","sourceRoot":"","sources":["../../../src/web/console/StaleProcessRecovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AA8DH,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EACF,gBAAgB,GAChB,gBAAgB,GAChB,uBAAuB,GACvB,oBAAoB,GACpB,YAAY,GACZ,cAAc,GACd,aAAa,GACb,eAAe,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGlE;AA8LD;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAyBxE;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGlF;AAED,wBAAsB,wBAAwB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAyB1G;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAoCrE"}

package/dist/web/console/StaleProcessRecovery.js

@@ -8,6 +8,7 @@
  * Extracted to a standalone module so it can be tested without importing
  * the full Express server and its dependency chain.
  */
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
 // 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.
 /** Timeout for lsof/fuser/ps system calls (ms) */
@@ -20,6 +21,12 @@ const KILL_POLL_COUNT = 10;
 const SIGKILL_WAIT_MS = 500;
 /** Wait between lock file reads for TOCTOU mitigation (ms) */
 const LOCK_RECHECK_DELAY_MS = 500;
+/** Number of lock-file checks before deciding the port holder is not a fresh leader. */
+const LOCK_RECHECK_ATTEMPTS = 2;
+/** PID used by the OS init/launchd process; direct children are effectively orphaned. */
+const ROOT_PARENT_PID = 1;
+/** Number of `ps` columns requested by inspectProcess: user, pid, ppid, command. */
+const PROCESS_INSPECTION_FIELD_COUNT = 4;
 let _logger = null;
 async function getLogger() {
     if (!_logger) {
@@ -31,10 +38,190 @@ async function getLogger() {
     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; },
+    warn: async (...args) => {
+        const l = await getLogger();
+        if (l)
+            l.warn(args[0], args[1]);
+        else
+            console.error('[WARN]', ...args);
+    },
+    info: async (...args) => {
+        const l = await getLogger();
+        if (l)
+            l.info(args[0], args[1]);
+        else
+            console.error('[INFO]', ...args);
+    },
+    debug: async (...args) => {
+        const l = await getLogger();
+        if (l)
+            l.debug(args[0], args[1]);
+    },
 };
+const MCP_HOST_PARENT_PATTERNS = [
+    /Claude\.app\/Contents\/Helpers\/disclaimer/i,
+    /Codex\.app\/Contents\/Resources\/codex app-server/i,
+    /Cursor\.app\//i,
+    /Windsurf\.app\//i,
+];
+export function isRecognizedMcpHostParent(command) {
+    const normalizedCommand = UnicodeValidator.normalize(command).normalizedContent;
+    return MCP_HOST_PARENT_PATTERNS.some((pattern) => pattern.test(normalizedCommand));
+}
+function isDollhouseProcessCommand(cmdLine) {
+    const normalizedCommand = UnicodeValidator.normalize(cmdLine).normalizedContent;
+    const isDollhouseBin = /(?:^|\/)dollhousemcp(?:\s|$)/.test(normalizedCommand) ||
+        normalizedCommand.includes('.bin/dollhousemcp');
+    const isMcpServerBin = normalizedCommand.includes('.bin/mcp-server') ||
+        /(?:dollhousemcp|mcp-server)[/\\]dist[/\\]index\.js/.test(normalizedCommand);
+    return isDollhouseBin || isMcpServerBin;
+}
+function parsePidToken(value) {
+    if (!value)
+        return null;
+    for (let i = 0; i < value.length; i++) {
+        const codePoint = value.codePointAt(i);
+        if (codePoint === undefined || codePoint < 48 || codePoint > 57) {
+            return null;
+        }
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isSafeInteger(parsed) || parsed < ROOT_PARENT_PID) {
+        return null;
+    }
+    return parsed;
+}
+function isWhitespaceChar(value) {
+    return value === ' ' || value === '\t' || value === '\n' || value === '\r' || value === '\f' || value === '\v';
+}
+function buildKillOutcome(killed, reason, processInfo, parentCommand, detail) {
+    return {
+        killed,
+        reason,
+        pid: processInfo.pid,
+        parentPid: processInfo.parentPid,
+        command: processInfo.command,
+        parentCommand,
+        ...(detail ? { detail } : {}),
+    };
+}
+async function getKillGuardFailure(processInfo, port) {
+    const currentUser = (await import('node:os')).userInfo().username;
+    if (processInfo.user !== currentUser) {
+        await logger.warn(`[WebUI] Port ${port} held by different user (pid ${processInfo.pid}) — not killing`);
+        return buildKillOutcome(false, 'different_user', processInfo);
+    }
+    if (!isDollhouseProcessCommand(processInfo.command)) {
+        await logger.warn(`[WebUI] Port ${port} held by non-DollhouseMCP process (pid ${processInfo.pid}) — not killing`, {
+            cmdLine: processInfo.command,
+        });
+        return buildKillOutcome(false, 'not_dollhouse_process', processInfo);
+    }
+    if (processInfo.parentPid <= ROOT_PARENT_PID || !isPidAlive(processInfo.parentPid)) {
+        return null;
+    }
+    const parentCommand = (await getProcessCommand(processInfo.parentPid)) ?? undefined;
+    if (parentCommand && isRecognizedMcpHostParent(parentCommand)) {
+        await logger.warn(`[WebUI] Port ${port} held by active client-backed DollhouseMCP process (pid ${processInfo.pid}) — not killing`, {
+            cmdLine: processInfo.command,
+            parentPid: processInfo.parentPid,
+            parentCommand,
+        });
+        return buildKillOutcome(false, 'active_host_parent', processInfo, parentCommand);
+    }
+    return null;
+}
+async function terminateProcess(processInfo, port, parentCommand) {
+    process.kill(processInfo.pid, 'SIGTERM');
+    logger.warn(`[WebUI] Sent SIGTERM to stale process ${processInfo.pid} on port ${port}`, {
+        cmdLine: processInfo.command,
+        parentPid: processInfo.parentPid,
+        parentCommand,
+    });
+    for (let i = 0; i < KILL_POLL_COUNT; i++) {
+        await new Promise(r => setTimeout(r, SIGTERM_POLL_MS));
+        if (!isPidAlive(processInfo.pid)) {
+            return buildKillOutcome(true, 'terminated', processInfo, parentCommand);
+        }
+    }
+    process.kill(processInfo.pid, 'SIGKILL');
+    logger.warn(`[WebUI] Sent SIGKILL to stale process ${processInfo.pid} on port ${port}`);
+    await new Promise(r => setTimeout(r, SIGKILL_WAIT_MS));
+    return isPidAlive(processInfo.pid)
+        ? buildKillOutcome(false, 'still_alive', processInfo, parentCommand)
+        : buildKillOutcome(true, 'terminated', processInfo, parentCommand);
+}
+function splitProcessInspectionFields(line) {
+    const fields = [];
+    let index = 0;
+    const normalizedLine = UnicodeValidator.normalize(line).normalizedContent.trim();
+    while (index < normalizedLine.length && fields.length < PROCESS_INSPECTION_FIELD_COUNT - 1) {
+        while (index < normalizedLine.length && isWhitespaceChar(normalizedLine[index])) {
+            index++;
+        }
+        if (index >= normalizedLine.length)
+            break;
+        const fieldStart = index;
+        while (index < normalizedLine.length && !isWhitespaceChar(normalizedLine[index])) {
+            index++;
+        }
+        fields.push(normalizedLine.slice(fieldStart, index));
+    }
+    while (index < normalizedLine.length && isWhitespaceChar(normalizedLine[index])) {
+        index++;
+    }
+    if (index < normalizedLine.length) {
+        fields.push(normalizedLine.slice(index));
+    }
+    return fields.length === PROCESS_INSPECTION_FIELD_COUNT ? fields : null;
+}
+async function inspectProcess(pid) {
+    const { execFile: execFileCb } = await import('node:child_process');
+    const { promisify } = await import('node:util');
+    const execFileAsync = promisify(execFileCb);
+    try {
+        const { stdout } = await execFileAsync('ps', ['-p', String(pid), '-o', 'user=,pid=,ppid=,command='], { timeout: COMMAND_TIMEOUT_MS });
+        const fields = splitProcessInspectionFields(stdout);
+        if (!fields)
+            return null;
+        const [user, pidToken, parentPidToken, command] = fields;
+        const parsedPid = parsePidToken(pidToken);
+        const parsedParentPid = parsePidToken(parentPidToken);
+        if (parsedPid === null || parsedParentPid === null)
+            return null;
+        return {
+            user: UnicodeValidator.normalize(user).normalizedContent,
+            pid: parsedPid,
+            parentPid: parsedParentPid,
+            command: UnicodeValidator.normalize(command).normalizedContent,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function getProcessCommand(pid) {
+    const { execFile: execFileCb } = await import('node:child_process');
+    const { promisify } = await import('node:util');
+    const execFileAsync = promisify(execFileCb);
+    try {
+        const { stdout } = await execFileAsync('ps', ['-p', String(pid), '-o', 'command='], { timeout: COMMAND_TIMEOUT_MS });
+        const normalized = UnicodeValidator.normalize(stdout).normalizedContent.trim();
+        return normalized || null;
+    }
+    catch {
+        return null;
+    }
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Find the PID of the process listening on a given port.
  * Uses lsof on macOS/Linux. Returns null if not found or on error.
@@ -56,7 +243,10 @@ export async function findPidOnPort(port) {
             const { stdout, stderr } = await execFileAsync(cmd.bin, cmd.args, { timeout: COMMAND_TIMEOUT_MS });
             // 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 pids = output
+                .split(/\s+/)
+                .map((token) => parsePidToken(token))
+                .filter((pid) => pid !== null);
             const otherPid = pids.find(p => p !== process.pid);
             if (otherPid)
                 return otherPid;
@@ -76,63 +266,31 @@ export async function findPidOnPort(port) {
  * 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
-    let cmdLine = '';
-    try {
-        const { stdout } = await execFileAsync('ps', ['-p', String(pid), '-o', 'user=,command='], { timeout: COMMAND_TIMEOUT_MS });
-        // 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.
-        cmdLine = stdout.trim();
-        const isDollhouseBin = /(?:^|\/)dollhousemcp(?:\s|$)/.test(cmdLine) ||
-            cmdLine.includes('.bin/dollhousemcp');
-        const isMcpServerBin = cmdLine.includes('.bin/mcp-server') ||
-            /(?:dollhousemcp|mcp-server)[/\\]dist[/\\]index\.js/.test(cmdLine);
-        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 });
+    const outcome = await killStaleProcessDetailed(pid, port);
+    return outcome.killed;
+}
+export async function killStaleProcessDetailed(pid, port) {
+    const processInfo = await inspectProcess(pid);
+    if (!processInfo) {
+        await logger.debug(`[WebUI] Cannot verify process ${pid} — skipping kill`);
+        return { killed: false, reason: 'inspect_failed', pid };
     }
-    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;
+    const guardFailure = await getKillGuardFailure(processInfo, port);
+    if (guardFailure) {
+        return guardFailure;
     }
+    const parentCommand = processInfo.parentPid > ROOT_PARENT_PID
+        ? (await getProcessCommand(processInfo.parentPid)) ?? undefined
+        : undefined;
+    await logger.debug(`[WebUI] Verified stale process ${pid} is DollhouseMCP`, { cmdLine: processInfo.command, parentPid: processInfo.parentPid, parentCommand });
     try {
-        process.kill(pid, 'SIGTERM');
-        logger.warn(`[WebUI] Sent SIGTERM to stale process ${pid} on port ${port}`, { cmdLine });
-        for (let i = 0; i < KILL_POLL_COUNT; i++) {
-            await new Promise(r => setTimeout(r, SIGTERM_POLL_MS));
-            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, SIGKILL_WAIT_MS));
-        return true;
+        return await terminateProcess(processInfo, port, parentCommand);
     }
-    catch {
-        return true; // process already dead
+    catch (err) {
+        if (!isPidAlive(pid)) {
+            return buildKillOutcome(true, 'already_dead', processInfo, parentCommand);
+        }
+        return buildKillOutcome(false, 'signal_failed', processInfo, parentCommand, err instanceof Error ? err.message : String(err));
     }
 }
 /**
@@ -150,7 +308,7 @@ export async function recoverStalePort(port) {
     // written its lock file. Read the lock, pause, re-read. If the second read
     // now matches the port holder, it's a fresh leader — don't kill.
     const { readLeaderLock } = await import('./LeaderElection.js');
-    for (let check = 0; check < 2; check++) {
+    for (let check = 0; check < LOCK_RECHECK_ATTEMPTS; check++) {
         try {
             const lock = await readLeaderLock();
             if (lock?.pid === stalePid && lock?.port === port && lock.pid !== process.pid) {
@@ -161,15 +319,23 @@ export async function recoverStalePort(port) {
         catch {
             // Can't read lock file — continue to next check or kill
         }
-        if (check === 0) {
+        if (check < LOCK_RECHECK_ATTEMPTS - 1) {
             await new Promise(r => setTimeout(r, LOCK_RECHECK_DELAY_MS));
         }
     }
-    const killed = await killStaleProcess(stalePid, port);
-    if (killed) {
+    const outcome = await killStaleProcessDetailed(stalePid, port);
+    if (outcome.killed) {
         logger.info(`[WebUI] Stale process ${stalePid} removed from port ${port}`);
         await new Promise(r => setTimeout(r, SIGKILL_WAIT_MS)); // brief pause for port release
     }
-    return killed;
+    else {
+        await logger.debug(`[WebUI] Stale-port recovery skipped for pid ${stalePid}`, {
+            reason: outcome.reason,
+            parentPid: outcome.parentPid,
+            parentCommand: outcome.parentCommand,
+            detail: outcome.detail,
+        });
+    }
+    return outcome.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.\n/** Timeout for lsof/fuser/ps system calls (ms) */\nconst COMMAND_TIMEOUT_MS = 1000;\n/** Polling interval when waiting for SIGTERM to take effect (ms) */\nconst SIGTERM_POLL_MS = 300;\n/** Number of polls before escalating to SIGKILL */\nconst KILL_POLL_COUNT = 10;\n/** Wait after SIGKILL before returning (ms) */\nconst SIGKILL_WAIT_MS = 500;\n/** Wait between lock file reads for TOCTOU mitigation (ms) */\nconst LOCK_RECHECK_DELAY_MS = 500;\n\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: COMMAND_TIMEOUT_MS });\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  let cmdLine = '';\n  try {\n    const { stdout } = await execFileAsync('ps', ['-p', String(pid), '-o', 'user=,command='], { timeout: COMMAND_TIMEOUT_MS });\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    cmdLine = stdout.trim();\n    const isDollhouseBin = /(?:^|\\/)dollhousemcp(?:\\s|$)/.test(cmdLine) ||\n      cmdLine.includes('.bin/dollhousemcp');\n    const isMcpServerBin = cmdLine.includes('.bin/mcp-server') ||\n      /(?:dollhousemcp|mcp-server)[/\\\\]dist[/\\\\]index\\.js/.test(cmdLine);\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}`, { cmdLine });\n    for (let i = 0; i < KILL_POLL_COUNT; i++) {\n      await new Promise(r => setTimeout(r, SIGTERM_POLL_MS));\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, SIGKILL_WAIT_MS));\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  // TOCTOU mitigation: a new process may have just bound the port but not yet\n  // written its lock file. Read the lock, pause, re-read. If the second read\n  // now matches the port holder, it's a fresh leader — don't kill.\n  const { readLeaderLock } = await import('./LeaderElection.js');\n  for (let check = 0; check < 2; check++) {\n    try {\n      const lock = await readLeaderLock();\n      if (lock?.pid === stalePid && lock?.port === port && lock.pid !== process.pid) {\n        await 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 — continue to next check or kill\n    }\n    if (check === 0) {\n      await new Promise(r => setTimeout(r, LOCK_RECHECK_DELAY_MS));\n    }\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, SIGKILL_WAIT_MS)); // brief pause for port release\n  }\n  return killed;\n}\n"]}
+//# 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\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\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.\n/** Timeout for lsof/fuser/ps system calls (ms) */\nconst COMMAND_TIMEOUT_MS = 1000;\n/** Polling interval when waiting for SIGTERM to take effect (ms) */\nconst SIGTERM_POLL_MS = 300;\n/** Number of polls before escalating to SIGKILL */\nconst KILL_POLL_COUNT = 10;\n/** Wait after SIGKILL before returning (ms) */\nconst SIGKILL_WAIT_MS = 500;\n/** Wait between lock file reads for TOCTOU mitigation (ms) */\nconst LOCK_RECHECK_DELAY_MS = 500;\n/** Number of lock-file checks before deciding the port holder is not a fresh leader. */\nconst LOCK_RECHECK_ATTEMPTS = 2;\n/** PID used by the OS init/launchd process; direct children are effectively orphaned. */\nconst ROOT_PARENT_PID = 1;\n/** Number of `ps` columns requested by inspectProcess: user, pid, ppid, command. */\nconst PROCESS_INSPECTION_FIELD_COUNT = 4;\n\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[]) => {\n    const l = await getLogger();\n    if (l) l.warn(args[0] as string, args[1]);\n    else console.error('[WARN]', ...args);\n  },\n  info: async (...args: unknown[]) => {\n    const l = await getLogger();\n    if (l) l.info(args[0] as string, args[1]);\n    else console.error('[INFO]', ...args);\n  },\n  debug: async (...args: unknown[]) => {\n    const l = await getLogger();\n    if (l) l.debug(args[0] as string, args[1]);\n  },\n};\n\nconst MCP_HOST_PARENT_PATTERNS = [\n  /Claude\\.app\\/Contents\\/Helpers\\/disclaimer/i,\n  /Codex\\.app\\/Contents\\/Resources\\/codex app-server/i,\n  /Cursor\\.app\\//i,\n  /Windsurf\\.app\\//i,\n];\n\ninterface ProcessInspection {\n  user: string;\n  pid: number;\n  parentPid: number;\n  command: string;\n}\n\nexport interface KillStaleProcessOutcome {\n  killed: boolean;\n  reason:\n    | 'inspect_failed'\n    | 'different_user'\n    | 'not_dollhouse_process'\n    | 'active_host_parent'\n    | 'terminated'\n    | 'already_dead'\n    | 'still_alive'\n    | 'signal_failed';\n  pid: number;\n  parentPid?: number;\n  command?: string;\n  parentCommand?: string;\n  detail?: string;\n}\n\nexport function isRecognizedMcpHostParent(command: string): boolean {\n  const normalizedCommand = UnicodeValidator.normalize(command).normalizedContent;\n  return MCP_HOST_PARENT_PATTERNS.some((pattern) => pattern.test(normalizedCommand));\n}\n\nfunction isDollhouseProcessCommand(cmdLine: string): boolean {\n  const normalizedCommand = UnicodeValidator.normalize(cmdLine).normalizedContent;\n  const isDollhouseBin = /(?:^|\\/)dollhousemcp(?:\\s|$)/.test(normalizedCommand) ||\n    normalizedCommand.includes('.bin/dollhousemcp');\n  const isMcpServerBin = normalizedCommand.includes('.bin/mcp-server') ||\n    /(?:dollhousemcp|mcp-server)[/\\\\]dist[/\\\\]index\\.js/.test(normalizedCommand);\n  return isDollhouseBin || isMcpServerBin;\n}\n\nfunction parsePidToken(value: string): number | null {\n  if (!value) return null;\n  for (let i = 0; i < value.length; i++) {\n    const codePoint = value.codePointAt(i);\n    if (codePoint === undefined || codePoint < 48 || codePoint > 57) {\n      return null;\n    }\n  }\n\n  const parsed = Number.parseInt(value, 10);\n  if (!Number.isSafeInteger(parsed) || parsed < ROOT_PARENT_PID) {\n    return null;\n  }\n  return parsed;\n}\n\nfunction isWhitespaceChar(value: string): boolean {\n  return value === ' ' || value === '\\t' || value === '\\n' || value === '\\r' || value === '\\f' || value === '\\v';\n}\n\nfunction buildKillOutcome(\n  killed: boolean,\n  reason: KillStaleProcessOutcome['reason'],\n  processInfo: ProcessInspection,\n  parentCommand?: string,\n  detail?: string,\n): KillStaleProcessOutcome {\n  return {\n    killed,\n    reason,\n    pid: processInfo.pid,\n    parentPid: processInfo.parentPid,\n    command: processInfo.command,\n    parentCommand,\n    ...(detail ? { detail } : {}),\n  };\n}\n\nasync function getKillGuardFailure(\n  processInfo: ProcessInspection,\n  port: number,\n): Promise<KillStaleProcessOutcome | null> {\n  const currentUser = (await import('node:os')).userInfo().username;\n  if (processInfo.user !== currentUser) {\n    await logger.warn(`[WebUI] Port ${port} held by different user (pid ${processInfo.pid}) — not killing`);\n    return buildKillOutcome(false, 'different_user', processInfo);\n  }\n\n  if (!isDollhouseProcessCommand(processInfo.command)) {\n    await logger.warn(`[WebUI] Port ${port} held by non-DollhouseMCP process (pid ${processInfo.pid}) — not killing`, {\n      cmdLine: processInfo.command,\n    });\n    return buildKillOutcome(false, 'not_dollhouse_process', processInfo);\n  }\n\n  if (processInfo.parentPid <= ROOT_PARENT_PID || !isPidAlive(processInfo.parentPid)) {\n    return null;\n  }\n\n  const parentCommand = (await getProcessCommand(processInfo.parentPid)) ?? undefined;\n  if (parentCommand && isRecognizedMcpHostParent(parentCommand)) {\n    await logger.warn(`[WebUI] Port ${port} held by active client-backed DollhouseMCP process (pid ${processInfo.pid}) — not killing`, {\n      cmdLine: processInfo.command,\n      parentPid: processInfo.parentPid,\n      parentCommand,\n    });\n    return buildKillOutcome(false, 'active_host_parent', processInfo, parentCommand);\n  }\n\n  return null;\n}\n\nasync function terminateProcess(\n  processInfo: ProcessInspection,\n  port: number,\n  parentCommand?: string,\n): Promise<KillStaleProcessOutcome> {\n  process.kill(processInfo.pid, 'SIGTERM');\n  logger.warn(`[WebUI] Sent SIGTERM to stale process ${processInfo.pid} on port ${port}`, {\n    cmdLine: processInfo.command,\n    parentPid: processInfo.parentPid,\n    parentCommand,\n  });\n\n  for (let i = 0; i < KILL_POLL_COUNT; i++) {\n    await new Promise(r => setTimeout(r, SIGTERM_POLL_MS));\n    if (!isPidAlive(processInfo.pid)) {\n      return buildKillOutcome(true, 'terminated', processInfo, parentCommand);\n    }\n  }\n\n  process.kill(processInfo.pid, 'SIGKILL');\n  logger.warn(`[WebUI] Sent SIGKILL to stale process ${processInfo.pid} on port ${port}`);\n  await new Promise(r => setTimeout(r, SIGKILL_WAIT_MS));\n  return isPidAlive(processInfo.pid)\n    ? buildKillOutcome(false, 'still_alive', processInfo, parentCommand)\n    : buildKillOutcome(true, 'terminated', processInfo, parentCommand);\n}\n\nfunction splitProcessInspectionFields(line: string): string[] | null {\n  const fields: string[] = [];\n  let index = 0;\n  const normalizedLine = UnicodeValidator.normalize(line).normalizedContent.trim();\n\n  while (index < normalizedLine.length && fields.length < PROCESS_INSPECTION_FIELD_COUNT - 1) {\n    while (index < normalizedLine.length && isWhitespaceChar(normalizedLine[index])) {\n      index++;\n    }\n    if (index >= normalizedLine.length) break;\n\n    const fieldStart = index;\n    while (index < normalizedLine.length && !isWhitespaceChar(normalizedLine[index])) {\n      index++;\n    }\n    fields.push(normalizedLine.slice(fieldStart, index));\n  }\n\n  while (index < normalizedLine.length && isWhitespaceChar(normalizedLine[index])) {\n    index++;\n  }\n  if (index < normalizedLine.length) {\n    fields.push(normalizedLine.slice(index));\n  }\n\n  return fields.length === PROCESS_INSPECTION_FIELD_COUNT ? fields : null;\n}\n\nasync function inspectProcess(pid: number): Promise<ProcessInspection | 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 {\n    const { stdout } = await execFileAsync(\n      'ps',\n      ['-p', String(pid), '-o', 'user=,pid=,ppid=,command='],\n      { timeout: COMMAND_TIMEOUT_MS },\n    );\n    const fields = splitProcessInspectionFields(stdout);\n    if (!fields) return null;\n    const [user, pidToken, parentPidToken, command] = fields;\n    const parsedPid = parsePidToken(pidToken);\n    const parsedParentPid = parsePidToken(parentPidToken);\n    if (parsedPid === null || parsedParentPid === null) return null;\n\n    return {\n      user: UnicodeValidator.normalize(user).normalizedContent,\n      pid: parsedPid,\n      parentPid: parsedParentPid,\n      command: UnicodeValidator.normalize(command).normalizedContent,\n    };\n  } catch {\n    return null;\n  }\n}\n\nasync function getProcessCommand(pid: number): Promise<string | 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 {\n    const { stdout } = await execFileAsync('ps', ['-p', String(pid), '-o', 'command='], { timeout: COMMAND_TIMEOUT_MS });\n    const normalized = UnicodeValidator.normalize(stdout).normalizedContent.trim();\n    return normalized || null;\n  } catch {\n    return null;\n  }\n}\n\nfunction isPidAlive(pid: number): boolean {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch {\n    return false;\n  }\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: COMMAND_TIMEOUT_MS });\n      // fuser outputs to stderr on some systems\n      const output = (stdout || stderr || '').trim();\n      const pids = output\n        .split(/\\s+/)\n        .map((token) => parsePidToken(token))\n        .filter((pid): pid is number => pid !== null);\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 outcome = await killStaleProcessDetailed(pid, port);\n  return outcome.killed;\n}\n\nexport async function killStaleProcessDetailed(pid: number, port: number): Promise<KillStaleProcessOutcome> {\n  const processInfo = await inspectProcess(pid);\n  if (!processInfo) {\n    await logger.debug(`[WebUI] Cannot verify process ${pid} — skipping kill`);\n    return { killed: false, reason: 'inspect_failed', pid };\n  }\n\n  const guardFailure = await getKillGuardFailure(processInfo, port);\n  if (guardFailure) {\n    return guardFailure;\n  }\n  const parentCommand = processInfo.parentPid > ROOT_PARENT_PID\n    ? (await getProcessCommand(processInfo.parentPid)) ?? undefined\n    : undefined;\n\n  await logger.debug(`[WebUI] Verified stale process ${pid} is DollhouseMCP`, { cmdLine: processInfo.command, parentPid: processInfo.parentPid, parentCommand });\n\n  try {\n    return await terminateProcess(processInfo, port, parentCommand);\n  } catch (err) {\n    if (!isPidAlive(pid)) {\n      return buildKillOutcome(true, 'already_dead', processInfo, parentCommand);\n    }\n    return buildKillOutcome(false, 'signal_failed', processInfo, parentCommand, err instanceof Error ? err.message : String(err));\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  // TOCTOU mitigation: a new process may have just bound the port but not yet\n  // written its lock file. Read the lock, pause, re-read. If the second read\n  // now matches the port holder, it's a fresh leader — don't kill.\n  const { readLeaderLock } = await import('./LeaderElection.js');\n  for (let check = 0; check < LOCK_RECHECK_ATTEMPTS; check++) {\n    try {\n      const lock = await readLeaderLock();\n      if (lock?.pid === stalePid && lock?.port === port && lock.pid !== process.pid) {\n        await 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 — continue to next check or kill\n    }\n    if (check < LOCK_RECHECK_ATTEMPTS - 1) {\n      await new Promise(r => setTimeout(r, LOCK_RECHECK_DELAY_MS));\n    }\n  }\n\n  const outcome = await killStaleProcessDetailed(stalePid, port);\n  if (outcome.killed) {\n    logger.info(`[WebUI] Stale process ${stalePid} removed from port ${port}`);\n    await new Promise(r => setTimeout(r, SIGKILL_WAIT_MS)); // brief pause for port release\n  } else {\n    await logger.debug(`[WebUI] Stale-port recovery skipped for pid ${stalePid}`, {\n      reason: outcome.reason,\n      parentPid: outcome.parentPid,\n      parentCommand: outcome.parentCommand,\n      detail: outcome.detail,\n    });\n  }\n  return outcome.killed;\n}\n"]}

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

@@ -17,7 +17,8 @@ import type { MetricSnapshot } from '../../metrics/types.js';
 import type { MemoryLogSink } from '../../logging/sinks/MemoryLogSink.js';
 import type { MemoryMetricsSink } from '../../metrics/sinks/MemoryMetricsSink.js';
 import { logger } from '../../utils/logger.js';
-import { detectLegacyLeader, type ElectionResult } from './LeaderElection.js';
+import { detectLegacyLeader, readLeaderLock, deleteLeaderLock, type ElectionResult, type ConsoleLeaderInfo } from './LeaderElection.js';
+import { findPidOnPort } from './StaleProcessRecovery.js';
 /**
  * Options for starting the unified console.
  */
@@ -79,6 +80,25 @@ export interface UnifiedConsoleResult {
  *          threw. Exposed so tests can assert the full result shape.
  */
 export declare function warnIfLegacyConsolePresent(currentPort: number, detect?: typeof detectLegacyLeader, log?: typeof logger): Promise<Awaited<ReturnType<typeof detectLegacyLeader>> | null>;
+export interface PortLeaderDiscovery {
+    leaderInfo: ConsoleLeaderInfo | null;
+    ownerPid: number | null;
+    source: 'api' | 'lock' | 'synthetic' | 'none';
+}
+export interface BindFailureRecoveryResult extends PortLeaderDiscovery {
+    lockCleanupAttempted: boolean;
+    lockCleanupPerformed: boolean;
+}
+interface DiscoveryDependencies {
+    fetchImpl?: typeof fetch;
+    findPidOnPortImpl?: typeof findPidOnPort;
+    readLeaderLockImpl?: typeof readLeaderLock;
+}
+export declare function discoverLeaderServingPort(port: number, authToken: string | null, deps?: DiscoveryDependencies): Promise<PortLeaderDiscovery>;
+interface BindFailureRecoveryDependencies extends DiscoveryDependencies {
+    deleteLeaderLockImpl?: typeof deleteLeaderLock;
+}
+export declare function recoverLeaderBindFailure(provisionalLeader: ConsoleLeaderInfo, port: number, authToken: string | null, deps?: BindFailureRecoveryDependencies): Promise<BindFailureRecoveryResult>;
 /**
  * Start the unified web console.
  *
@@ -86,4 +106,5 @@ export declare function warnIfLegacyConsolePresent(currentPort: number, detect?:
  * or sets up event forwarding (follower).
  */
 export declare function startUnifiedConsole(options: UnifiedConsoleOptions): Promise<UnifiedConsoleResult>;
+export {};
 //# sourceMappingURL=UnifiedConsole.d.ts.map

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

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

package/dist/web/console/UnifiedConsole.js

@@ -12,12 +12,14 @@
  *
  * @since v2.1.0 — Issue #1700
  */
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
 import { logger } from '../../utils/logger.js';
-import { electLeader, isLeaderWebConsoleReachable, forceClaimLeadership, startHeartbeat, registerLeaderCleanup, detectLegacyLeader, } from './LeaderElection.js';
+import { electLeader, isLeaderWebConsoleReachable, forceClaimLeadership, startHeartbeat, registerLeaderCleanup, detectLegacyLeader, readLeaderLock, deleteLeaderLock, LOCK_VERSION, CONSOLE_PROTOCOL_VERSION, LEGACY_SERVER_VERSION, } from './LeaderElection.js';
 import { createIngestRoutes } from './IngestRoutes.js';
 import { LeaderForwardingLogSink, SessionHeartbeat, } from './LeaderForwardingSink.js';
 import { PromotionManager } from './PromotionManager.js';
 import { ConsoleTokenStore } from './consoleToken.js';
+import { findPidOnPort } from './StaleProcessRecovery.js';
 import { env } from '../../config/env.js';
 /**
  * Default console port from the env var. Used as fallback when no port
@@ -27,6 +29,11 @@ import { env } from '../../config/env.js';
  *   3. 41715 (hardcoded default in env.ts)
  */
 const DEFAULT_CONSOLE_PORT = env.DOLLHOUSE_WEB_CONSOLE_PORT;
+const LEGACY_CONSOLE_FALLBACK_PORT = 3939;
+const SYNTHETIC_PORT_OWNER_SESSION_PREFIX = 'port-owner-';
+function currentTimestamp() {
+    return new Date().toISOString();
+}
 /**
  * Check for a running legacy (pre-authentication) DollhouseMCP console and
  * log a WARN-level message if one is found (#1794).
@@ -56,7 +63,7 @@ export async function warnIfLegacyConsolePresent(currentPort, detect = detectLeg
                 `(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}. ` +
+                `the legacy console uses port ${legacy.port ?? LEGACY_CONSOLE_FALLBACK_PORT}. ` +
                 `For consistent security, update the legacy installation to a ` +
                 `version with the authenticated console.`);
         }
@@ -70,6 +77,135 @@ export async function warnIfLegacyConsolePresent(currentPort, detect = detectLeg
         return null;
     }
 }
+function buildDiscoveryHeaders(authToken) {
+    return authToken ? { Authorization: `Bearer ${authToken}` } : {};
+}
+function buildLeaderInfoFromSession(port, ownerPid, leaderSession) {
+    return {
+        version: LOCK_VERSION,
+        pid: ownerPid,
+        port,
+        sessionId: UnicodeValidator.normalize(leaderSession.sessionId).normalizedContent,
+        startedAt: leaderSession.startedAt ?? currentTimestamp(),
+        heartbeat: leaderSession.lastHeartbeat ?? currentTimestamp(),
+        serverVersion: leaderSession.serverVersion ?? LEGACY_SERVER_VERSION,
+        consoleProtocolVersion: leaderSession.consoleProtocolVersion ?? CONSOLE_PROTOCOL_VERSION,
+    };
+}
+function buildSyntheticLeaderInfo(port, ownerPid) {
+    const now = currentTimestamp();
+    return {
+        version: LOCK_VERSION,
+        pid: ownerPid,
+        port,
+        sessionId: `${SYNTHETIC_PORT_OWNER_SESSION_PREFIX}${ownerPid}`,
+        startedAt: now,
+        heartbeat: now,
+        serverVersion: LEGACY_SERVER_VERSION,
+        consoleProtocolVersion: CONSOLE_PROTOCOL_VERSION,
+    };
+}
+async function discoverLeaderViaSessionsApi(port, ownerPid, authToken, fetchImpl) {
+    const response = await fetchImpl(`http://127.0.0.1:${port}/api/sessions`, {
+        headers: buildDiscoveryHeaders(authToken),
+    });
+    if (!response.ok) {
+        return null;
+    }
+    const payload = await response.json();
+    const sessions = Array.isArray(payload.sessions) ? payload.sessions : [];
+    const leaderSession = sessions.find((session) => session.pid === ownerPid &&
+        session.isLeader === true &&
+        session.kind === 'mcp' &&
+        session.status !== 'stopped');
+    return leaderSession ? buildLeaderInfoFromSession(port, ownerPid, leaderSession) : null;
+}
+export async function discoverLeaderServingPort(port, authToken, deps = {}) {
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const findPidOnPortImpl = deps.findPidOnPortImpl ?? findPidOnPort;
+    const readLeaderLockImpl = deps.readLeaderLockImpl ?? readLeaderLock;
+    const ownerPid = await findPidOnPortImpl(port);
+    if (ownerPid !== null) {
+        try {
+            const leaderInfo = await discoverLeaderViaSessionsApi(port, ownerPid, authToken, fetchImpl);
+            if (leaderInfo) {
+                return { ownerPid, source: 'api', leaderInfo };
+            }
+        }
+        catch (err) {
+            logger.debug('[UnifiedConsole] Failed to query active leader sessions', {
+                port,
+                ownerPid,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    const lock = await readLeaderLockImpl();
+    if (lock?.port === port && (ownerPid === null || lock.pid === ownerPid)) {
+        return {
+            ownerPid: ownerPid ?? lock.pid,
+            source: 'lock',
+            leaderInfo: {
+                ...lock,
+                sessionId: UnicodeValidator.normalize(lock.sessionId).normalizedContent,
+            },
+        };
+    }
+    if (ownerPid !== null) {
+        return {
+            ownerPid,
+            source: 'synthetic',
+            leaderInfo: buildSyntheticLeaderInfo(port, ownerPid),
+        };
+    }
+    return { leaderInfo: null, ownerPid: null, source: 'none' };
+}
+export async function recoverLeaderBindFailure(provisionalLeader, port, authToken, deps = {}) {
+    const readLeaderLockImpl = deps.readLeaderLockImpl ?? readLeaderLock;
+    const deleteLeaderLockImpl = deps.deleteLeaderLockImpl ?? deleteLeaderLock;
+    logger.info('[UnifiedConsole] Leader bind recovery initiated', {
+        provisionalSessionId: provisionalLeader.sessionId,
+        provisionalPid: provisionalLeader.pid,
+        port,
+    });
+    let fallback = await discoverLeaderServingPort(port, authToken, deps);
+    let lockCleanupAttempted = false;
+    let lockCleanupPerformed = false;
+    const currentLock = await readLeaderLockImpl();
+    const provisionalLockMatches = (currentLock?.pid === provisionalLeader.pid &&
+        currentLock.port === provisionalLeader.port &&
+        currentLock.sessionId === provisionalLeader.sessionId);
+    const fallbackPointsToProvisionalLeader = (fallback.leaderInfo?.pid === provisionalLeader.pid &&
+        fallback.leaderInfo.port === provisionalLeader.port &&
+        fallback.leaderInfo.sessionId === provisionalLeader.sessionId);
+    if (provisionalLockMatches) {
+        lockCleanupAttempted = true;
+        await deleteLeaderLockImpl();
+        lockCleanupPerformed = true;
+        logger.info('[UnifiedConsole] Removed provisional leader lock after bind failure', {
+            provisionalSessionId: provisionalLeader.sessionId,
+            provisionalPid: provisionalLeader.pid,
+            port,
+        });
+        if (fallbackPointsToProvisionalLeader) {
+            fallback = await discoverLeaderServingPort(port, authToken, deps);
+        }
+    }
+    logger.info('[UnifiedConsole] Leader bind recovery completed', {
+        provisionalSessionId: provisionalLeader.sessionId,
+        provisionalPid: provisionalLeader.pid,
+        port,
+        discoverySource: fallback.source,
+        ownerPid: fallback.ownerPid,
+        lockCleanupAttempted,
+        lockCleanupPerformed,
+    });
+    return {
+        ...fallback,
+        lockCleanupAttempted,
+        lockCleanupPerformed,
+    };
+}
 /**
  * Start the unified web console.
  *
@@ -134,10 +270,6 @@ async function startAsLeader(options, election, consolePort = DEFAULT_CONSOLE_PO
         metricsOnSnapshot: (snapshot) => liveMetricsOnSnapshot?.(snapshot),
         storeMetricsSnapshot: (snapshot) => options.metricsSink?.onSnapshot(snapshot),
     });
-    // Register the leader as a session
-    ingestResult.registerLeaderSession(options.sessionId, process.pid);
-    // 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 = {
@@ -153,8 +285,34 @@ async function startAsLeader(options, election, consolePort = DEFAULT_CONSOLE_PO
     // process on the port, then retrying. No external retry loop needed.
     const webResult = await startWebServer(serverOpts);
     if (webResult.bindResult && !webResult.bindResult.success) {
-        logger.error(`[UnifiedConsole] Leader failed to bind port ${consolePort} — console unavailable`);
+        const fallback = await recoverLeaderBindFailure(election.leaderInfo, consolePort, primaryToken.token);
+        if (fallback.leaderInfo) {
+            logger.warn('[UnifiedConsole] Leader role aborted: bind failed, falling back to follower', {
+                port: consolePort,
+                bindError: webResult.bindResult.error,
+                bindDetail: webResult.bindResult.detail,
+                provisionalLeaderPid: election.leaderInfo.pid,
+                provisionalLeaderSessionId: election.leaderInfo.sessionId,
+                ownerPid: fallback.ownerPid,
+                source: fallback.source,
+                lockCleanupAttempted: fallback.lockCleanupAttempted,
+                lockCleanupPerformed: fallback.lockCleanupPerformed,
+            });
+            const followerElection = { role: 'follower', leaderInfo: fallback.leaderInfo };
+            return startAsFollower(options, followerElection, consolePort, primaryToken.token);
+        }
+        logger.error('[UnifiedConsole] Leader failed to bind and no active leader could be identified', {
+            port: consolePort,
+            provisionalLeaderPid: election.leaderInfo.pid,
+            bindError: webResult.bindResult.error,
+            bindDetail: webResult.bindResult.detail,
+        });
+        throw new Error(`Leader failed to bind port ${consolePort} and no active leader was discoverable`);
     }
+    // Register the leader only after the HTTP listener is actually serving the port.
+    ingestResult.registerLeaderSession(options.sessionId, process.pid);
+    // Register the web console itself so the session indicator is never empty (#1805)
+    ingestResult.registerConsoleSession();
     // Wire SSE broadcasts for this leader's own events
     options.wireSSEBroadcasts(webResult, options.metricsSink);
     // Now wire the live broadcast functions into the ingest routes
@@ -191,13 +349,16 @@ async function startAsLeader(options, election, consolePort = DEFAULT_CONSOLE_PO
  * Start as a follower.
  * Registers forwarding sinks with the LogManager, starts session heartbeat.
  */
-async function startAsFollower(options, election, consolePort = DEFAULT_CONSOLE_PORT) {
+async function startAsFollower(options, election, consolePort = DEFAULT_CONSOLE_PORT, initialAuthToken = null) {
     const leaderUrl = `http://127.0.0.1:${election.leaderInfo.port}`;
     // 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);
+    let authToken = initialAuthToken;
+    if (authToken === null) {
+        const { getPrimaryTokenFromFile } = await import('./consoleToken.js');
+        authToken = await getPrimaryTokenFromFile(env.DOLLHOUSE_CONSOLE_TOKEN_FILE);
+    }
     if (authToken) {
         logger.debug('[UnifiedConsole] Follower loaded console auth token');
     }
@@ -233,4 +394,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 { pickRandomTokenName } = 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(pickRandomTokenName());\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    storeMetricsSnapshot: (snapshot) => options.metricsSink?.onSnapshot(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"]}
+//# 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 { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { logger } from '../../utils/logger.js';\nimport {\n  electLeader,\n  isLeaderWebConsoleReachable,\n  forceClaimLeadership,\n  startHeartbeat,\n  registerLeaderCleanup,\n  detectLegacyLeader,\n  readLeaderLock,\n  deleteLeaderLock,\n  LOCK_VERSION,\n  CONSOLE_PROTOCOL_VERSION,\n  LEGACY_SERVER_VERSION,\n  type ElectionResult,\n  type ConsoleLeaderInfo,\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 { findPidOnPort } from './StaleProcessRecovery.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;\nconst LEGACY_CONSOLE_FALLBACK_PORT = 3939;\nconst SYNTHETIC_PORT_OWNER_SESSION_PREFIX = 'port-owner-';\n\nfunction currentTimestamp(): string {\n  return new Date().toISOString();\n}\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 ?? LEGACY_CONSOLE_FALLBACK_PORT}. ` +\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\ninterface SessionApiRecord {\n  sessionId: string;\n  pid: number;\n  startedAt?: string;\n  lastHeartbeat?: string;\n  status?: string;\n  isLeader?: boolean;\n  kind?: string;\n  serverVersion?: string;\n  consoleProtocolVersion?: number;\n}\n\nexport interface PortLeaderDiscovery {\n  leaderInfo: ConsoleLeaderInfo | null;\n  ownerPid: number | null;\n  source: 'api' | 'lock' | 'synthetic' | 'none';\n}\n\nexport interface BindFailureRecoveryResult extends PortLeaderDiscovery {\n  lockCleanupAttempted: boolean;\n  lockCleanupPerformed: boolean;\n}\n\ninterface DiscoveryDependencies {\n  fetchImpl?: typeof fetch;\n  findPidOnPortImpl?: typeof findPidOnPort;\n  readLeaderLockImpl?: typeof readLeaderLock;\n}\n\nfunction buildDiscoveryHeaders(authToken: string | null): Record<string, string> {\n  return authToken ? { Authorization: `Bearer ${authToken}` } : {};\n}\n\nfunction buildLeaderInfoFromSession(port: number, ownerPid: number, leaderSession: SessionApiRecord): ConsoleLeaderInfo {\n  return {\n    version: LOCK_VERSION,\n    pid: ownerPid,\n    port,\n    sessionId: UnicodeValidator.normalize(leaderSession.sessionId).normalizedContent,\n    startedAt: leaderSession.startedAt ?? currentTimestamp(),\n    heartbeat: leaderSession.lastHeartbeat ?? currentTimestamp(),\n    serverVersion: leaderSession.serverVersion ?? LEGACY_SERVER_VERSION,\n    consoleProtocolVersion: leaderSession.consoleProtocolVersion ?? CONSOLE_PROTOCOL_VERSION,\n  };\n}\n\nfunction buildSyntheticLeaderInfo(port: number, ownerPid: number): ConsoleLeaderInfo {\n  const now = currentTimestamp();\n  return {\n    version: LOCK_VERSION,\n    pid: ownerPid,\n    port,\n    sessionId: `${SYNTHETIC_PORT_OWNER_SESSION_PREFIX}${ownerPid}`,\n    startedAt: now,\n    heartbeat: now,\n    serverVersion: LEGACY_SERVER_VERSION,\n    consoleProtocolVersion: CONSOLE_PROTOCOL_VERSION,\n  };\n}\n\nasync function discoverLeaderViaSessionsApi(\n  port: number,\n  ownerPid: number,\n  authToken: string | null,\n  fetchImpl: typeof fetch,\n): Promise<ConsoleLeaderInfo | null> {\n  const response = await fetchImpl(`http://127.0.0.1:${port}/api/sessions`, {\n    headers: buildDiscoveryHeaders(authToken),\n  });\n  if (!response.ok) {\n    return null;\n  }\n\n  const payload = await response.json() as { sessions?: SessionApiRecord[] };\n  const sessions = Array.isArray(payload.sessions) ? payload.sessions : [];\n  const leaderSession = sessions.find((session) =>\n    session.pid === ownerPid &&\n    session.isLeader === true &&\n    session.kind === 'mcp' &&\n    session.status !== 'stopped'\n  );\n  return leaderSession ? buildLeaderInfoFromSession(port, ownerPid, leaderSession) : null;\n}\n\nexport async function discoverLeaderServingPort(\n  port: number,\n  authToken: string | null,\n  deps: DiscoveryDependencies = {},\n): Promise<PortLeaderDiscovery> {\n  const fetchImpl = deps.fetchImpl ?? fetch;\n  const findPidOnPortImpl = deps.findPidOnPortImpl ?? findPidOnPort;\n  const readLeaderLockImpl = deps.readLeaderLockImpl ?? readLeaderLock;\n  const ownerPid = await findPidOnPortImpl(port);\n\n  if (ownerPid !== null) {\n    try {\n      const leaderInfo = await discoverLeaderViaSessionsApi(port, ownerPid, authToken, fetchImpl);\n      if (leaderInfo) {\n        return { ownerPid, source: 'api', leaderInfo };\n      }\n    } catch (err) {\n      logger.debug('[UnifiedConsole] Failed to query active leader sessions', {\n        port,\n        ownerPid,\n        error: err instanceof Error ? err.message : String(err),\n      });\n    }\n  }\n\n  const lock = await readLeaderLockImpl();\n  if (lock?.port === port && (ownerPid === null || lock.pid === ownerPid)) {\n    return {\n      ownerPid: ownerPid ?? lock.pid,\n      source: 'lock',\n      leaderInfo: {\n        ...lock,\n        sessionId: UnicodeValidator.normalize(lock.sessionId).normalizedContent,\n      },\n    };\n  }\n\n  if (ownerPid !== null) {\n    return {\n      ownerPid,\n      source: 'synthetic',\n      leaderInfo: buildSyntheticLeaderInfo(port, ownerPid),\n    };\n  }\n\n  return { leaderInfo: null, ownerPid: null, source: 'none' };\n}\n\ninterface BindFailureRecoveryDependencies extends DiscoveryDependencies {\n  deleteLeaderLockImpl?: typeof deleteLeaderLock;\n}\n\nexport async function recoverLeaderBindFailure(\n  provisionalLeader: ConsoleLeaderInfo,\n  port: number,\n  authToken: string | null,\n  deps: BindFailureRecoveryDependencies = {},\n): Promise<BindFailureRecoveryResult> {\n  const readLeaderLockImpl = deps.readLeaderLockImpl ?? readLeaderLock;\n  const deleteLeaderLockImpl = deps.deleteLeaderLockImpl ?? deleteLeaderLock;\n  logger.info('[UnifiedConsole] Leader bind recovery initiated', {\n    provisionalSessionId: provisionalLeader.sessionId,\n    provisionalPid: provisionalLeader.pid,\n    port,\n  });\n\n  let fallback = await discoverLeaderServingPort(port, authToken, deps);\n  let lockCleanupAttempted = false;\n  let lockCleanupPerformed = false;\n  const currentLock = await readLeaderLockImpl();\n  const provisionalLockMatches = (\n    currentLock?.pid === provisionalLeader.pid &&\n    currentLock.port === provisionalLeader.port &&\n    currentLock.sessionId === provisionalLeader.sessionId\n  );\n  const fallbackPointsToProvisionalLeader = (\n    fallback.leaderInfo?.pid === provisionalLeader.pid &&\n    fallback.leaderInfo.port === provisionalLeader.port &&\n    fallback.leaderInfo.sessionId === provisionalLeader.sessionId\n  );\n\n  if (provisionalLockMatches) {\n    lockCleanupAttempted = true;\n    await deleteLeaderLockImpl();\n    lockCleanupPerformed = true;\n    logger.info('[UnifiedConsole] Removed provisional leader lock after bind failure', {\n      provisionalSessionId: provisionalLeader.sessionId,\n      provisionalPid: provisionalLeader.pid,\n      port,\n    });\n    if (fallbackPointsToProvisionalLeader) {\n      fallback = await discoverLeaderServingPort(port, authToken, deps);\n    }\n  }\n\n  logger.info('[UnifiedConsole] Leader bind recovery completed', {\n    provisionalSessionId: provisionalLeader.sessionId,\n    provisionalPid: provisionalLeader.pid,\n    port,\n    discoverySource: fallback.source,\n    ownerPid: fallback.ownerPid,\n    lockCleanupAttempted,\n    lockCleanupPerformed,\n  });\n\n  return {\n    ...fallback,\n    lockCleanupAttempted,\n    lockCleanupPerformed,\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 { pickRandomTokenName } = 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(pickRandomTokenName());\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    storeMetricsSnapshot: (snapshot) => options.metricsSink?.onSnapshot(snapshot),\n  });\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    const fallback = await recoverLeaderBindFailure(election.leaderInfo, consolePort, primaryToken.token);\n    if (fallback.leaderInfo) {\n      logger.warn('[UnifiedConsole] Leader role aborted: bind failed, falling back to follower', {\n        port: consolePort,\n        bindError: webResult.bindResult.error,\n        bindDetail: webResult.bindResult.detail,\n        provisionalLeaderPid: election.leaderInfo.pid,\n        provisionalLeaderSessionId: election.leaderInfo.sessionId,\n        ownerPid: fallback.ownerPid,\n        source: fallback.source,\n        lockCleanupAttempted: fallback.lockCleanupAttempted,\n        lockCleanupPerformed: fallback.lockCleanupPerformed,\n      });\n      const followerElection: ElectionResult = { role: 'follower', leaderInfo: fallback.leaderInfo };\n      return startAsFollower(options, followerElection, consolePort, primaryToken.token);\n    }\n\n    logger.error('[UnifiedConsole] Leader failed to bind and no active leader could be identified', {\n      port: consolePort,\n      provisionalLeaderPid: election.leaderInfo.pid,\n      bindError: webResult.bindResult.error,\n      bindDetail: webResult.bindResult.detail,\n    });\n    throw new Error(`Leader failed to bind port ${consolePort} and no active leader was discoverable`);\n  }\n\n  // Register the leader only after the HTTP listener is actually serving the port.\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  // 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  initialAuthToken: string | null = null,\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  let authToken = initialAuthToken;\n  if (authToken === null) {\n    const { getPrimaryTokenFromFile } = await import('./consoleToken.js');\n    authToken = await getPrimaryTokenFromFile(env.DOLLHOUSE_CONSOLE_TOKEN_FILE);\n  }\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"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dollhousemcp/mcp-server",
-  "version": "2.0.19",
+  "version": "2.0.20",
   "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.19",
+  "version": "2.0.20",
   "homepage": "https://dollhousemcp.com",
   "repository": {
     "type": "git",
@@ -29,7 +29,7 @@
     {
       "registryType": "npm",
       "identifier": "@dollhousemcp/mcp-server",
-      "version": "2.0.19",
+      "version": "2.0.20",
       "transport": {
         "type": "stdio"
       }