@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.
355 lines • 51.6 kB
JavaScript
/**
* Stale process detection and recovery (#1850).
*
* Finds and kills zombie DollhouseMCP processes that squat on the console
* port after their session has ended. Used by bindAndListen in server.ts
* when EADDRINUSE occurs.
*
* Extracted to a standalone module so it can be tested without importing
* the full Express server and its dependency chain.
*/
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) */
const COMMAND_TIMEOUT_MS = 1000;
/** Polling interval when waiting for SIGTERM to take effect (ms) */
const SIGTERM_POLL_MS = 300;
/** Number of polls before escalating to SIGKILL */
const KILL_POLL_COUNT = 10;
/** Wait after SIGKILL before returning (ms) */
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) {
try {
_logger = (await import('../../utils/logger.js')).logger;
}
catch { /* fallback below */ }
}
return _logger;
}
const logger = {
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, options = {}) {
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 (!options.allowActiveHostParent && 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.
*
* Timeout: 1s — lsof on localhost is typically <100ms. The 1s ceiling
* handles slow NFS-mounted /dev/fd or overloaded CI runners without
* delaying startup noticeably.
*/
export async function findPidOnPort(port) {
const { execFile: execFileCb } = await import('node:child_process');
const { promisify } = await import('node:util');
const execFileAsync = promisify(execFileCb);
// Query only LISTEN sockets so established client connections to the console
// don't get mistaken for the owning leader process.
for (const cmd of [
{ bin: 'lsof', args: ['-nP', '-iTCP:' + String(port), '-sTCP:LISTEN', '-t'] },
{ bin: 'ss', args: ['-ltnp', `sport = :${port}`] },
{ bin: 'fuser', args: ['-n', 'tcp', String(port)] },
]) {
try {
const { stdout, stderr } = await execFileAsync(cmd.bin, cmd.args, { timeout: COMMAND_TIMEOUT_MS });
const output = (stdout || stderr || '').trim();
if (!output) {
continue;
}
let pids = [];
if (cmd.bin === 'ss') {
pids = output
.split('\n')
.flatMap((line) => Array.from(line.matchAll(/pid=(\d+)/g), (match) => parsePidToken(match[1])))
.filter((pid) => pid !== null);
}
else {
// fuser outputs to stderr on some systems; lsof emits one PID per line.
pids = output
.split(/\s+/)
.map((token) => parsePidToken(token))
.filter((pid) => pid !== null);
}
const otherPid = pids.find(p => p !== process.pid);
if (otherPid)
return otherPid;
}
catch {
continue; // command not found or no results — try next
}
}
return null;
}
/**
* Kill a stale process holding a port. Sends SIGTERM, waits briefly,
* then SIGKILL if still alive. Only kills DollhouseMCP processes
* (verified by checking the command line and user ownership).
*
* Timeout: 1s for ps verification. Kill wait: 300ms × 10 polls = 3s
* before escalating to SIGKILL. Total worst case: ~4s.
*/
export async function killStaleProcess(pid, port) {
const outcome = await killStaleProcessDetailed(pid, port);
return outcome.killed;
}
export async function killStaleProcessDetailed(pid, port, options = {}) {
const processInfo = await inspectProcess(pid);
if (!processInfo) {
await logger.debug(`[WebUI] Cannot verify process ${pid} — skipping kill`);
return { killed: false, reason: 'inspect_failed', pid };
}
const guardFailure = await getKillGuardFailure(processInfo, port, options);
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 {
return await terminateProcess(processInfo, port, parentCommand);
}
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));
}
}
/**
* Detect and recover from a stale process squatting on the port.
* Compares the port holder's PID against the leader lock file to determine
* if it's a squatter. Returns true if the squatter was killed.
*
* Timeouts: lsof 1s, ps 1s, SIGTERM wait 3s — max ~5s total.
*/
export async function recoverStalePort(port) {
const stalePid = await findPidOnPort(port);
if (!stalePid)
return false;
// TOCTOU mitigation: a new process may have just bound the port but not yet
// 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 < LOCK_RECHECK_ATTEMPTS; check++) {
try {
const lock = await readLeaderLock();
if (lock?.pid === stalePid && lock?.port === port && lock.pid !== process.pid) {
await logger.warn(`[WebUI] Port ${port} held by legitimate leader (pid ${stalePid}) — not killing`);
return false;
}
}
catch {
// Can't read lock file — continue to next check or kill
}
if (check < LOCK_RECHECK_ATTEMPTS - 1) {
await new Promise(r => setTimeout(r, LOCK_RECHECK_DELAY_MS));
}
}
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
}
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\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 interface KillStaleProcessOptions {\n  allowActiveHostParent?: boolean;\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  options: KillStaleProcessOptions = {},\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 (!options.allowActiveHostParent && 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  // Query only LISTEN sockets so established client connections to the console\n  // don't get mistaken for the owning leader process.\n  for (const cmd of [\n    { bin: 'lsof', args: ['-nP', '-iTCP:' + String(port), '-sTCP:LISTEN', '-t'] },\n    { bin: 'ss', args: ['-ltnp', `sport = :${port}`] },\n    { bin: 'fuser', args: ['-n', 'tcp', String(port)] },\n  ]) {\n    try {\n      const { stdout, stderr } = await execFileAsync(cmd.bin, cmd.args, { timeout: COMMAND_TIMEOUT_MS });\n      const output = (stdout || stderr || '').trim();\n      if (!output) {\n        continue;\n      }\n\n      let pids: number[] = [];\n      if (cmd.bin === 'ss') {\n        pids = output\n          .split('\\n')\n          .flatMap((line) => Array.from(line.matchAll(/pid=(\\d+)/g), (match) => parsePidToken(match[1])))\n          .filter((pid): pid is number => pid !== null);\n      } else {\n        // fuser outputs to stderr on some systems; lsof emits one PID per line.\n        pids = output\n          .split(/\\s+/)\n          .map((token) => parsePidToken(token))\n          .filter((pid): pid is number => pid !== null);\n      }\n\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(\n  pid: number,\n  port: number,\n  options: KillStaleProcessOptions = {},\n): 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, options);\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 l