@dollhousemcp/mcp-server 2.0.0-rc.6 → 2.0.1

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

@@ -0,0 +1,64 @@
+/**
+ * Unified web console orchestrator.
+ *
+ * Ties together leader election, console startup, follower wiring,
+ * and session lifecycle management. This is the main entry point
+ * called by the DI container during deferred setup.
+ *
+ * Flow:
+ * 1. Run leader election (read lock file, claim or follow)
+ * 2. If leader: start web server on fixed port, mount ingest routes, start heartbeat
+ * 3. If follower: register forwarding sinks with LogManager, start session heartbeat
+ *
+ * @since v2.1.0 — Issue #1700
+ */
+import type { UnifiedLogEntry } from '../../logging/types.js';
+import type { MetricSnapshot } from '../../metrics/types.js';
+import type { MemoryLogSink } from '../../logging/sinks/MemoryLogSink.js';
+import type { MemoryMetricsSink } from '../../metrics/sinks/MemoryMetricsSink.js';
+import { type ElectionResult } from './LeaderElection.js';
+/**
+ * Options for starting the unified console.
+ */
+export interface UnifiedConsoleOptions {
+    /** This process's unique session ID */
+    sessionId: string;
+    /** Portfolio base directory (for startWebServer) */
+    portfolioDir: string;
+    /** Log memory sink (for console history) */
+    memorySink: MemoryLogSink;
+    /** Metrics memory sink */
+    metricsSink?: MemoryMetricsSink;
+    /** MCP-AQL handler for permission routes (typed as any to avoid circular imports) */
+    mcpAqlHandler?: any;
+    /** Callback to register a log sink with the LogManager */
+    registerLogSink: (sink: {
+        write(entry: UnifiedLogEntry): void;
+        flush(): Promise<void>;
+        close(): Promise<void>;
+    }) => void;
+    /** Callback to wire SSE broadcasts after web server starts */
+    wireSSEBroadcasts: (webResult: {
+        logBroadcast?: (entry: UnifiedLogEntry) => void;
+        metricsOnSnapshot?: (snapshot: MetricSnapshot) => void;
+    }, metricsSink?: MemoryMetricsSink) => void;
+}
+/**
+ * Result of starting the unified console.
+ */
+export interface UnifiedConsoleResult {
+    role: 'leader' | 'follower';
+    election: ElectionResult;
+    /** Port the console is running on (leader only) */
+    port?: number;
+    /** Cleanup function to call on shutdown */
+    cleanup: () => Promise<void>;
+}
+/**
+ * Start the unified web console.
+ *
+ * Runs leader election, then either starts the full console (leader)
+ * or sets up event forwarding (follower).
+ */
+export declare function startUnifiedConsole(options: UnifiedConsoleOptions): Promise<UnifiedConsoleResult>;
+//# sourceMappingURL=UnifiedConsole.d.ts.map

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

@@ -0,0 +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;AAElF,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAU7B;;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;CACtL;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;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAQvG"}

package/dist/web/console/UnifiedConsole.js

