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

package/dist/web/server.d.ts

@@ -11,6 +11,8 @@
  * @see https://github.com/DollhouseMCP/mcp-server-v2-refactor/issues/774
  */
 import type { MCPAQLHandler } from '../handlers/mcp-aql/MCPAQLHandler.js';
+import type { MemoryLogSink } from '../logging/sinks/MemoryLogSink.js';
+import type { MemoryMetricsSink } from '../metrics/sinks/MemoryMetricsSink.js';
 /**
  * Options for starting the web server.
  */
@@ -28,6 +30,23 @@ export interface WebServerOptions {
      * Issue #796: Web MCP-AQL Gateway.
      */
     mcpAqlHandler?: MCPAQLHandler;
+    /** MemoryLogSink for log routes (optional — logs tab disabled if not provided) */
+    memorySink?: MemoryLogSink;
+    /** MemoryMetricsSink for metrics routes (optional — metrics tab disabled if not provided) */
+    metricsSink?: MemoryMetricsSink;
+    /** Additional routers to mount before the SPA fallback (e.g., ingest routes) */
+    additionalRouters?: import('express').Router[];
+}
+/**
+ * Result of starting the web server, including hooks for DI wiring.
+ */
+export interface WebServerResult {
+    /** Express app instance — for mounting additional routes (e.g., ingest routes) */
+    app?: import('express').Express;
+    /** Log broadcast function — call with each entry to push to SSE clients */
+    logBroadcast?: (entry: import('../logging/types.js').UnifiedLogEntry) => void;
+    /** Metrics snapshot function — call with each snapshot to push to SSE clients */
+    metricsOnSnapshot?: (snapshot: import('../metrics/types.js').MetricSnapshot) => void;
 }
 /**
  * Result of attempting to open the browser.
@@ -52,8 +71,9 @@ export interface BrowserOpenResult {
  * browser without starting a second instance.
  *
  * @param options - Server configuration
+ * @returns Hooks for DI wiring (log broadcast, metrics onSnapshot)
  */
