@dollhousemcp/mcp-server
Version:
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.
233 lines • 29 kB
JavaScript
/**
* Dynamic port allocation and port file discovery for the web console.
*
* When multiple DollhouseMCP sessions run simultaneously (e.g., multiple
* Claude Code windows, IDE instances, or agent sessions), each needs its
* own web console port. This module handles:
*
* 1. Finding an available port starting from the configured default
* (see `DOLLHOUSE_WEB_CONSOLE_PORT` in `src/config/env.ts`)
* 2. Writing port discovery files so external tools know which port to use
* 3. Cleaning up port files on process exit
*
* Port files are written to ~/.dollhouse/run/:
* - permission-server-{pid}.port — per-process file (cleaned on exit)
* - permission-server.port — latest port (convenience for scripts)
*/
import { createServer } from 'node:net';
import { homedir } from 'node:os';
import { join } from 'node:path';
import { mkdir, writeFile, unlink, readdir, readFile } from 'node:fs/promises';
import { env } from '../config/env.js';
import { logger } from '../utils/logger.js';
/** Default maximum port attempts before giving up */
const DEFAULT_MAX_PORT_ATTEMPTS = 10;
/** Directory for runtime state files (port discovery, PID files) */
const RUN_DIR = join(homedir(), '.dollhouse', 'run');
const LATEST_PORT_FILENAME = 'permission-server.port';
function pidPortFilePath(dir = RUN_DIR, pid = process.pid) {
return join(dir, `permission-server-${pid}.port`);
}
function latestPortFilePath(dir = RUN_DIR) {
return join(dir, LATEST_PORT_FILENAME);
}
/** Track port file path for cleanup */
let portFilePath = null;
/**
* Attempt to bind to a single port. Returns the port if successful, null if in use.
* Keeps the server listening to prevent TOCTOU race conditions — caller must
* close the returned server after their own server binds.
*/
function tryBindPort(port) {
return new Promise((resolve) => {
const server = createServer();
server.once('error', (err) => {
if (err.code === 'EADDRINUSE') {
resolve(null);
}
else {
resolve(null);
logger.debug(`[PortDiscovery] Unexpected error on port ${port}: ${err.code}`);
}
});
server.once('listening', () => {
resolve({ port, server });
});
server.listen(port, '127.0.0.1');
});
}
/**
* Find an available port starting from the given port.
*
* Tries sequential ports, logging each attempt. Returns both the port number
* and a held server to prevent TOCTOU race conditions. The caller should
* close the held server after binding their own Express app to the port.
*
* @param startPort - Port to try first (see `DOLLHOUSE_WEB_CONSOLE_PORT` for the default)
* @param maxAttempts - Maximum ports to try (default: 10, configurable via DOLLHOUSE_MAX_PORT_ATTEMPTS)
* @returns Object with port number and held server, or throws if all attempts fail
*/
export async function findAvailablePort(startPort, maxAttempts = Number(process.env.DOLLHOUSE_MAX_PORT_ATTEMPTS) || DEFAULT_MAX_PORT_ATTEMPTS) {
for (let attempt = 0; attempt < maxAttempts; attempt++) {
const port = startPort + attempt;
logger.debug(`[PortDiscovery] Trying port ${port} (attempt ${attempt + 1}/${maxAttempts})`);
const result = await tryBindPort(port);
if (result) {
// Close the probe server — there's a brief TOCTOU window here between
// closing and the caller binding, but it's negligible on localhost.
// A future improvement could return the server for the caller to adopt.
result.server.close();
if (attempt > 0) {
logger.info(`[PortDiscovery] Port ${startPort} in use, using ${port} (after ${attempt} skip${attempt > 1 ? 's' : ''})`);
}
return port;
}
logger.debug(`[PortDiscovery] Port ${port} in use, trying next`);
}
throw new Error(`No available port found in range ${startPort}-${startPort + maxAttempts - 1} ` +
`after ${maxAttempts} attempts. Set DOLLHOUSE_MAX_PORT_ATTEMPTS to increase the range.`);
}
/**
* Write the active server port to a discoverable file.
*
* Creates two files:
* - PID-keyed file for per-process cleanup
* - Latest file for convenience (scripts can read this without knowing the PID)
*
* @param port - The port the web server is listening on
* @returns Path to the PID-keyed port file
*/
export async function writePortFile(port) {
await mkdir(RUN_DIR, { recursive: true });
const pidFile = pidPortFilePath();
const latestFile = latestPortFilePath();
await writeFile(pidFile, String(port), 'utf-8');
await writeFile(latestFile, String(port), 'utf-8');
portFilePath = pidFile;
logger.debug(`[PortDiscovery] Port file written: ${pidFile}`);
return pidFile;
}
/**
* Restore or update the shared latest port file for the active listener.
*
* Returns true when the file had to be written or updated, false when it
* already matched the active port.
*/
export async function ensureLatestPortFile(port, customDir) {
const dir = customDir || RUN_DIR;
const latestFile = latestPortFilePath(dir);
const desiredValue = String(port);
await mkdir(dir, { recursive: true });
try {
const existingValue = (await readFile(latestFile, 'utf-8')).trim();
if (existingValue === desiredValue) {
return false;
}
}
catch {
// Missing/unreadable file — rewrite below.
}
await writeFile(latestFile, desiredValue, 'utf-8');
logger.debug(`[PortDiscovery] Shared latest port file refreshed: ${latestFile}`);
return true;
}
/**
* Clean up port file on shutdown.
*/
export async function cleanupPortFile() {
if (portFilePath) {
try {
await unlink(portFilePath);
}
catch { /* already gone */ }
}
}
/**
* Register process exit handlers to clean up port files.
* Should be called once after the web server successfully starts.
*/
export function registerPortCleanup() {
const exitCleanup = () => { cleanupPortFile().catch(() => { }); };
process.once('exit', exitCleanup);
process.once('SIGTERM', exitCleanup);
process.once('SIGINT', exitCleanup);
process.once('SIGHUP', exitCleanup);
}
/**
* Sweep stale port files from ~/.dollhouse/run/ on startup (#1856).
*
* Scans for permission-server-{pid}.port files and removes any whose PID
* is no longer alive. This prevents unbounded accumulation of port files
* from crashed or abandoned sessions.
*
* Note: This only removes metadata files, not processes or ports. The port
* binding itself (in bindAndListen) is atomic via listen(). There is no race
* between sweeping files and binding — they operate on independent resources.
*
* Safe to call on every startup — only removes files for dead processes.
*/
export async function sweepStalePortFiles(customDir) {
try {
const dir = customDir || RUN_DIR;
await mkdir(dir, { recursive: true });
const files = await readdir(dir);
const PORT_FILE_RE = /^permission-server-(\d+)\.port$/;
let removed = 0;
for (const file of files) {
const match = PORT_FILE_RE.exec(file);
if (!match)
continue;
const pid = Number(match[1]);
// Check if process is alive via signal-0.
// ESRCH = process doesn't exist (dead). EPERM = process exists but
// owned by another user (alive — don't touch their port file).
let alive = false;
try {
process.kill(pid, 0);
alive = true;
}
catch (err) {
alive = err?.code === 'EPERM'; // EPERM = alive but different user
}
if (!alive) {
try {
await unlink(join(dir, file));
removed++;
}
catch { /* already gone */ }
}
}
if (removed > 0) {
logger.info(`[PortDiscovery] Swept ${removed} stale port files from ${dir}`);
}
return removed;
}
catch (err) {
logger.debug('[PortDiscovery] Stale port file sweep failed', {
error: err instanceof Error ? err.message : String(err),
});
return 0;
}
}
/**
* Discover an available port, write discovery files, and register cleanup.
*
* This is the recommended entry point for Container startup. Combines
* port discovery, file writing, and cleanup registration in one call.
*
* @param defaultPort - Port to try first (see `DOLLHOUSE_WEB_CONSOLE_PORT` for the default)
* @returns The port the server should bind to, or undefined if discovery failed
*/
export async function discoverAndBindPort(defaultPort = env.DOLLHOUSE_WEB_CONSOLE_PORT) {
try {
const port = await findAvailablePort(defaultPort);
await writePortFile(port);
registerPortCleanup();
return port;
}
catch (err) {
logger.warn('[PortDiscovery] Port discovery failed:', err);
return undefined;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portDiscovery.js","sourceRoot":"","sources":["../../src/web/portDiscovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,YAAY,EAAe,MAAM,UAAU,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC/E,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,qDAAqD;AACrD,MAAM,yBAAyB,GAAG,EAAE,CAAC;AAErC,oEAAoE;AACpE,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,YAAY,EAAE,KAAK,CAAC,CAAC;AACrD,MAAM,oBAAoB,GAAG,wBAAwB,CAAC;AAEtD,SAAS,eAAe,CAAC,MAAc,OAAO,EAAE,MAAc,OAAO,CAAC,GAAG;IACvE,OAAO,IAAI,CAAC,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,CAAC;AACpD,CAAC;AAED,SAAS,kBAAkB,CAAC,MAAc,OAAO;IAC/C,OAAO,IAAI,CAAC,GAAG,EAAE,oBAAoB,CAAC,CAAC;AACzC,CAAC;AAED,uCAAuC;AACvC,IAAI,YAAY,GAAkB,IAAI,CAAC;AAEvC;;;;GAIG;AACH,SAAS,WAAW,CAAC,IAAY;IAC/B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;QAC9B,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAA0B,EAAE,EAAE;YAClD,IAAI,GAAG,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;gBAC9B,OAAO,CAAC,IAAI,CAAC,CAAC;YAChB,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,IAAI,CAAC,CAAC;gBACd,MAAM,CAAC,KAAK,CAAC,4CAA4C,IAAI,KAAK,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;YAChF,CAAC;QACH,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,EAAE;YAC5B,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;QAC5B,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IACnC,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,SAAiB,EACjB,cAAsB,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,2BAA2B,CAAC,IAAI,yBAAyB;IAElG,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,WAAW,EAAE,OAAO,EAAE,EAAE,CAAC;QACvD,MAAM,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC;QACjC,MAAM,CAAC,KAAK,CAAC,+BAA+B,IAAI,aAAa,OAAO,GAAG,CAAC,IAAI,WAAW,GAAG,CAAC,CAAC;QAE5F,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,MAAM,EAAE,CAAC;YACX,sEAAsE;YACtE,oEAAoE;YACpE,wEAAwE;YACxE,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YACtB,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;gBAChB,MAAM,CAAC,IAAI,CAAC,wBAAwB,SAAS,kBAAkB,IAAI,WAAW,OAAO,QAAQ,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;YAC1H,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,CAAC,KAAK,CAAC,wBAAwB,IAAI,sBAAsB,CAAC,CAAC;IACnE,CAAC;IAED,MAAM,IAAI,KAAK,CACb,oCAAoC,SAAS,IAAI,SAAS,GAAG,WAAW,GAAG,CAAC,GAAG;QAC/E,SAAS,WAAW,mEAAmE,CACxF,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,IAAY;IAC9C,MAAM,KAAK,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1C,MAAM,OAAO,GAAG,eAAe,EAAE,CAAC;IAClC,MAAM,UAAU,GAAG,kBAAkB,EAAE,CAAC;IACxC,MAAM,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;IAChD,MAAM,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;IACnD,YAAY,GAAG,OAAO,CAAC;IACvB,MAAM,CAAC,KAAK,CAAC,sCAAsC,OAAO,EAAE,CAAC,CAAC;IAC9D,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,IAAY,EAAE,SAAkB;IACzE,MAAM,GAAG,GAAG,SAAS,IAAI,OAAO,CAAC;IACjC,MAAM,UAAU,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC;IAC3C,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAElC,MAAM,KAAK,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAEtC,IAAI,CAAC;QACH,MAAM,aAAa,GAAG,CAAC,MAAM,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACnE,IAAI,aAAa,KAAK,YAAY,EAAE,CAAC;YACnC,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,2CAA2C;IAC7C,CAAC;IAED,MAAM,SAAS,CAAC,UAAU,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACnD,MAAM,CAAC,KAAK,CAAC,sDAAsD,UAAU,EAAE,CAAC,CAAC;IACjF,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe;IACnC,IAAI,YAAY,EAAE,CAAC;QACjB,IAAI,CAAC;YAAC,MAAM,MAAM,CAAC,YAAY,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC,CAAC,kBAAkB,CAAC,CAAC;IAClE,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,mBAAmB;IACjC,MAAM,WAAW,GAAG,GAAG,EAAE,GAAG,eAAe,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAClC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IACrC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IACpC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,SAAkB;IAC1D,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,SAAS,IAAI,OAAO,CAAC;QACjC,MAAM,KAAK,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACtC,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;QACjC,MAAM,YAAY,GAAG,iCAAiC,CAAC;QACvD,IAAI,OAAO,GAAG,CAAC,CAAC;QAEhB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,KAAK,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACtC,IAAI,CAAC,KAAK;gBAAE,SAAS;YACrB,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAE7B,0CAA0C;YAC1C,mEAAmE;YACnE,+DAA+D;YAC/D,IAAI,KAAK,GAAG,KAAK,CAAC;YAClB,IAAI,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;gBACrB,KAAK,GAAG,IAAI,CAAC;YACf,CAAC;YAAC,OAAO,GAAQ,EAAE,CAAC;gBAClB,KAAK,GAAG,GAAG,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC,mCAAmC;YACpE,CAAC;YAED,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,IAAI,CAAC;oBACH,MAAM,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;oBAC9B,OAAO,EAAE,CAAC;gBACZ,CAAC;gBAAC,MAAM,CAAC,CAAC,kBAAkB,CAAC,CAAC;YAChC,CAAC;QACH,CAAC;QAED,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,yBAAyB,OAAO,0BAA0B,GAAG,EAAE,CAAC,CAAC;QAC/E,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,8CAA8C,EAAE;YAC3D,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;SACxD,CAAC,CAAC;QACH,OAAO,CAAC,CAAC;IACX,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,cAAsB,GAAG,CAAC,0BAA0B;IAEpD,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAAC,WAAW,CAAC,CAAC;QAElD,MAAM,aAAa,CAAC,IAAI,CAAC,CAAC;QAC1B,mBAAmB,EAAE,CAAC;QAEtB,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,wCAAwC,EAAE,GAAG,CAAC,CAAC;QAC3D,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC","sourcesContent":["/**\n * Dynamic port allocation and port file discovery for the web console.\n *\n * When multiple DollhouseMCP sessions run simultaneously (e.g., multiple\n * Claude Code windows, IDE instances, or agent sessions), each needs its\n * own web console port. This module handles:\n *\n * 1. Finding an available port starting from the configured default\n *    (see `DOLLHOUSE_WEB_CONSOLE_PORT` in `src/config/env.ts`)\n * 2. Writing port discovery files so external tools know which port to use\n * 3. Cleaning up port files on process exit\n *\n * Port files are written to ~/.dollhouse/run/:\n * - permission-server-{pid}.port — per-process file (cleaned on exit)\n * - permission-server.port — latest port (convenience for scripts)\n */\n\nimport { createServer, type Server } from 'node:net';\nimport { homedir } from 'node:os';\nimport { join } from 'node:path';\nimport { mkdir, writeFile, unlink, readdir, readFile } from 'node:fs/promises';\nimport { env } from '../config/env.js';\nimport { logger } from '../utils/logger.js';\n\n/** Default maximum port attempts before giving up */\nconst DEFAULT_MAX_PORT_ATTEMPTS = 10;\n\n/** Directory for runtime state files (port discovery, PID files) */\nconst RUN_DIR = join(homedir(), '.dollhouse', 'run');\nconst LATEST_PORT_FILENAME = 'permission-server.port';\n\nfunction pidPortFilePath(dir: string = RUN_DIR, pid: number = process.pid): string {\n  return join(dir, `permission-server-${pid}.port`);\n}\n\nfunction latestPortFilePath(dir: string = RUN_DIR): string {\n  return join(dir, LATEST_PORT_FILENAME);\n}\n\n/** Track port file path for cleanup */\nlet portFilePath: string | null = null;\n\n/**\n * Attempt to bind to a single port. Returns the port if successful, null if in use.\n * Keeps the server listening to prevent TOCTOU race conditions — caller must\n * close the returned server after their own server binds.\n */\nfunction tryBindPort(port: number): Promise<{ port: number; server: Server } | null> {\n  return new Promise((resolve) => {\n    const server = createServer();\n    server.once('error', (err: NodeJS.ErrnoException) => {\n      if (err.code === 'EADDRINUSE') {\n        resolve(null);\n      } else {\n        resolve(null);\n        logger.debug(`[PortDiscovery] Unexpected error on port ${port}: ${err.code}`);\n      }\n    });\n    server.once('listening', () => {\n      resolve({ port, server });\n    });\n    server.listen(port, '127.0.0.1');\n  });\n}\n\n/**\n * Find an available port starting from the given port.\n *\n * Tries sequential ports, logging each attempt. Returns both the port number\n * and a held server to prevent TOCTOU race conditions. The caller should\n * close the held server after binding their own Express app to the port.\n *\n * @param startPort - Port to try first (see `DOLLHOUSE_WEB_CONSOLE_PORT` for the default)\n * @param maxAttempts - Maximum ports to try (default: 10, configurable via DOLLHOUSE_MAX_PORT_ATTEMPTS)\n * @returns Object with port number and held server, or throws if all attempts fail\n */\nexport async function findAvailablePort(\n  startPort: number,\n  maxAttempts: number = Number(process.env.DOLLHOUSE_MAX_PORT_ATTEMPTS) || DEFAULT_MAX_PORT_ATTEMPTS,\n): Promise<number> {\n  for (let attempt = 0; attempt < maxAttempts; attempt++) {\n    const port = startPort + attempt;\n    logger.debug(`[PortDiscovery] Trying port ${port} (attempt ${attempt + 1}/${maxAttempts})`);\n\n    const result = await tryBindPort(port);\n    if (result) {\n      // Close the probe server — there's a brief TOCTOU window here between\n      // closing and the caller binding, but it's negligible on localhost.\n      // A future improvement could return the server for the caller to adopt.\n      result.server.close();\n      if (attempt > 0) {\n        logger.info(`[PortDiscovery] Port ${startPort} in use, using ${port} (after ${attempt} skip${attempt > 1 ? 's' : ''})`);\n      }\n      return port;\n    }\n    logger.debug(`[PortDiscovery] Port ${port} in use, trying next`);\n  }\n\n  throw new Error(\n    `No available port found in range ${startPort}-${startPort + maxAttempts - 1} ` +\n    `after ${maxAttempts} attempts. Set DOLLHOUSE_MAX_PORT_ATTEMPTS to increase the range.`\n  );\n}\n\n/**\n * Write the active server port to a discoverable file.\n *\n * Creates two files:\n * - PID-keyed file for per-process cleanup\n * - Latest file for convenience (scripts can read this without knowing the PID)\n *\n * @param port - The port the web server is listening on\n * @returns Path to the PID-keyed port file\n */\nexport async function writePortFile(port: number): Promise<string> {\n  await mkdir(RUN_DIR, { recursive: true });\n  const pidFile = pidPortFilePath();\n  const latestFile = latestPortFilePath();\n  await writeFile(pidFile, String(port), 'utf-8');\n  await writeFile(latestFile, String(port), 'utf-8');\n  portFilePath = pidFile;\n  logger.debug(`[PortDiscovery] Port file written: ${pidFile}`);\n  return pidFile;\n}\n\n/**\n * Restore or update the shared latest port file for the active listener.\n *\n * Returns true when the file had to be written or updated, false when it\n * already matched the active port.\n */\nexport async function ensureLatestPortFile(port: number, customDir?: string): Promise<boolean> {\n  const dir = customDir || RUN_DIR;\n  const latestFile = latestPortFilePath(dir);\n  const desiredValue = String(port);\n\n  await mkdir(dir, { recursive: true });\n\n  try {\n    const existingValue = (await readFile(latestFile, 'utf-8')).trim();\n    if (existingValue === desiredValue) {\n      return false;\n    }\n  } catch {\n    // Missing/unreadable file — rewrite below.\n  }\n\n  await writeFile(latestFile, desiredValue, 'utf-8');\n  logger.debug(`[PortDiscovery] Shared latest port file refreshed: ${latestFile}`);\n  return true;\n}\n\n/**\n * Clean up port file on shutdown.\n */\nexport async function cleanupPortFile(): Promise<void> {\n  if (portFilePath) {\n    try { await unlink(portFilePath); } catch { /* already gone */ }\n  }\n}\n\n/**\n * Register process exit handlers to clean up port files.\n * Should be called once after the web server successfully starts.\n */\nexport function registerPortCleanup(): void {\n  const exitCleanup = () => { cleanupPortFile().catch(() => {}); };\n  process.once('exit', exitCleanup);\n  process.once('SIGTERM', exitCleanup);\n  process.once('SIGINT', exitCleanup);\n  process.once('SIGHUP', exitCleanup);\n}\n\n/**\n * Sweep stale port files from ~/.dollhouse/run/ on startup (#1856).\n *\n * Scans for permission-server-{pid}.port files and removes any whose PID\n * is no longer alive. This prevents unbounded accumulation of port files\n * from crashed or abandoned sessions.\n *\n * Note: This only removes metadata files, not processes or ports. The port\n * binding itself (in bindAndListen) is atomic via listen(). There is no race\n * between sweeping files and binding — they operate on independent resources.\n *\n * Safe to call on every startup — only removes files for dead processes.\n */\nexport async function sweepStalePortFiles(customDir?: string): Promise<number> {\n  try {\n    const dir = customDir || RUN_DIR;\n    await mkdir(dir, { recursive: true });\n    const files = await readdir(dir);\n    const PORT_FILE_RE = /^permission-server-(\\d+)\\.port$/;\n    let removed = 0;\n\n    for (const file of files) {\n      const match = PORT_FILE_RE.exec(file);\n      if (!match) continue;\n      const pid = Number(match[1]);\n\n      // Check if process is alive via signal-0.\n      // ESRCH = process doesn't exist (dead). EPERM = process exists but\n      // owned by another user (alive — don't touch their port file).\n      let alive = false;\n      try {\n        process.kill(pid, 0);\n        alive = true;\n      } catch (err: any) {\n        alive = err?.code === 'EPERM'; // EPERM = alive but different user\n      }\n\n      if (!alive) {\n        try {\n          await unlink(join(dir, file));\n          removed++;\n        } catch { /* already gone */ }\n      }\n    }\n\n    if (removed > 0) {\n      logger.info(`[PortDiscovery] Swept ${removed} stale port files from ${dir}`);\n    }\n    return removed;\n  } catch (err) {\n    logger.debug('[PortDiscovery] Stale port file sweep failed', {\n      error: err instanceof Error ? err.message : String(err),\n    });\n    return 0;\n  }\n}\n\n/**\n * Discover an available port, write discovery files, and register cleanup.\n *\n * This is the recommended entry point for Container startup. Combines\n * port discovery, file writing, and cleanup registration in one call.\n *\n * @param defaultPort - Port to try first (see `DOLLHOUSE_WEB_CONSOLE_PORT` for the default)\n * @returns The port the server should bind to, or undefined if discovery failed\n */\nexport async function discoverAndBindPort(\n  defaultPort: number = env.DOLLHOUSE_WEB_CONSOLE_PORT,\n): Promise<number | undefined> {\n  try {\n    const port = await findAvailablePort(defaultPort);\n\n    await writePortFile(port);\n    registerPortCleanup();\n\n    return port;\n  } catch (err) {\n    logger.warn('[PortDiscovery] Port discovery failed:', err);\n    return undefined;\n  }\n}\n"]}