@@ -0,0 +1,119 @@
+/**
+ * Unified web console orchestrator.
+ *
+ * Ties together leader election, console startup, follower wiring,
+ * and session lifecycle management. This is the main entry point
+ * called by the DI container during deferred setup.
+ *
+ * Flow:
+ * 1. Run leader election (read lock file, claim or follow)
+ * 2. If leader: start web server on fixed port, mount ingest routes, start heartbeat
+ * 3. If follower: register forwarding sinks with LogManager, start session heartbeat
+ *
+ * @since v2.1.0 — Issue #1700
+ */
+import { logger } from '../../utils/logger.js';
+import { electLeader, startHeartbeat, registerLeaderCleanup, } from './LeaderElection.js';
+import { createIngestRoutes } from './IngestRoutes.js';
+import { LeaderForwardingLogSink, SessionHeartbeat, } from './LeaderForwardingSink.js';
+/** Fixed port for the unified console leader */
+const CONSOLE_PORT = 3939;
+/**
+ * Start the unified web console.
+ *
+ * Runs leader election, then either starts the full console (leader)
+ * or sets up event forwarding (follower).
+ */
+export async function startUnifiedConsole(options) {
+    const election = await electLeader(options.sessionId, CONSOLE_PORT);
+    if (election.role === 'leader') {
+        return startAsLeader(options, election);
+    }
+    else {
+        return startAsFollower(options, election);
+    }
+}
+/**
+ * Start as the console leader.
+ * Binds port 3939, mounts all routes including ingestion, starts heartbeat.
+ */
+async function startAsLeader(options, election) {
+    const { startWebServer } = await import('../server.js');
+    // Pre-create a placeholder broadcast that we'll wire up after the server starts
+    let liveBroadcast;
+    let liveMetricsOnSnapshot;
+    // Create ingestion routes with a deferred broadcast (wired after server starts)
+    const ingestResult = createIngestRoutes({
+        logBroadcast: (entry) => liveBroadcast?.(entry),
+        metricsOnSnapshot: (snapshot) => liveMetricsOnSnapshot?.(snapshot),
+    });
+    // Register the leader as a session
+    ingestResult.registerLeaderSession(options.sessionId, process.pid);
+    // Start the web server with ingest routes mounted before the SPA fallback
+    const webResult = await startWebServer({
+        portfolioDir: options.portfolioDir,
+        memorySink: options.memorySink,
+        metricsSink: options.metricsSink,
+        port: CONSOLE_PORT,
+        additionalRouters: [ingestResult.router],
+        ...(options.mcpAqlHandler ? { mcpAqlHandler: options.mcpAqlHandler } : {}),
+    });
+    // Wire SSE broadcasts for this leader's own events
+    options.wireSSEBroadcasts(webResult, options.metricsSink);
+    // Now wire the live broadcast functions into the ingest routes
+    if (webResult.logBroadcast) {
+        const originalBroadcast = webResult.logBroadcast;
+        // Stamp leader's own entries with session ID
+        liveBroadcast = (entry) => {
+            const stamped = {
+                ...entry,
+                data: { ...entry.data, _sessionId: options.sessionId },
+            };
+            originalBroadcast(stamped);
+        };
+    }
+    liveMetricsOnSnapshot = webResult.metricsOnSnapshot;
+    logger.info('[UnifiedConsole] Ingestion routes mounted');
+    // Start heartbeat and register cleanup
+    const stopHeartbeat = startHeartbeat(election.leaderInfo);
+    registerLeaderCleanup();
+    logger.info('[UnifiedConsole] Leader started', {
+        sessionId: options.sessionId, port: CONSOLE_PORT, pid: process.pid,
+        role: 'leader', ingestRoutes: ['/api/ingest/logs', '/api/ingest/metrics', '/api/ingest/session', '/api/sessions'],
+    });
+    return {
+        role: 'leader',
+        election,
+        port: CONSOLE_PORT,
+        cleanup: async () => {
+            stopHeartbeat();
+        },
+    };
+}
+/**
+ * Start as a follower.
+ * Registers forwarding sinks with the LogManager, starts session heartbeat.
+ */
+async function startAsFollower(options, election) {
+    const leaderUrl = `http://127.0.0.1:${election.leaderInfo.port}`;
+    // Register a forwarding log sink
+    const forwardingSink = new LeaderForwardingLogSink(leaderUrl, options.sessionId);
+    options.registerLogSink(forwardingSink);
+    // Start session heartbeat to the leader
+    const sessionHeartbeat = new SessionHeartbeat(leaderUrl, options.sessionId, process.pid);
+    await sessionHeartbeat.start();
+    logger.info('[UnifiedConsole] Follower started', {
+        sessionId: options.sessionId, pid: process.pid, role: 'follower',
+        leaderSession: election.leaderInfo.sessionId, leaderPid: election.leaderInfo.pid,
+        leaderPort: election.leaderInfo.port, leaderUrl,
+    });
+    return {
+        role: 'follower',
+        election,
+        cleanup: async () => {
+            await sessionHeartbeat.stop();
+            await forwardingSink.close();
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UnifiedConsole.js","sourceRoot":"","sources":["../../../src/web/console/UnifiedConsole.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EACL,WAAW,EACX,cAAc,EACd,qBAAqB,GAEtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EACL,uBAAuB,EACvB,gBAAgB,GACjB,MAAM,2BAA2B,CAAC;AAEnC,gDAAgD;AAChD,MAAM,YAAY,GAAG,IAAI,CAAC;AAkC1B;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,OAA8B;IACtE,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,OAAO,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;IAEpE,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO,aAAa,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC1C,CAAC;SAAM,CAAC;QACN,OAAO,eAAe,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC5C,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,KAAK,UAAU,aAAa,CAC1B,OAA8B,EAC9B,QAAwB;IAExB,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,MAAM,CAAC,cAAc,CAAC,CAAC;IAExD,gFAAgF;IAChF,IAAI,aAA6D,CAAC;IAClE,IAAI,qBAAuE,CAAC;IAE5E,gFAAgF;IAChF,MAAM,YAAY,GAAG,kBAAkB,CAAC;QACtC,YAAY,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC;QAC/C,iBAAiB,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,qBAAqB,EAAE,CAAC,QAAQ,CAAC;KACnE,CAAC,CAAC;IAEH,mCAAmC;IACnC,YAAY,CAAC,qBAAqB,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IAEnE,0EAA0E;IAC1E,MAAM,SAAS,GAAG,MAAM,cAAc,CAAC;QACrC,YAAY,EAAE,OAAO,CAAC,YAAY;QAClC,UAAU,EAAE,OAAO,CAAC,UAAU;QAC9B,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,IAAI,EAAE,YAAY;QAClB,iBAAiB,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC;QACxC,GAAG,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC3E,CAAC,CAAC;IAEH,mDAAmD;IACnD,OAAO,CAAC,iBAAiB,CAAC,SAAS,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAE1D,+DAA+D;IAC/D,IAAI,SAAS,CAAC,YAAY,EAAE,CAAC;QAC3B,MAAM,iBAAiB,GAAG,SAAS,CAAC,YAAY,CAAC;QACjD,6CAA6C;QAC7C,aAAa,GAAG,CAAC,KAAsB,EAAE,EAAE;YACzC,MAAM,OAAO,GAAoB;gBAC/B,GAAG,KAAK;gBACR,IAAI,EAAE,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,SAAS,EAAE;aACvD,CAAC;YACF,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC,CAAC;IACJ,CAAC;IACD,qBAAqB,GAAG,SAAS,CAAC,iBAAiB,CAAC;IAEpD,MAAM,CAAC,IAAI,CAAC,2CAA2C,CAAC,CAAC;IAEzD,uCAAuC;IACvC,MAAM,aAAa,GAAG,cAAc,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC1D,qBAAqB,EAAE,CAAC;IAExB,MAAM,CAAC,IAAI,CAAC,iCAAiC,EAAE;QAC7C,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG;QAClE,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC,kBAAkB,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,eAAe,CAAC;KAClH,CAAC,CAAC;IAEH,OAAO;QACL,IAAI,EAAE,QAAQ;QACd,QAAQ;QACR,IAAI,EAAE,YAAY;QAClB,OAAO,EAAE,KAAK,IAAI,EAAE;YAClB,aAAa,EAAE,CAAC;QAClB,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,KAAK,UAAU,eAAe,CAC5B,OAA8B,EAC9B,QAAwB;IAExB,MAAM,SAAS,GAAG,oBAAoB,QAAQ,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;IAEjE,iCAAiC;IACjC,MAAM,cAAc,GAAG,IAAI,uBAAuB,CAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACjF,OAAO,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC;IAExC,wCAAwC;IACxC,MAAM,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IACzF,MAAM,gBAAgB,CAAC,KAAK,EAAE,CAAC;IAE/B,MAAM,CAAC,IAAI,CAAC,mCAAmC,EAAE;QAC/C,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,UAAU;QAChE,aAAa,EAAE,QAAQ,CAAC,UAAU,CAAC,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG;QAChF,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,IAAI,EAAE,SAAS;KAChD,CAAC,CAAC;IAEH,OAAO;QACL,IAAI,EAAE,UAAU;QAChB,QAAQ;QACR,OAAO,EAAE,KAAK,IAAI,EAAE;YAClB,MAAM,gBAAgB,CAAC,IAAI,EAAE,CAAC;YAC9B,MAAM,cAAc,CAAC,KAAK,EAAE,CAAC;QAC/B,CAAC;KACF,CAAC;AACJ,CAAC","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  startHeartbeat,\n  registerLeaderCleanup,\n  type ElectionResult,\n} from './LeaderElection.js';\nimport { createIngestRoutes } from './IngestRoutes.js';\nimport {\n  LeaderForwardingLogSink,\n  SessionHeartbeat,\n} from './LeaderForwardingSink.js';\n\n/** Fixed port for the unified console leader */\nconst CONSOLE_PORT = 3939;\n\n/**\n * Options for starting the unified console.\n */\nexport interface UnifiedConsoleOptions {\n  /** This process's unique session ID */\n  sessionId: string;\n  /** Portfolio base directory (for startWebServer) */\n  portfolioDir: string;\n  /** Log memory sink (for console history) */\n  memorySink: MemoryLogSink;\n  /** Metrics memory sink */\n  metricsSink?: MemoryMetricsSink;\n  /** MCP-AQL handler for permission routes (typed as any to avoid circular imports) */\n  mcpAqlHandler?: any;\n  /** Callback to register a log sink with the LogManager */\n  registerLogSink: (sink: { write(entry: UnifiedLogEntry): void; flush(): Promise<void>; close(): Promise<void> }) => void;\n  /** Callback to wire SSE broadcasts after web server starts */\n  wireSSEBroadcasts: (webResult: { logBroadcast?: (entry: UnifiedLogEntry) => void; metricsOnSnapshot?: (snapshot: MetricSnapshot) => void }, metricsSink?: MemoryMetricsSink) => void;\n}\n\n/**\n * Result of starting the unified console.\n */\nexport interface UnifiedConsoleResult {\n  role: 'leader' | 'follower';\n  election: ElectionResult;\n  /** Port the console is running on (leader only) */\n  port?: number;\n  /** Cleanup function to call on shutdown */\n  cleanup: () => Promise<void>;\n}\n\n/**\n * Start the unified web console.\n *\n * Runs leader election, then either starts the full console (leader)\n * or sets up event forwarding (follower).\n */\nexport async function startUnifiedConsole(options: UnifiedConsoleOptions): Promise<UnifiedConsoleResult> {\n  const election = await electLeader(options.sessionId, CONSOLE_PORT);\n\n  if (election.role === 'leader') {\n    return startAsLeader(options, election);\n  } else {\n    return startAsFollower(options, election);\n  }\n}\n\n/**\n * Start as the console leader.\n * Binds port 3939, mounts all routes including ingestion, starts heartbeat.\n */\nasync function startAsLeader(\n  options: UnifiedConsoleOptions,\n  election: ElectionResult,\n): Promise<UnifiedConsoleResult> {\n  const { startWebServer } = await import('../server.js');\n\n  // Pre-create a placeholder broadcast that we'll wire up after the server starts\n  let liveBroadcast: ((entry: UnifiedLogEntry) => void) | undefined;\n  let liveMetricsOnSnapshot: ((snapshot: MetricSnapshot) => void) | undefined;\n\n  // Create ingestion routes with a deferred broadcast (wired after server starts)\n  const ingestResult = createIngestRoutes({\n    logBroadcast: (entry) => liveBroadcast?.(entry),\n    metricsOnSnapshot: (snapshot) => liveMetricsOnSnapshot?.(snapshot),\n  });\n\n  // Register the leader as a session\n  ingestResult.registerLeaderSession(options.sessionId, process.pid);\n\n  // Start the web server with ingest routes mounted before the SPA fallback\n  const webResult = await startWebServer({\n    portfolioDir: options.portfolioDir,\n    memorySink: options.memorySink,\n    metricsSink: options.metricsSink,\n    port: CONSOLE_PORT,\n    additionalRouters: [ingestResult.router],\n    ...(options.mcpAqlHandler ? { mcpAqlHandler: options.mcpAqlHandler } : {}),\n  });\n\n  // Wire SSE broadcasts for this leader's own events\n  options.wireSSEBroadcasts(webResult, options.metricsSink);\n\n  // Now wire the live broadcast functions into the ingest routes\n  if (webResult.logBroadcast) {\n    const originalBroadcast = webResult.logBroadcast;\n    // Stamp leader's own entries with session ID\n    liveBroadcast = (entry: UnifiedLogEntry) => {\n      const stamped: UnifiedLogEntry = {\n        ...entry,\n        data: { ...entry.data, _sessionId: options.sessionId },\n      };\n      originalBroadcast(stamped);\n    };\n  }\n  liveMetricsOnSnapshot = webResult.metricsOnSnapshot;\n\n  logger.info('[UnifiedConsole] Ingestion routes mounted');\n\n  // Start heartbeat and register cleanup\n  const stopHeartbeat = startHeartbeat(election.leaderInfo);\n  registerLeaderCleanup();\n\n  logger.info('[UnifiedConsole] Leader started', {\n    sessionId: options.sessionId, port: CONSOLE_PORT, pid: process.pid,\n    role: 'leader', ingestRoutes: ['/api/ingest/logs', '/api/ingest/metrics', '/api/ingest/session', '/api/sessions'],\n  });\n\n  return {\n    role: 'leader',\n    election,\n    port: CONSOLE_PORT,\n    cleanup: async () => {\n      stopHeartbeat();\n    },\n  };\n}\n\n/**\n * Start as a follower.\n * Registers forwarding sinks with the LogManager, starts session heartbeat.\n */\nasync function startAsFollower(\n  options: UnifiedConsoleOptions,\n  election: ElectionResult,\n): Promise<UnifiedConsoleResult> {\n  const leaderUrl = `http://127.0.0.1:${election.leaderInfo.port}`;\n\n  // Register a forwarding log sink\n  const forwardingSink = new LeaderForwardingLogSink(leaderUrl, options.sessionId);\n  options.registerLogSink(forwardingSink);\n\n  // Start session heartbeat to the leader\n  const sessionHeartbeat = new SessionHeartbeat(leaderUrl, options.sessionId, process.pid);\n  await sessionHeartbeat.start();\n\n  logger.info('[UnifiedConsole] Follower started', {\n    sessionId: options.sessionId, pid: process.pid, role: 'follower',\n    leaderSession: election.leaderInfo.sessionId, leaderPid: election.leaderInfo.pid,\n    leaderPort: election.leaderInfo.port, leaderUrl,\n  });\n\n  return {\n    role: 'follower',\n    election,\n    cleanup: async () => {\n      await sessionHeartbeat.stop();\n      await forwardingSink.close();\n    },\n  };\n}\n"]}

package/dist/web/contentPipeline.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Content Validation Pipeline for Web UI
+ *
+ * Composes the standalone security validators into a single pipeline
+ * for validating portfolio element content before serving to the browser.
+ *
+ * Uses the same validators as the MCPAQLHandler but without coupling
+ * to the handler's operation dispatch. This is the extraction point
+ * for the upcoming MCPAQLHandler decomposition.
+ *
+ * auto-dollhouse#5 / upstream #1679
+ * DMCP-SEC-004 compliant: uses UnicodeValidator.normalize() on all inputs
+ */
+/** Known metadata fields extracted from YAML frontmatter for web display */
+export interface ElementDisplayMetadata {
+    name?: string;
+    description?: string;
+    version?: string;
+    author?: string;
+    category?: string;
+    created?: string;
+    created_date?: string;
+    modified?: string;
+    tags?: string[];
+    license?: string;
+    age_rating?: string;
+    triggers?: string[];
+    instructions?: string;
+    coordination_strategy?: string;
+    use_cases?: string[];
+    proficiency_levels?: Record<string, string>;
+    gatekeeper?: Record<string, unknown>;
+    goal?: Record<string, unknown>;
+    autonomy?: Record<string, unknown>;
+    memoryType?: string;
+    [key: string]: unknown;
+}
+export interface PipelineResult {
+    valid: boolean;
+    content: string;
+    metadata: ElementDisplayMetadata;
+    body: string;
+    rejection?: {
+        reason: string;
+        severity?: string;
+        patterns?: string[];
+    };
+}
+/**
+ * Validate element content through the security pipeline.
+ *
+ * @param filename - The element filename (e.g., "alex-sterling.md")
+ * @param rawContent - The raw file content string
+ * @param elementType - The plural element type directory (e.g., "personas")
+ * @returns Validated content with parsed metadata, or rejection with reason
+ */
+export declare function validateElementContent(filename: string, rawContent: string, elementType: string): PipelineResult;
+//# sourceMappingURL=contentPipeline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contentPipeline.d.ts","sourceRoot":"","sources":["../../src/web/contentPipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAiBH,4EAA4E;AAC5E,MAAM,WAAW,sBAAsB;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,sBAAsB,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE;QACV,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CACH;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GAClB,cAAc,CAgFhB"}

package/dist/web/contentPipeline.js

@@ -0,0 +1,112 @@
+/**
+ * Content Validation Pipeline for Web UI
+ *
+ * Composes the standalone security validators into a single pipeline
+ * for validating portfolio element content before serving to the browser.
+ *
+ * Uses the same validators as the MCPAQLHandler but without coupling
+ * to the handler's operation dispatch. This is the extraction point
+ * for the upcoming MCPAQLHandler decomposition.
+ *
+ * auto-dollhouse#5 / upstream #1679
+ * DMCP-SEC-004 compliant: uses UnicodeValidator.normalize() on all inputs
+ */
+import { extname } from 'node:path';
+import { SecureYamlParser } from '../security/secureYamlParser.js';
+import { ContentValidator } from '../security/contentValidator.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { logger } from '../utils/logger.js';
+/** Element types that map to content validation contexts */
+const TYPE_TO_CONTEXT = {
+    personas: 'persona',
+    skills: 'skill',
+    templates: 'template',
+    agents: 'agent',
+    memories: 'memory',
+};
+/**
+ * Validate element content through the security pipeline.
+ *
+ * @param filename - The element filename (e.g., "alex-sterling.md")
+ * @param rawContent - The raw file content string
+ * @param elementType - The plural element type directory (e.g., "personas")
+ * @returns Validated content with parsed metadata, or rejection with reason
+ */
+export function validateElementContent(filename, rawContent, elementType) {
+    // DMCP-SEC-004: Normalize all inputs via UnicodeValidator to prevent
+    // homograph attacks, direction override bypasses, and suspicious patterns.
+    const filenameValidation = UnicodeValidator.normalize(filename);
+    const contentValidation = UnicodeValidator.normalize(rawContent);
+    const normalizedFilename = filenameValidation.normalizedContent;
+    const normalizedContent = contentValidation.normalizedContent;
+    const normalizedType = elementType.normalize('NFC');
+    const ext = extname(normalizedFilename);
+    const isYaml = ext === '.yaml' || ext === '.yml';
+    const contentContext = TYPE_TO_CONTEXT[normalizedType];
+    // Step 1: Parse and validate structure (YAML bomb detection, circular refs)
+    let metadata = {};
+    let body = '';
+    try {
+        if (isYaml) {
+            // Pure YAML file (memories) — use parseRawYaml for structural validation
+            // (bomb detection, circular refs, size limits).
+            // Skip ContentValidator.validateYamlContent() — it produces false positives
+            // on memory content that legitimately contains code patterns, security
+            // keywords, and technical documentation. Memories are locally-generated
+            // trusted content, not untrusted external submissions.
+            const parsed = SecureYamlParser.parseRawYaml(normalizedContent);
+            metadata = (typeof parsed === 'object' && parsed !== null) ? parsed : {};
+        }
+        else {
+            // Markdown with YAML frontmatter
+            const parsed = SecureYamlParser.parse(normalizedContent, { contentContext });
+            metadata = parsed.data;
+            body = parsed.content;
+        }
+    }
+    catch (err) {
+        return {
+            valid: false,
+            content: normalizedContent,
+            metadata: {},
+            body: '',
+            rejection: { reason: `Parse validation failed: ${err.message}`, severity: 'high' },
+        };
+    }
+    // Step 2: Content injection pattern detection (markdown elements only)
+    // YAML memories skip this — they contain legitimate code patterns and
+    // technical content that triggers false positives. The structural YAML
+    // parsing above (bomb/circular ref detection) is sufficient for local content.
+    if (!isYaml) {
+        const validation = ContentValidator.validateAndSanitize(normalizedContent, {
+            contentContext,
+        });
+        if (!validation.isValid) {
+            logger.warn('[ContentPipeline] Content rejected', {
+                filename,
+                elementType,
+                patterns: validation.detectedPatterns,
+                severity: validation.severity,
+            });
+            return {
+                valid: false,
+                content: normalizedContent,
+                metadata,
+                body,
+                rejection: {
+                    reason: 'Content failed security validation',
+                    severity: validation.severity,
+                    patterns: validation.detectedPatterns,
+                },
+            };
+        }
+    }
+    // Step 3: Return validated content
+    return {
+        valid: true,
+        content: rawContent,
+        metadata,
+        body,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contentPipeline.js","sourceRoot":"","sources":["../../src/web/contentPipeline.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Content Validation Pipeline for Web UI\n *\n * Composes the standalone security validators into a single pipeline\n * for validating portfolio element content before serving to the browser.\n *\n * Uses the same validators as the MCPAQLHandler but without coupling\n * to the handler's operation dispatch. This is the extraction point\n * for the upcoming MCPAQLHandler decomposition.\n *\n * auto-dollhouse#5 / upstream #1679\n * DMCP-SEC-004 compliant: uses UnicodeValidator.normalize() on all inputs\n */\n\nimport { extname } from 'node:path';\nimport { SecureYamlParser } from '../security/secureYamlParser.js';\nimport { ContentValidator, type ContentValidationResult } from '../security/contentValidator.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { logger } from '../utils/logger.js';\n\n/** Element types that map to content validation contexts */\nconst TYPE_TO_CONTEXT: Record<string, 'persona' | 'skill' | 'template' | 'agent' | 'memory'> = {\n  personas: 'persona',\n  skills: 'skill',\n  templates: 'template',\n  agents: 'agent',\n  memories: 'memory',\n};\n\n/** Known metadata fields extracted from YAML frontmatter for web display */\nexport interface ElementDisplayMetadata {\n  name?: string;\n  description?: string;\n  version?: string;\n  author?: string;\n  category?: string;\n  created?: string;\n  created_date?: string;\n  modified?: string;\n  tags?: string[];\n  license?: string;\n  age_rating?: string;\n  triggers?: string[];\n  instructions?: string;\n  coordination_strategy?: string;\n  use_cases?: string[];\n  proficiency_levels?: Record<string, string>;\n  gatekeeper?: Record<string, unknown>;\n  goal?: Record<string, unknown>;\n  autonomy?: Record<string, unknown>;\n  memoryType?: string;\n  [key: string]: unknown;\n}\n\nexport interface PipelineResult {\n  valid: boolean;\n  content: string;\n  metadata: ElementDisplayMetadata;\n  body: string;\n  rejection?: {\n    reason: string;\n    severity?: string;\n    patterns?: string[];\n  };\n}\n\n/**\n * Validate element content through the security pipeline.\n *\n * @param filename - The element filename (e.g., \"alex-sterling.md\")\n * @param rawContent - The raw file content string\n * @param elementType - The plural element type directory (e.g., \"personas\")\n * @returns Validated content with parsed metadata, or rejection with reason\n */\nexport function validateElementContent(\n  filename: string,\n  rawContent: string,\n  elementType: string,\n): PipelineResult {\n  // DMCP-SEC-004: Normalize all inputs via UnicodeValidator to prevent\n  // homograph attacks, direction override bypasses, and suspicious patterns.\n  const filenameValidation = UnicodeValidator.normalize(filename);\n  const contentValidation = UnicodeValidator.normalize(rawContent);\n  const normalizedFilename = filenameValidation.normalizedContent;\n  const normalizedContent = contentValidation.normalizedContent;\n  const normalizedType = elementType.normalize('NFC');\n\n  const ext = extname(normalizedFilename);\n  const isYaml = ext === '.yaml' || ext === '.yml';\n  const contentContext = TYPE_TO_CONTEXT[normalizedType];\n\n  // Step 1: Parse and validate structure (YAML bomb detection, circular refs)\n  let metadata: ElementDisplayMetadata = {};\n  let body = '';\n\n  try {\n    if (isYaml) {\n      // Pure YAML file (memories) — use parseRawYaml for structural validation\n      // (bomb detection, circular refs, size limits).\n      // Skip ContentValidator.validateYamlContent() — it produces false positives\n      // on memory content that legitimately contains code patterns, security\n      // keywords, and technical documentation. Memories are locally-generated\n      // trusted content, not untrusted external submissions.\n      const parsed = SecureYamlParser.parseRawYaml(normalizedContent);\n      metadata = (typeof parsed === 'object' && parsed !== null) ? parsed : {};\n    } else {\n      // Markdown with YAML frontmatter\n      const parsed = SecureYamlParser.parse(normalizedContent, { contentContext });\n      metadata = parsed.data;\n      body = parsed.content;\n    }\n  } catch (err) {\n    return {\n      valid: false,\n      content: normalizedContent,\n      metadata: {},\n      body: '',\n      rejection: { reason: `Parse validation failed: ${(err as Error).message}`, severity: 'high' },\n    };\n  }\n\n  // Step 2: Content injection pattern detection (markdown elements only)\n  // YAML memories skip this — they contain legitimate code patterns and\n  // technical content that triggers false positives. The structural YAML\n  // parsing above (bomb/circular ref detection) is sufficient for local content.\n  if (!isYaml) {\n    const validation: ContentValidationResult = ContentValidator.validateAndSanitize(normalizedContent, {\n      contentContext,\n    });\n\n    if (!validation.isValid) {\n      logger.warn('[ContentPipeline] Content rejected', {\n        filename,\n        elementType,\n        patterns: validation.detectedPatterns,\n        severity: validation.severity,\n      });\n      return {\n        valid: false,\n        content: normalizedContent,\n        metadata,\n        body,\n        rejection: {\n          reason: 'Content failed security validation',\n          severity: validation.severity,\n          patterns: validation.detectedPatterns,\n        },\n      };\n    }\n  }\n\n  // Step 3: Return validated content\n  return {\n    valid: true,\n    content: rawContent,\n    metadata,\n    body,\n  };\n}\n"]}

package/dist/web/portDiscovery.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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 default (3939)
+ * 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)
+ */
+/**
+ * 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 (default: 3939)
+ * @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 declare function findAvailablePort(startPort: number, maxAttempts?: number): Promise<number>;
+/**
+ * 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 declare function writePortFile(port: number): Promise<string>;
+/**
+ * Clean up port file on shutdown.
+ */
+export declare function cleanupPortFile(): Promise<void>;
+/**
+ * Register process exit handlers to clean up port files.
+ * Should be called once after the web server successfully starts.
+ */
+export declare function registerPortCleanup(): void;
+/**
+ * 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 (default: 3939)
+ * @returns The port the server should bind to, or undefined if discovery failed
+ */
+export declare function discoverAndBindPort(defaultPort?: number): Promise<number | undefined>;
+//# sourceMappingURL=portDiscovery.d.ts.map

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

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

package/dist/web/portDiscovery.js

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