-export declare function startWebServer(options: WebServerOptions): Promise<void>;
+export declare function startWebServer(options: WebServerOptions): Promise<WebServerResult>;
 /**
  * Open the portfolio browser from within the MCP server process.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/web/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAUH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAW1E;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,YAAY,EAAE,MAAM,CAAC;IACrB,qEAAqE;IACrE,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,4EAA4E;IAC5E,cAAc,EAAE,OAAO,CAAC;IACxB,kDAAkD;IAClD,aAAa,EAAE,OAAO,CAAC;IACvB,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAqCD;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8F7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAwBzI"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/web/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAaH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAW/E;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,YAAY,EAAE,MAAM,CAAC;IACrB,qEAAqE;IACrE,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,kFAAkF;IAClF,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,6FAA6F;IAC7F,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,gFAAgF;IAChF,iBAAiB,CAAC,EAAE,OAAO,SAAS,EAAE,MAAM,EAAE,CAAC;CAChD;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,kFAAkF;IAClF,GAAG,CAAC,EAAE,OAAO,SAAS,EAAE,OAAO,CAAC;IAChC,2EAA2E;IAC3E,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,qBAAqB,EAAE,eAAe,KAAK,IAAI,CAAC;IAC9E,iFAAiF;IACjF,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,qBAAqB,EAAE,cAAc,KAAK,IAAI,CAAC;CACtF;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,4EAA4E;IAC5E,cAAc,EAAE,OAAO,CAAC;IACxB,kDAAkD;IAClD,aAAa,EAAE,OAAO,CAAC;IACvB,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAqCD;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAwIxF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAwBzI"}

package/dist/web/server.js

@@ -17,6 +17,9 @@ import { execFile } from 'node:child_process';
 import { platform } from 'node:os';
 import { mkdir, readdir } from 'node:fs/promises';
 import { createApiRoutes, createGatewayApiRoutes } from './routes.js';
+import { createLogRoutes } from './routes/logRoutes.js';
+import { createMetricsRoutes } from './routes/metricsRoutes.js';
+import { createHealthRoutes } from './routes/healthRoutes.js';
 import { logger } from '../utils/logger.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const DEFAULT_PORT = 3939;
@@ -69,16 +72,19 @@ function openInBrowser(url) {
  * browser without starting a second instance.
  *
  * @param options - Server configuration
+ * @returns Hooks for DI wiring (log broadcast, metrics onSnapshot)
  */
 export async function startWebServer(options) {
     const port = options.port || DEFAULT_PORT;
+    const result = {};
     if (serverRunning) {
         if (options.openBrowser) {
             openInBrowser(`http://${CONSOLE_HOST}:${serverPort}`);
         }
-        return;
+        return result;
     }
     const app = express();
+    result.app = app;
     app.disable('x-powered-by');
     // Security headers
     app.use((_req, res, next) => {
@@ -90,7 +96,7 @@ export async function startWebServer(options) {
         res.setHeader('Content-Security-Policy', [
             "default-src 'self'",
             "script-src 'self' cdn.jsdelivr.net cdnjs.cloudflare.com",
-            "style-src 'self' 'unsafe-inline' cdnjs.cloudflare.com",
+            "style-src 'self' 'unsafe-inline' cdnjs.cloudflare.com cdn.jsdelivr.net",
             "connect-src 'self' raw.githubusercontent.com",
             "font-src 'self'",
         ].join('; '));
@@ -99,12 +105,41 @@ export async function startWebServer(options) {
     // API routes — use MCP-AQL gateway when handler is available (Issue #796)
     if (options.mcpAqlHandler) {
         app.use('/api', createGatewayApiRoutes(options.mcpAqlHandler, options.portfolioDir));
-        logger.info('[WebUI] API routes using MCP-AQL Gateway (validated, cached, gatekeeper-checked)');
+        // Permission evaluation routes (POST /evaluate_permission, GET /permissions/status)
+        const { registerPermissionRoutes } = await import('./routes/permissionRoutes.js');
+        const permRouter = (await import('express')).Router();
+        registerPermissionRoutes(permRouter, options.mcpAqlHandler);
+        app.use('/api', permRouter);
+        logger.info('[WebUI] API routes using MCP-AQL Gateway + permission routes');
     }
     else {
         app.use('/api', createApiRoutes(options.portfolioDir));
         logger.warn('[WebUI] API routes using direct filesystem access (no MCP-AQL handler available)');
     }
+    // Console routes: logs, metrics, health
+    let logRoutes;
+    let metricsRoutes;
+    if (options.memorySink) {
+        logRoutes = createLogRoutes(options.memorySink);
+        app.use('/api', logRoutes.router);
+        result.logBroadcast = logRoutes.broadcast;
+        logger.info('[WebUI] Log viewer routes mounted at /api/logs');
+    }
+    if (options.metricsSink) {
+        metricsRoutes = createMetricsRoutes(options.metricsSink);
+        app.use('/api', metricsRoutes.router);
+        result.metricsOnSnapshot = metricsRoutes.onSnapshot;
+        logger.info('[WebUI] Metrics routes mounted at /api/metrics');
+    }
+    if (options.memorySink) {
+        const healthRouter = createHealthRoutes({
+            memorySink: options.memorySink,
+            metricsSink: options.metricsSink,
+            logClientCount: logRoutes ? logRoutes.clientCount : () => 0,
+            metricsClientCount: metricsRoutes ? metricsRoutes.clientCount : () => 0,
+        });
+        app.use('/api', healthRouter);
+    }
     // Serve ~/.dollhouse/pages/ at /pages/ — dashboards, generated content, stack views
     const pagesDir = join(dirname(options.portfolioDir), 'pages');
     mkdir(pagesDir, { recursive: true }).catch(err => {
@@ -128,6 +163,8 @@ export async function startWebServer(options) {
             res.json({ pages: [], directory: pagesDir });
         }
     });
+    // Additional routers (e.g., unified console ingest routes) — must mount before SPA fallback
+    options.additionalRouters?.forEach(router => app.use(router));
     // Static frontend files
     const publicDir = join(__dirname, 'public');
     app.use(express.static(publicDir));
@@ -156,6 +193,7 @@ export async function startWebServer(options) {
             openInBrowser(url);
         }
     });
+    return result;
 }
 /**
  * Open the portfolio browser from within the MCP server process.
@@ -192,4 +230,4 @@ export async function openPortfolioBrowser(portfolioDir, port, mcpAqlHandler) {
         ...(browserResult.error ? { warning: `Browser could not be opened automatically: ${browserResult.error}. Open ${url} manually.` } : {}),
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/web/server.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * DollhouseMCP Web UI Server\n *\n * Lightweight Express server for browsing portfolio elements in a browser.\n * Bound to 127.0.0.1 only (localhost). Read-only for V1.\n *\n * Can be started standalone (`--web` flag) or from within the MCP server\n * process via `openPortfolioBrowser()`.\n *\n * @see https://github.com/DollhouseMCP/mcp-server-v2-refactor/issues/704\n * @see https://github.com/DollhouseMCP/mcp-server-v2-refactor/issues/774\n */\n\nimport express from 'express';\nimport { join, dirname, extname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { execFile } from 'node:child_process';\nimport { platform } from 'node:os';\nimport { mkdir, readdir } from 'node:fs/promises';\nimport { createApiRoutes, createGatewayApiRoutes } from './routes.js';\nimport { logger } from '../utils/logger.js';\nimport type { MCPAQLHandler } from '../handlers/mcp-aql/MCPAQLHandler.js';\n\nconst __dirname = dirname(fileURLToPath(import.meta.url));\nconst DEFAULT_PORT = 3939;\nconst CONSOLE_HOST = 'dollhouse.localhost';\nconst ALLOWED_PAGE_EXTENSIONS = new Set(['.html', '.htm']);\n\n/** Track whether the web server is already running in-process. */\nlet serverRunning = false;\nlet serverPort = DEFAULT_PORT;\n\n/**\n * Options for starting the web server.\n */\nexport interface WebServerOptions {\n  /** Port to bind to (default: 3939) */\n  port?: number;\n  /** Path to the portfolio directory (e.g., ~/.dollhouse/portfolio) */\n  portfolioDir: string;\n  /** Open the browser automatically after starting (default: false) */\n  openBrowser?: boolean;\n  /**\n   * MCPAQLHandler for routing through the MCP-AQL pipeline.\n   * When provided, API routes use the gateway (validated, cached, gatekeeper-checked).\n   * When absent, falls back to direct filesystem access (legacy behavior).\n   * Issue #796: Web MCP-AQL Gateway.\n   */\n  mcpAqlHandler?: MCPAQLHandler;\n}\n\n/**\n * Result of attempting to open the browser.\n */\nexport interface BrowserOpenResult {\n  /** The URL the server is running on */\n  url: string;\n  /** Whether the server was already running (true) or just started (false) */\n  alreadyRunning: boolean;\n  /** Whether the browser was successfully opened */\n  browserOpened: boolean;\n  /** Warning message if the browser could not be opened */\n  warning?: string;\n}\n\n/**\n * Open a URL in the system's default browser.\n *\n * Platform-aware:\n * - macOS: `open`\n * - Linux: `xdg-open`\n * - Windows: `start`\n *\n * @param url - The URL to open\n * @returns Promise that resolves to true if the browser opened, false with error message if not\n */\nfunction openInBrowser(url: string): Promise<{ success: boolean; error?: string }> {\n  return new Promise((resolve) => {\n    const plat = platform();\n    const cmd = plat === 'darwin' ? 'open'\n      : plat === 'win32' ? 'start'\n      : 'xdg-open';\n\n    // Security: use execFile with URL as argument array, not string interpolation\n    const urlStr = String(url);\n    if (!/^https?:\\/\\/localhost[:/]/.test(urlStr)) {\n      resolve({ success: false, error: 'URL must be a localhost HTTP URL' });\n      return;\n    }\n    execFile(cmd, [urlStr], (err) => {\n      if (err) {\n        logger.warn(`[WebUI] Could not auto-open browser: ${err.message}`);\n        resolve({ success: false, error: err.message });\n      } else {\n        resolve({ success: true });\n      }\n    });\n  });\n}\n\n/**\n * Start the portfolio web server.\n *\n * Binds to 127.0.0.1 only (localhost). Serves the portfolio browser\n * frontend and API routes for reading elements.\n *\n * Idempotent: if the server is already running, optionally opens the\n * browser without starting a second instance.\n *\n * @param options - Server configuration\n */\nexport async function startWebServer(options: WebServerOptions): Promise<void> {\n  const port = options.port || DEFAULT_PORT;\n\n  if (serverRunning) {\n    if (options.openBrowser) {\n      openInBrowser(`http://${CONSOLE_HOST}:${serverPort}`);\n    }\n    return;\n  }\n\n  const app = express();\n  app.disable('x-powered-by');\n\n  // Security headers\n  app.use((_req, res, next) => {\n    res.setHeader('X-Content-Type-Options', 'nosniff');\n    res.setHeader('X-Frame-Options', 'DENY');\n    res.setHeader('X-XSS-Protection', '1; mode=block');\n    res.setHeader('Referrer-Policy', 'no-referrer');\n    res.setHeader('Access-Control-Allow-Origin', `http://${CONSOLE_HOST}:${port}`);\n    res.setHeader('Content-Security-Policy', [\n      \"default-src 'self'\",\n      \"script-src 'self' cdn.jsdelivr.net cdnjs.cloudflare.com\",\n      \"style-src 'self' 'unsafe-inline' cdnjs.cloudflare.com\",\n      \"connect-src 'self' raw.githubusercontent.com\",\n      \"font-src 'self'\",\n    ].join('; '));\n    next();\n  });\n\n  // API routes — use MCP-AQL gateway when handler is available (Issue #796)\n  if (options.mcpAqlHandler) {\n    app.use('/api', createGatewayApiRoutes(options.mcpAqlHandler, options.portfolioDir));\n    logger.info('[WebUI] API routes using MCP-AQL Gateway (validated, cached, gatekeeper-checked)');\n  } else {\n    app.use('/api', createApiRoutes(options.portfolioDir));\n    logger.warn('[WebUI] API routes using direct filesystem access (no MCP-AQL handler available)');\n  }\n\n  // Serve ~/.dollhouse/pages/ at /pages/ — dashboards, generated content, stack views\n  const pagesDir = join(dirname(options.portfolioDir), 'pages');\n  mkdir(pagesDir, { recursive: true }).catch(err => {\n    logger.warn(`[WebUI] Could not create pages directory: ${(err as Error).message}`);\n  });\n  app.use('/pages', express.static(pagesDir));\n\n  /**\n   * GET /api/pages\n   * Lists available HTML pages in ~/.dollhouse/pages/.\n   * Returns page names and their URLs for the management console.\n   */\n  app.get('/api/pages', async (_req, res) => {\n    try {\n      const files = await readdir(pagesDir);\n      const pages = files\n        .filter(f => !f.startsWith('.') && ALLOWED_PAGE_EXTENSIONS.has(extname(f)))\n        .map(f => ({ name: f, url: `/pages/${f}` }));\n      res.json({ pages, directory: pagesDir });\n    } catch {\n      res.json({ pages: [], directory: pagesDir });\n    }\n  });\n\n  // Static frontend files\n  const publicDir = join(__dirname, 'public');\n  app.use(express.static(publicDir));\n\n  // SPA fallback\n  app.get('/{*path}', (req, res) => {\n    const normalizedPath = req.path.normalize('NFC');\n    if (normalizedPath.startsWith('/api/')) {\n      res.status(404).json({ error: `API route not found: ${normalizedPath}` });\n      return;\n    }\n    if (normalizedPath.startsWith('/pages/')) {\n      res.status(404).json({ error: `Page not found: ${normalizedPath}` });\n      return;\n    }\n    res.sendFile(join(publicDir, 'index.html'));\n  });\n\n  // Bind to localhost only\n  app.listen(port, '127.0.0.1', () => {\n    serverRunning = true;\n    serverPort = port;\n    const url = `http://${CONSOLE_HOST}:${port}`;\n    const fallbackUrl = `http://127.0.0.1:${port}`;\n    logger.info(`[WebUI] Management console running at ${url}`);\n    console.log(`\\n  DollhouseMCP Management Console\\n  ${url}\\n  ${fallbackUrl} (fallback)\\n`);\n\n    if (options.openBrowser) {\n      openInBrowser(url);\n    }\n  });\n}\n\n/**\n * Open the portfolio browser from within the MCP server process.\n *\n * Starts the web server if not already running, then opens the system\n * browser to the portfolio UI. Returns a result object indicating\n * whether the server started and the browser opened successfully.\n *\n * Called by the `open_portfolio_browser` MCP-AQL operation (Issue #774).\n *\n * @param portfolioDir - Path to the portfolio directory (e.g., ~/.dollhouse/portfolio)\n * @param port - Port to bind to (default: 3939)\n * @returns Result with URL, server status, and browser open status\n */\nexport async function openPortfolioBrowser(portfolioDir: string, port?: number, mcpAqlHandler?: MCPAQLHandler): Promise<BrowserOpenResult> {\n  const targetPort = port || DEFAULT_PORT;\n  const url = `http://${CONSOLE_HOST}:${targetPort}`;\n  const alreadyRunning = serverRunning;\n\n  if (!serverRunning) {\n    await startWebServer({\n      portfolioDir,\n      port: targetPort,\n      openBrowser: false, // We'll open manually below to capture the result\n      mcpAqlHandler,\n    });\n    // Wait briefly for the server to bind\n    await new Promise(resolve => setTimeout(resolve, 500));\n  }\n\n  const browserResult = await openInBrowser(url);\n\n  return {\n    url,\n    alreadyRunning,\n    browserOpened: browserResult.success,\n    ...(browserResult.error ? { warning: `Browser could not be opened automatically: ${browserResult.error}. Open ${url} manually.` } : {}),\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/web/server.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * DollhouseMCP Web UI Server\n *\n * Lightweight Express server for browsing portfolio elements in a browser.\n * Bound to 127.0.0.1 only (localhost). Read-only for V1.\n *\n * Can be started standalone (`--web` flag) or from within the MCP server\n * process via `openPortfolioBrowser()`.\n *\n * @see https://github.com/DollhouseMCP/mcp-server-v2-refactor/issues/704\n * @see https://github.com/DollhouseMCP/mcp-server-v2-refactor/issues/774\n */\n\nimport express from 'express';\nimport { join, dirname, extname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { execFile } from 'node:child_process';\nimport { platform } from 'node:os';\nimport { mkdir, readdir } from 'node:fs/promises';\nimport { createApiRoutes, createGatewayApiRoutes } from './routes.js';\nimport { createLogRoutes, type LogRoutesResult } from './routes/logRoutes.js';\nimport { createMetricsRoutes, type MetricsRoutesResult } from './routes/metricsRoutes.js';\nimport { createHealthRoutes } from './routes/healthRoutes.js';\nimport { logger } from '../utils/logger.js';\nimport type { MCPAQLHandler } from '../handlers/mcp-aql/MCPAQLHandler.js';\nimport type { MemoryLogSink } from '../logging/sinks/MemoryLogSink.js';\nimport type { MemoryMetricsSink } from '../metrics/sinks/MemoryMetricsSink.js';\n\nconst __dirname = dirname(fileURLToPath(import.meta.url));\nconst DEFAULT_PORT = 3939;\nconst CONSOLE_HOST = 'dollhouse.localhost';\nconst ALLOWED_PAGE_EXTENSIONS = new Set(['.html', '.htm']);\n\n/** Track whether the web server is already running in-process. */\nlet serverRunning = false;\nlet serverPort = DEFAULT_PORT;\n\n/**\n * Options for starting the web server.\n */\nexport interface WebServerOptions {\n  /** Port to bind to (default: 3939) */\n  port?: number;\n  /** Path to the portfolio directory (e.g., ~/.dollhouse/portfolio) */\n  portfolioDir: string;\n  /** Open the browser automatically after starting (default: false) */\n  openBrowser?: boolean;\n  /**\n   * MCPAQLHandler for routing through the MCP-AQL pipeline.\n   * When provided, API routes use the gateway (validated, cached, gatekeeper-checked).\n   * When absent, falls back to direct filesystem access (legacy behavior).\n   * Issue #796: Web MCP-AQL Gateway.\n   */\n  mcpAqlHandler?: MCPAQLHandler;\n  /** MemoryLogSink for log routes (optional — logs tab disabled if not provided) */\n  memorySink?: MemoryLogSink;\n  /** MemoryMetricsSink for metrics routes (optional — metrics tab disabled if not provided) */\n  metricsSink?: MemoryMetricsSink;\n  /** Additional routers to mount before the SPA fallback (e.g., ingest routes) */\n  additionalRouters?: import('express').Router[];\n}\n\n/**\n * Result of starting the web server, including hooks for DI wiring.\n */\nexport interface WebServerResult {\n  /** Express app instance — for mounting additional routes (e.g., ingest routes) */\n  app?: import('express').Express;\n  /** Log broadcast function — call with each entry to push to SSE clients */\n  logBroadcast?: (entry: import('../logging/types.js').UnifiedLogEntry) => void;\n  /** Metrics snapshot function — call with each snapshot to push to SSE clients */\n  metricsOnSnapshot?: (snapshot: import('../metrics/types.js').MetricSnapshot) => void;\n}\n\n/**\n * Result of attempting to open the browser.\n */\nexport interface BrowserOpenResult {\n  /** The URL the server is running on */\n  url: string;\n  /** Whether the server was already running (true) or just started (false) */\n  alreadyRunning: boolean;\n  /** Whether the browser was successfully opened */\n  browserOpened: boolean;\n  /** Warning message if the browser could not be opened */\n  warning?: string;\n}\n\n/**\n * Open a URL in the system's default browser.\n *\n * Platform-aware:\n * - macOS: `open`\n * - Linux: `xdg-open`\n * - Windows: `start`\n *\n * @param url - The URL to open\n * @returns Promise that resolves to true if the browser opened, false with error message if not\n */\nfunction openInBrowser(url: string): Promise<{ success: boolean; error?: string }> {\n  return new Promise((resolve) => {\n    const plat = platform();\n    const cmd = plat === 'darwin' ? 'open'\n      : plat === 'win32' ? 'start'\n      : 'xdg-open';\n\n    // Security: use execFile with URL as argument array, not string interpolation\n    const urlStr = String(url);\n    if (!/^https?:\\/\\/localhost[:/]/.test(urlStr)) {\n      resolve({ success: false, error: 'URL must be a localhost HTTP URL' });\n      return;\n    }\n    execFile(cmd, [urlStr], (err) => {\n      if (err) {\n        logger.warn(`[WebUI] Could not auto-open browser: ${err.message}`);\n        resolve({ success: false, error: err.message });\n      } else {\n        resolve({ success: true });\n      }\n    });\n  });\n}\n\n/**\n * Start the portfolio web server.\n *\n * Binds to 127.0.0.1 only (localhost). Serves the portfolio browser\n * frontend and API routes for reading elements.\n *\n * Idempotent: if the server is already running, optionally opens the\n * browser without starting a second instance.\n *\n * @param options - Server configuration\n * @returns Hooks for DI wiring (log broadcast, metrics onSnapshot)\n */\nexport async function startWebServer(options: WebServerOptions): Promise<WebServerResult> {\n  const port = options.port || DEFAULT_PORT;\n  const result: WebServerResult = {};\n\n  if (serverRunning) {\n    if (options.openBrowser) {\n      openInBrowser(`http://${CONSOLE_HOST}:${serverPort}`);\n    }\n    return result;\n  }\n\n  const app = express();\n  result.app = app;\n  app.disable('x-powered-by');\n\n  // Security headers\n  app.use((_req, res, next) => {\n    res.setHeader('X-Content-Type-Options', 'nosniff');\n    res.setHeader('X-Frame-Options', 'DENY');\n    res.setHeader('X-XSS-Protection', '1; mode=block');\n    res.setHeader('Referrer-Policy', 'no-referrer');\n    res.setHeader('Access-Control-Allow-Origin', `http://${CONSOLE_HOST}:${port}`);\n    res.setHeader('Content-Security-Policy', [\n      \"default-src 'self'\",\n      \"script-src 'self' cdn.jsdelivr.net cdnjs.cloudflare.com\",\n      \"style-src 'self' 'unsafe-inline' cdnjs.cloudflare.com cdn.jsdelivr.net\",\n      \"connect-src 'self' raw.githubusercontent.com\",\n      \"font-src 'self'\",\n    ].join('; '));\n    next();\n  });\n\n  // API routes — use MCP-AQL gateway when handler is available (Issue #796)\n  if (options.mcpAqlHandler) {\n    app.use('/api', createGatewayApiRoutes(options.mcpAqlHandler, options.portfolioDir));\n\n    // Permission evaluation routes (POST /evaluate_permission, GET /permissions/status)\n    const { registerPermissionRoutes } = await import('./routes/permissionRoutes.js');\n    const permRouter = (await import('express')).Router();\n    registerPermissionRoutes(permRouter, options.mcpAqlHandler);\n    app.use('/api', permRouter);\n\n    logger.info('[WebUI] API routes using MCP-AQL Gateway + permission routes');\n  } else {\n    app.use('/api', createApiRoutes(options.portfolioDir));\n    logger.warn('[WebUI] API routes using direct filesystem access (no MCP-AQL handler available)');\n  }\n\n  // Console routes: logs, metrics, health\n  let logRoutes: LogRoutesResult | undefined;\n  let metricsRoutes: MetricsRoutesResult | undefined;\n\n  if (options.memorySink) {\n    logRoutes = createLogRoutes(options.memorySink);\n    app.use('/api', logRoutes.router);\n    result.logBroadcast = logRoutes.broadcast;\n    logger.info('[WebUI] Log viewer routes mounted at /api/logs');\n  }\n\n  if (options.metricsSink) {\n    metricsRoutes = createMetricsRoutes(options.metricsSink);\n    app.use('/api', metricsRoutes.router);\n    result.metricsOnSnapshot = metricsRoutes.onSnapshot;\n    logger.info('[WebUI] Metrics routes mounted at /api/metrics');\n  }\n\n  if (options.memorySink) {\n    const healthRouter = createHealthRoutes({\n      memorySink: options.memorySink,\n      metricsSink: options.metricsSink,\n      logClientCount: logRoutes ? logRoutes.clientCount : () => 0,\n      metricsClientCount: metricsRoutes ? metricsRoutes.clientCount : () => 0,\n    });\n    app.use('/api', healthRouter);\n  }\n\n  // Serve ~/.dollhouse/pages/ at /pages/ — dashboards, generated content, stack views\n  const pagesDir = join(dirname(options.portfolioDir), 'pages');\n  mkdir(pagesDir, { recursive: true }).catch(err => {\n    logger.warn(`[WebUI] Could not create pages directory: ${(err as Error).message}`);\n  });\n  app.use('/pages', express.static(pagesDir));\n\n  /**\n   * GET /api/pages\n   * Lists available HTML pages in ~/.dollhouse/pages/.\n   * Returns page names and their URLs for the management console.\n   */\n  app.get('/api/pages', async (_req, res) => {\n    try {\n      const files = await readdir(pagesDir);\n      const pages = files\n        .filter(f => !f.startsWith('.') && ALLOWED_PAGE_EXTENSIONS.has(extname(f)))\n        .map(f => ({ name: f, url: `/pages/${f}` }));\n      res.json({ pages, directory: pagesDir });\n    } catch {\n      res.json({ pages: [], directory: pagesDir });\n    }\n  });\n\n  // Additional routers (e.g., unified console ingest routes) — must mount before SPA fallback\n  options.additionalRouters?.forEach(router => app.use(router));\n\n  // Static frontend files\n  const publicDir = join(__dirname, 'public');\n  app.use(express.static(publicDir));\n\n  // SPA fallback\n  app.get('/{*path}', (req, res) => {\n    const normalizedPath = req.path.normalize('NFC');\n    if (normalizedPath.startsWith('/api/')) {\n      res.status(404).json({ error: `API route not found: ${normalizedPath}` });\n      return;\n    }\n    if (normalizedPath.startsWith('/pages/')) {\n      res.status(404).json({ error: `Page not found: ${normalizedPath}` });\n      return;\n    }\n    res.sendFile(join(publicDir, 'index.html'));\n  });\n\n  // Bind to localhost only\n  app.listen(port, '127.0.0.1', () => {\n    serverRunning = true;\n    serverPort = port;\n    const url = `http://${CONSOLE_HOST}:${port}`;\n    const fallbackUrl = `http://127.0.0.1:${port}`;\n    logger.info(`[WebUI] Management console running at ${url}`);\n    console.log(`\\n  DollhouseMCP Management Console\\n  ${url}\\n  ${fallbackUrl} (fallback)\\n`);\n\n    if (options.openBrowser) {\n      openInBrowser(url);\n    }\n  });\n\n  return result;\n}\n\n/**\n * Open the portfolio browser from within the MCP server process.\n *\n * Starts the web server if not already running, then opens the system\n * browser to the portfolio UI. Returns a result object indicating\n * whether the server started and the browser opened successfully.\n *\n * Called by the `open_portfolio_browser` MCP-AQL operation (Issue #774).\n *\n * @param portfolioDir - Path to the portfolio directory (e.g., ~/.dollhouse/portfolio)\n * @param port - Port to bind to (default: 3939)\n * @returns Result with URL, server status, and browser open status\n */\nexport async function openPortfolioBrowser(portfolioDir: string, port?: number, mcpAqlHandler?: MCPAQLHandler): Promise<BrowserOpenResult> {\n  const targetPort = port || DEFAULT_PORT;\n  const url = `http://${CONSOLE_HOST}:${targetPort}`;\n  const alreadyRunning = serverRunning;\n\n  if (!serverRunning) {\n    await startWebServer({\n      portfolioDir,\n      port: targetPort,\n      openBrowser: false, // We'll open manually below to capture the result\n      mcpAqlHandler,\n    });\n    // Wait briefly for the server to bind\n    await new Promise(resolve => setTimeout(resolve, 500));\n  }\n\n  const browserResult = await openInBrowser(url);\n\n  return {\n    url,\n    alreadyRunning,\n    browserOpened: browserResult.success,\n    ...(browserResult.error ? { warning: `Browser could not be opened automatically: ${browserResult.error}. Open ${url} manually.` } : {}),\n  };\n}\n"]}

package/dist/web/sinks/WebSSELogSink.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Thin ILogSink adapter that bridges LogManager to the web console SSE stream.
+ *
+ * write() calls the broadcast function from logRoutes.
+ * flush()/close() are no-ops — the SSE connections are managed by Express.
+ */
+import type { ILogSink, UnifiedLogEntry } from '../../logging/types.js';
+export declare class WebSSELogSink implements ILogSink {
+    private readonly broadcast;
+    constructor(broadcast: (entry: UnifiedLogEntry) => void);
+    write(entry: UnifiedLogEntry): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=WebSSELogSink.d.ts.map

package/dist/web/sinks/WebSSELogSink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSSELogSink.d.ts","sourceRoot":"","sources":["../../../src/web/sinks/WebSSELogSink.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAExE,qBAAa,aAAc,YAAW,QAAQ;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI;IAExE,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAI7B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/web/sinks/WebSSELogSink.js

@@ -0,0 +1,22 @@
+/**
+ * Thin ILogSink adapter that bridges LogManager to the web console SSE stream.
+ *
+ * write() calls the broadcast function from logRoutes.
+ * flush()/close() are no-ops — the SSE connections are managed by Express.
+ */
+export class WebSSELogSink {
+    broadcast;
+    constructor(broadcast) {
+        this.broadcast = broadcast;
+    }
+    write(entry) {
+        this.broadcast(entry);
+    }
+    async flush() {
+        // No-op — SSE writes are immediate.
+    }
+    async close() {
+        // No-op — SSE connections managed by Express.
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiV2ViU1NFTG9nU2luay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy93ZWIvc2lua3MvV2ViU1NFTG9nU2luay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUlILE1BQU0sT0FBTyxhQUFhO0lBQ0s7SUFBN0IsWUFBNkIsU0FBMkM7UUFBM0MsY0FBUyxHQUFULFNBQVMsQ0FBa0M7SUFBRyxDQUFDO0lBRTVFLEtBQUssQ0FBQyxLQUFzQjtRQUMxQixJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3hCLENBQUM7SUFFRCxLQUFLLENBQUMsS0FBSztRQUNULG9DQUFvQztJQUN0QyxDQUFDO0lBRUQsS0FBSyxDQUFDLEtBQUs7UUFDVCw4Q0FBOEM7SUFDaEQsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGluIElMb2dTaW5rIGFkYXB0ZXIgdGhhdCBicmlkZ2VzIExvZ01hbmFnZXIgdG8gdGhlIHdlYiBjb25zb2xlIFNTRSBzdHJlYW0uXG4gKlxuICogd3JpdGUoKSBjYWxscyB0aGUgYnJvYWRjYXN0IGZ1bmN0aW9uIGZyb20gbG9nUm91dGVzLlxuICogZmx1c2goKS9jbG9zZSgpIGFyZSBuby1vcHMg4oCUIHRoZSBTU0UgY29ubmVjdGlvbnMgYXJlIG1hbmFnZWQgYnkgRXhwcmVzcy5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7IElMb2dTaW5rLCBVbmlmaWVkTG9nRW50cnkgfSBmcm9tICcuLi8uLi9sb2dnaW5nL3R5cGVzLmpzJztcblxuZXhwb3J0IGNsYXNzIFdlYlNTRUxvZ1NpbmsgaW1wbGVtZW50cyBJTG9nU2luayB7XG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgYnJvYWRjYXN0OiAoZW50cnk6IFVuaWZpZWRMb2dFbnRyeSkgPT4gdm9pZCkge31cblxuICB3cml0ZShlbnRyeTogVW5pZmllZExvZ0VudHJ5KTogdm9pZCB7XG4gICAgdGhpcy5icm9hZGNhc3QoZW50cnkpO1xuICB9XG5cbiAgYXN5bmMgZmx1c2goKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgLy8gTm8tb3Ag4oCUIFNTRSB3cml0ZXMgYXJlIGltbWVkaWF0ZS5cbiAgfVxuXG4gIGFzeW5jIGNsb3NlKCk6IFByb21pc2U8dm9pZD4ge1xuICAgIC8vIE5vLW9wIOKAlCBTU0UgY29ubmVjdGlvbnMgbWFuYWdlZCBieSBFeHByZXNzLlxuICB9XG59XG4iXX0=

package/dist/web/sinks/WebSSEMetricsSink.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Thin IMetricsSink adapter that bridges MetricsManager to the web console SSE stream.
+ *
+ * onSnapshot() calls the onSnapshot function from metricsRoutes.
+ * flush()/close() are no-ops — the SSE connections are managed by Express.
+ */
+import type { IMetricsSink, MetricSnapshot } from '../../metrics/types.js';
+export declare class WebSSEMetricsSink implements IMetricsSink {
+    private readonly pushSnapshot;
+    readonly name = "WebSSEMetricsSink";
+    constructor(pushSnapshot: (snapshot: MetricSnapshot) => void);
+    onSnapshot(snapshot: MetricSnapshot): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=WebSSEMetricsSink.d.ts.map

package/dist/web/sinks/WebSSEMetricsSink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSSEMetricsSink.d.ts","sourceRoot":"","sources":["../../../src/web/sinks/WebSSEMetricsSink.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE3E,qBAAa,iBAAkB,YAAW,YAAY;IAGxC,OAAO,CAAC,QAAQ,CAAC,YAAY;IAFzC,QAAQ,CAAC,IAAI,uBAAuB;gBAEP,YAAY,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,IAAI;IAE7E,UAAU,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAIpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/web/sinks/WebSSEMetricsSink.js

@@ -0,0 +1,23 @@
+/**
+ * Thin IMetricsSink adapter that bridges MetricsManager to the web console SSE stream.
+ *
+ * onSnapshot() calls the onSnapshot function from metricsRoutes.
+ * flush()/close() are no-ops — the SSE connections are managed by Express.
+ */
+export class WebSSEMetricsSink {
+    pushSnapshot;
+    name = 'WebSSEMetricsSink';
+    constructor(pushSnapshot) {
+        this.pushSnapshot = pushSnapshot;
+    }
+    onSnapshot(snapshot) {
+        this.pushSnapshot(snapshot);
+    }
+    async flush() {
+        // No-op — SSE writes are immediate.
+    }
+    async close() {
+        // No-op — SSE connections managed by Express.
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiV2ViU1NFTWV0cmljc1NpbmsuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvd2ViL3NpbmtzL1dlYlNTRU1ldHJpY3NTaW5rLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBSUgsTUFBTSxPQUFPLGlCQUFpQjtJQUdDO0lBRnBCLElBQUksR0FBRyxtQkFBbUIsQ0FBQztJQUVwQyxZQUE2QixZQUFnRDtRQUFoRCxpQkFBWSxHQUFaLFlBQVksQ0FBb0M7SUFBRyxDQUFDO0lBRWpGLFVBQVUsQ0FBQyxRQUF3QjtRQUNqQyxJQUFJLENBQUMsWUFBWSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQzlCLENBQUM7SUFFRCxLQUFLLENBQUMsS0FBSztRQUNULG9DQUFvQztJQUN0QyxDQUFDO0lBRUQsS0FBSyxDQUFDLEtBQUs7UUFDVCw4Q0FBOEM7SUFDaEQsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGluIElNZXRyaWNzU2luayBhZGFwdGVyIHRoYXQgYnJpZGdlcyBNZXRyaWNzTWFuYWdlciB0byB0aGUgd2ViIGNvbnNvbGUgU1NFIHN0cmVhbS5cbiAqXG4gKiBvblNuYXBzaG90KCkgY2FsbHMgdGhlIG9uU25hcHNob3QgZnVuY3Rpb24gZnJvbSBtZXRyaWNzUm91dGVzLlxuICogZmx1c2goKS9jbG9zZSgpIGFyZSBuby1vcHMg4oCUIHRoZSBTU0UgY29ubmVjdGlvbnMgYXJlIG1hbmFnZWQgYnkgRXhwcmVzcy5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7IElNZXRyaWNzU2luaywgTWV0cmljU25hcHNob3QgfSBmcm9tICcuLi8uLi9tZXRyaWNzL3R5cGVzLmpzJztcblxuZXhwb3J0IGNsYXNzIFdlYlNTRU1ldHJpY3NTaW5rIGltcGxlbWVudHMgSU1ldHJpY3NTaW5rIHtcbiAgcmVhZG9ubHkgbmFtZSA9ICdXZWJTU0VNZXRyaWNzU2luayc7XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBwdXNoU25hcHNob3Q6IChzbmFwc2hvdDogTWV0cmljU25hcHNob3QpID0+IHZvaWQpIHt9XG5cbiAgb25TbmFwc2hvdChzbmFwc2hvdDogTWV0cmljU25hcHNob3QpOiB2b2lkIHtcbiAgICB0aGlzLnB1c2hTbmFwc2hvdChzbmFwc2hvdCk7XG4gIH1cblxuICBhc3luYyBmbHVzaCgpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICAvLyBOby1vcCDigJQgU1NFIHdyaXRlcyBhcmUgaW1tZWRpYXRlLlxuICB9XG5cbiAgYXN5bmMgY2xvc2UoKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgLy8gTm8tb3Ag4oCUIFNTRSBjb25uZWN0aW9ucyBtYW5hZ2VkIGJ5IEV4cHJlc3MuXG4gIH1cbn1cbiJdfQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dollhousemcp/mcp-server",
-  "version": "2.0.0-rc.6",
+  "version": "2.0.0",
   "description": "DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.",
   "type": "module",
   "main": "dist/index.js",
@@ -12,7 +12,7 @@
     "prebuild": "npm run build:safety && node scripts/generate-version.js",
     "build:safety": "cd packages/safety && npm install && npm run build",
     "build": "tsc",
-    "postbuild": "cp -r src/seed-elements dist/ && cp -r src/web/public dist/web/public",
+    "postbuild": "node -e \"const fs=require('fs'),p=require('path');function rm(d){if(fs.existsSync(d)){for(const e of fs.readdirSync(d)){const f=p.join(d,e);fs.statSync(f).isDirectory()?rm(f):fs.unlinkSync(f)}fs.rmdirSync(d)}}function cpR(s,d){fs.mkdirSync(d,{recursive:true});for(const e of fs.readdirSync(s)){const sp=p.join(s,e),dp=p.join(d,e);fs.statSync(sp).isDirectory()?cpR(sp,dp):fs.copyFileSync(sp,dp)}}cpR('src/seed-elements','dist/seed-elements');rm('dist/web/public');cpR('src/web/public','dist/web/public')\"",
     "web": "node dist/index.js --web",
     "start": "node dist/index.js",
     "dev": "tsx watch src/index.ts",

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.DollhouseMCP/mcp-server",
   "title": "DollhouseMCP",
   "description": "OSS to create Personas, Skills, Templates, Agents, and Memories to customize your AI experience.",
-  "version": "2.0.0-rc.6",
+  "version": "2.0.0",
   "homepage": "https://dollhousemcp.com",
   "repository": {
     "type": "git",
@@ -29,7 +29,7 @@
     {
       "registryType": "npm",
       "identifier": "@dollhousemcp/mcp-server",
-      "version": "2.0.0-rc.6",
+      "version": "2.0.0",
       "transport": {
         "type": "stdio"
       }

package/dist/constants/version.d.ts

@@ -1,3 +0,0 @@
-export declare const VERSION = "1.6.5";
-export declare const BUILD_DATE = "2025-08-26T15:30:22.187Z";
-//# sourceMappingURL=version.d.ts.map

package/dist/constants/version.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/constants/version.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO,UAAU,CAAC;AAC/B,eAAO,MAAM,UAAU,6BAA6B,CAAC"}

package/dist/constants/version.js

@@ -1,4 +0,0 @@
-// Auto-generated version constant
-export const VERSION = "1.6.5";
-export const BUILD_DATE = "2025-08-26T15:30:22.187Z";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25zdGFudHMvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxrQ0FBa0M7QUFDbEMsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQztBQUMvQixNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBBdXRvLWdlbmVyYXRlZCB2ZXJzaW9uIGNvbnN0YW50XG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiMS42LjVcIjtcbmV4cG9ydCBjb25zdCBCVUlMRF9EQVRFID0gXCIyMDI1LTA4LTI2VDE1OjMwOjIyLjE4N1pcIjtcbiJdfQ==

package/dist/logging/sinks/SSELogSink.d.ts

@@ -1,35 +0,0 @@
-/**
- * SSE-based real-time log viewer sink.
- *
- * Implements ILogSink and runs an opt-in Express HTTP server that:
- * - Serves a browser-based log viewer at GET /
- * - Streams log entries via SSE at GET /logs/stream
- * - Exposes a JSON query endpoint at GET /logs (delegates to MemoryLogSink)
- * - Provides a health endpoint at GET /health
- *
- * See docs/LOGGING-DESIGN.md §4.6 for the full design.
- */
-import type { ILogSink, UnifiedLogEntry } from '../types.js';
-import type { MemoryLogSink } from './MemoryLogSink.js';
-export interface SSELogSinkOptions {
-    port: number;
-    memorySink: MemoryLogSink;
-}
-export declare class SSELogSink implements ILogSink {
-    private readonly app;
-    private server;
-    private readonly clients;
-    private readonly memorySink;
-    private readonly port;
-    private readonly startTime;
-    constructor(options: SSELogSinkOptions);
-    write(entry: UnifiedLogEntry): void;
-    flush(): Promise<void>;
-    close(): Promise<void>;
-    start(): Promise<void>;
-    get clientCount(): number;
-    getPort(): number;
-    private setupRoutes;
-    private matchesFilter;
-}
-//# sourceMappingURL=SSELogSink.d.ts.map

package/dist/logging/sinks/SSELogSink.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SSELogSink.d.ts","sourceRoot":"","sources":["../../../src/logging/sinks/SSELogSink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAyB,MAAM,aAAa,CAAC;AAEpF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,aAAa,CAAC;CAC3B;AAcD,qBAAa,UAAW,YAAW,QAAQ;IACzC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA6B;IACjD,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAc;gBAE5B,OAAO,EAAE,iBAAiB;IAWtC,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAQ7B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAoBtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,OAAO,IAAI,MAAM;IAWjB,OAAO,CAAC,WAAW;IA4FnB,OAAO,CAAC,aAAa;CAkBtB"}