@dollhousemcp/mcp-server/dist/web/server.js

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.

/**
 * DollhouseMCP Web UI Server
 *
 * Lightweight Express server for browsing portfolio elements in a browser.
 * Bound to 127.0.0.1 only (localhost). Read-only for V1.
 *
 * Can be started standalone (`--web` flag) or from within the MCP server
 * process via `openPortfolioBrowser()`.
 *
 * @see https://github.com/DollhouseMCP/mcp-server-v2-refactor/issues/704
 * @see https://github.com/DollhouseMCP/mcp-server-v2-refactor/issues/774
 */
import express from 'express';
import { join, dirname, extname } from 'node:path';
import { fileURLToPath } from 'node:url';
import { execFile } from 'node:child_process';
import { platform } from 'node:os';
import { mkdir, readdir, readFile as readFileFs } 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 { createSetupRoutes, repairNvmLauncherOnStartup } from './routes/setupRoutes.js';
import { repairPermissionHooksOnStartup } from '../utils/permissionHooks.js';
import { createTotpRoutes } from './routes/totpRoutes.js';
import { createTokenRoutes } from './routes/tokenRoutes.js';
import { logger } from '../utils/logger.js';
import { env } from '../config/env.js';
import { createAuthMiddleware } from './middleware/authMiddleware.js';
import { PACKAGE_VERSION } from '../generated/version.js';
/**
 * Public path prefixes that never require authentication (#1780).
 * These endpoints return safe metadata or act as health probes — requiring
 * tokens on them would break monitoring and client detection without adding
 * real security value.
 */
const PUBLIC_PATH_PREFIXES = [
    '/api/health',
    '/api/setup/version',
    '/api/setup/mcpb',
    '/api/setup/detect',
    '/api/setup/license',
];
/** Placeholder in index.html that is replaced with the current console token. */
const TOKEN_META_PLACEHOLDER = '{{CONSOLE_TOKEN}}';
/** Placeholder in index.html that is replaced with the running server version. */
const VERSION_META_PLACEHOLDER = '{{DOLLHOUSE_VERSION}}';
/** Placeholder in index.html that is replaced with the stable Dollhouse session ID. */
const SESSION_ID_META_PLACEHOLDER = '{{DOLLHOUSE_SESSION_ID}}';
/** Placeholder in index.html that is replaced with the runtime session ID. */
const RUNTIME_SESSION_ID_META_PLACEHOLDER = '{{DOLLHOUSE_RUNTIME_SESSION_ID}}';
/** Placeholder in index.html that is replaced with the asset cache-busting version. */
const ASSET_VERSION_META_PLACEHOLDER = '{{DOLLHOUSE_ASSET_VERSION}}';
const __dirname = dirname(fileURLToPath(import.meta.url));
/**
 * Default port for standalone `startWebServer` calls. Reads from the
 * `DOLLHOUSE_WEB_CONSOLE_PORT` env var so there is a single source of
 * truth (see `src/config/env.ts`). Callers passing an explicit `port` in
 * `WebServerOptions` override this default.
 */
const DEFAULT_PORT = env.DOLLHOUSE_WEB_CONSOLE_PORT;
const CONSOLE_HOST = 'dollhouse.localhost';
const ALLOWED_PAGE_EXTENSIONS = new Set(['.html', '.htm']);
/** Max JSON body for setup routes (install/open-config). Ingest routes use their own 1mb limit. */
const SETUP_BODY_LIMIT = '1kb';
/** Track whether the web server is already running in-process. */
let serverRunning = false;
let serverPort = DEFAULT_PORT;
/** Active HTTP server instance — tracked so _resetServerState can close it. */
let activeHttpServer = null;
/** Cached token store for openPortfolioBrowser — prevents duplicate instances on the same file. */
let cachedTokenStore = null;
/** Check whether the web server has been started in this process. */
export function isWebServerRunning() {
    return serverRunning;
}
/**
 * Reset module-level server state. Exported for testing only —
 * allows tests to exercise startWebServer/bindAndListen without
 * interference from prior runs in the same process.
 * @internal
 */
export function _resetServerState() {
    if (activeHttpServer) {
        activeHttpServer.close();
        activeHttpServer = null;
    }
    serverRunning = false;
    serverPort = DEFAULT_PORT;
    cachedTokenStore = null;
}
/**
 * Gracefully shut down the HTTP server (#1856).
 * Closes the active server and resets module state so the port is freed
 * immediately rather than lingering until process exit.
 */
export function shutdownWebServer() {
    if (activeHttpServer) {
        activeHttpServer.close();
        activeHttpServer = null;
        serverRunning = false;
        logger.info(`[WebUI] HTTP server closed on port ${serverPort}`);
    }
}
/**
 * Open a URL in the system's default browser.
 *
 * Platform-aware:
 * - macOS: `open`
 * - Linux: `xdg-open`
 * - Windows: `start`
 *
 * @param url - The URL to open
 * @returns Promise that resolves to true if the browser opened, false with error message if not
 */
function openInBrowser(url) {
    return new Promise((resolve) => {
        const plat = platform();
        const cmd = plat === 'darwin' ? 'open'
            : plat === 'win32' ? 'start'
                : 'xdg-open';
        // Security: use execFile with URL as argument array, not string interpolation
        const urlStr = String(url);
        // Accept localhost, 127.0.0.1, and *.localhost subdomains (RFC 6761)
        if (!/^https?:\/\/(localhost|127\.0\.0\.1|[\w-]+\.localhost)[:/]/.test(urlStr)) {
            resolve({ success: false, error: 'URL must be a localhost HTTP URL' });
            return;
        }
        execFile(cmd, [urlStr], (err) => {
            if (err) {
                logger.warn(`[WebUI] Could not auto-open browser: ${err.message}`);
                resolve({ success: false, error: err.message });
            }
            else {
                resolve({ success: true });
            }
        });
    });
}
/**
 * Start the portfolio web server.
 *
 * Binds to 127.0.0.1 only (localhost). Serves the portfolio browser
 * frontend and API routes for reading elements.
 *
 * Idempotent: if the server is already running, optionally opens the
 * 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 result;
    }
    const app = express();
    result.app = app;
    app.disable('x-powered-by');
    // Security headers
    app.use((_req, res, next) => {
        res.setHeader('X-Content-Type-Options', 'nosniff');
        res.setHeader('X-Frame-Options', 'DENY');
        res.setHeader('X-XSS-Protection', '1; mode=block');
        res.setHeader('Referrer-Policy', 'no-referrer');
        res.setHeader('Access-Control-Allow-Origin', `http://${CONSOLE_HOST}:${port}`);
        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 cdn.jsdelivr.net",
            "img-src 'self' data:",
            "connect-src 'self' raw.githubusercontent.com",
            "font-src 'self'",
        ].join('; '));
        next();
    });
    // Console token authentication middleware (#1780). Mounted before any /api
    // routes so every protected endpoint goes through it. When the feature flag
    // DOLLHOUSE_WEB_AUTH_ENABLED is false (Phase 1 default) this is a pass-through.
    // Public endpoints in PUBLIC_PATH_PREFIXES always bypass auth regardless of flag.
    if (options.tokenStore) {
        const authMiddleware = createAuthMiddleware({
            store: options.tokenStore,
            enabled: env.DOLLHOUSE_WEB_AUTH_ENABLED,
            publicPathPrefixes: PUBLIC_PATH_PREFIXES,
            label: 'api',
        });
        app.use('/api', authMiddleware);
        logger.info(`[WebUI] Console auth middleware mounted ${env.DOLLHOUSE_WEB_AUTH_ENABLED ? 'ENFORCING' : 'pass-through (flag off)'}`);
        // TOTP enrollment routes (#1794). Mounted AFTER the /api auth middleware
        // because the router adds its own always-on auth guard — the global auth
        // middleware at /api is a pass-through during Phase 1 rollout, but the
        // TOTP router enforces regardless of DOLLHOUSE_WEB_AUTH_ENABLED so an
        // attacker with local port access cannot pre-enroll a second factor and
        // lock the legitimate user out.
        app.use('/api/console/totp', createTotpRoutes({ store: options.tokenStore }));
        logger.info('[WebUI] TOTP routes mounted at /api/console/totp (always-on auth)');
        // Token management routes (#1795). Mounted alongside the TOTP router with
        // the same always-on auth pattern. Currently hosts the rotation endpoint;
        // future token management operations (list, revoke) go here too.
        app.use('/api/console/token', createTokenRoutes({ store: options.tokenStore }));
        logger.info('[WebUI] Token routes mounted at /api/console/token (always-on auth)');
    }
    // Setup routes: auto-install DollhouseMCP to MCP clients (mount BEFORE API routes)
    // Body limit scoped to setup routes only — ingest routes need 1mb for follower log forwarding
    const setupJsonParser = express.json({ limit: SETUP_BODY_LIMIT, type: 'application/json' });
    const { installHandler, openConfigHandler, versionHandler, mcpbRedirectHandler, detectHandler, getLicenseHandler, setLicenseHandler, verifyLicenseHandler, resendVerificationHandler } = createSetupRoutes();
    app.post('/api/setup/install', setupJsonParser, installHandler);
    app.post('/api/setup/open-config', setupJsonParser, openConfigHandler);
    app.get('/api/setup/version', versionHandler);
    app.get('/api/setup/mcpb', mcpbRedirectHandler);
    app.get('/api/setup/detect', detectHandler);
    app.get('/api/setup/license', getLicenseHandler);
    app.post('/api/setup/license', setupJsonParser, setLicenseHandler);
    app.post('/api/setup/license/verify', setupJsonParser, verifyLicenseHandler);
    app.post('/api/setup/license/resend', setupJsonParser, resendVerificationHandler);
    logger.info('[WebUI] Setup routes mounted at /api/setup');
    // Fire-and-forget NVM launcher repair: recreates the wrapper if deleted and
    // patches any pre-existing configs that still use bare `npx`. No-ops when
    // NVM is absent or on Windows. Never delays server startup.
    repairNvmLauncherOnStartup().catch(err => logger.warn(`[Setup] NVM startup repair threw unexpectedly: ${err instanceof Error ? err.message : String(err)}`));
    if (process.env.NODE_ENV !== 'test') {
        repairPermissionHooksOnStartup()
            .then((summary) => {
            if (summary.needsRepairCount > 0) {
                logger.warn(`[Setup] Permission hook startup repair completed with ${summary.needsRepairCount} issue(s) ` +
                    `across ${summary.hostResults.length} host(s)`);
            }
        })
            .catch(err => logger.warn(`[Setup] Permission hook startup repair threw unexpectedly: ${err instanceof Error ? err.message : String(err)}`));
    }
    // API routes — use MCP-AQL gateway when handler is available (Issue #796)
    if (options.mcpAqlHandler) {
        app.use('/api', createGatewayApiRoutes(options.mcpAqlHandler, options.portfolioDir));
        // 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 — extracted to keep cognitive
    // complexity of startWebServer manageable.
    mountConsoleRoutes(app, options, result);
    // Serve ~/.dollhouse/pages/ at /pages/ — dashboards, generated content, stack views
    const pagesDir = join(dirname(options.portfolioDir), 'pages');
    mkdir(pagesDir, { recursive: true }).catch(err => {
        logger.warn(`[WebUI] Could not create pages directory: ${err.message}`);
    });
    app.use('/pages', express.static(pagesDir));
    /**
     * GET /api/pages
     * Lists available HTML pages in ~/.dollhouse/pages/.
     * Returns page names and their URLs for the management console.
     */
    app.get('/api/pages', async (_req, res) => {
        try {
            const files = await readdir(pagesDir);
            const pages = files
                .filter(f => !f.startsWith('.') && ALLOWED_PAGE_EXTENSIONS.has(extname(f)))
                .map(f => ({ name: f, url: `/pages/${f}` }));
            res.json({ pages, directory: pagesDir });
        }
        catch {
            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');
    // Serve static assets but skip index.html — the SPA fallback below
    // handles it with token injection (replaces {{CONSOLE_TOKEN}} in the
    // meta tag). Without this, express.static serves the raw template
    // and the browser never gets the auth token (#1780).
    const isDebug = Boolean(process.env.DOLLHOUSE_DEBUG || process.env.ENABLE_DEBUG);
    app.use(express.static(publicDir, {
        index: false,
        // In debug mode, disable caching on all static assets (JS, CSS) so
        // UI changes are picked up on normal reload without Cmd+Shift+R.
        ...(isDebug
            ? { etag: false, lastModified: false, maxAge: 0 }
            : { maxAge: '1y', immutable: true }),
    }));
    // SPA fallback with console token injection (#1780).
    // Reads index.html on first request, substitutes the {{CONSOLE_TOKEN}} placeholder
    // with the current token value, and caches the rendered string. The cache is
    // auto-invalidated when the primary token changes (rotation), so a page reload
    // after rotation picks up the new token without a server restart.
    let cachedIndexHtml = null;
    let cachedTokenValue = null;
    const indexHtmlPath = join(publicDir, 'index.html');
    const renderIndexHtml = async () => {
        const tokenValue = options.tokenStore?.getPrimaryTokenValue() ?? '';
        // Auto-invalidate cache when the token changes (rotation).
        // In debug mode, always re-read from disk so UI changes are picked up on reload.
        if (!isDebug && cachedIndexHtml !== null && cachedTokenValue === tokenValue) {
            return cachedIndexHtml;
        }
        const template = await readFileFs(indexHtmlPath, 'utf8');
        // Defensive HTML attribute escape. Tokens are strict 64-char lowercase hex
        // today so no escaping is actually needed, but if the token format ever
        // changes this prevents an HTML-injection regression from landing silently.
        const escapedToken = tokenValue
            .replaceAll('&', '&')
            .replaceAll('"', '"')
            .replaceAll("'", ''')
            .replaceAll('<', '&lt;')
            .replaceAll('>', '&gt;');
        const escapedSessionId = (options.sessionId ?? '')
            .replaceAll('&', '&amp;')
            .replaceAll('"', '&quot;')
            .replaceAll("'", '&#39;')
            .replaceAll('<', '&lt;')
            .replaceAll('>', '&gt;');
        const escapedRuntimeSessionId = (options.runtimeSessionId ?? '')
            .replaceAll('&', '&amp;')
            .replaceAll('"', '&quot;')
            .replaceAll("'", '&#39;')
            .replaceAll('<', '&lt;')
            .replaceAll('>', '&gt;');
        cachedIndexHtml = template
            .replaceAll(TOKEN_META_PLACEHOLDER, escapedToken)
            .replaceAll(VERSION_META_PLACEHOLDER, PACKAGE_VERSION)
            .replaceAll(SESSION_ID_META_PLACEHOLDER, escapedSessionId)
            .replaceAll(RUNTIME_SESSION_ID_META_PLACEHOLDER, escapedRuntimeSessionId)
            .replaceAll(ASSET_VERSION_META_PLACEHOLDER, PACKAGE_VERSION);
        cachedTokenValue = tokenValue;
        return cachedIndexHtml;
    };
    app.get('/{*path}', async (req, res) => {
        const normalizedPath = req.path.normalize('NFC');
        if (normalizedPath.startsWith('/api/')) {
            res.status(404).json({ error: `API route not found: ${normalizedPath}` });
            return;
        }
        if (normalizedPath.startsWith('/pages/')) {
            res.status(404).json({ error: `Page not found: ${normalizedPath}` });
            return;
        }
        try {
            const html = await renderIndexHtml();
            res.setHeader('Content-Type', 'text/html; charset=utf-8');
            // The shell should always revalidate so a forced reload can pick up
            // a new leader/version immediately. Asset files themselves carry a
            // version query and can be cached aggressively.
            res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
            res.send(html);
        }
        catch (err) {
            logger.error(`[WebUI] Failed to render index.html: ${err.message}`);
            res.status(500).send('Failed to load console');
        }
    });
    // Global error handler — catch Express errors and route to logger instead of terminal.
    // Without this, Express dumps stack traces to stderr (visible in --web terminal).
    // All errors still appear in the management console's Logs tab via MemoryLogSink.
    app.use((err, _req, res, _next) => {
        const status = err.status || err.statusCode || 500;
        logger.warn(`[WebUI] ${err.name}: ${err.message}`);
        if (!res.headersSent) {
            res.status(status).json({ error: err.message });
        }
    });
    // Bind to localhost only — handle port conflicts gracefully.
    // Extracted to a helper to keep startWebServer's cognitive complexity manageable.
    result.bindResult = await bindAndListen(app, port, options);
    return result;
}
/**
 * Mount the logs, metrics, and health routes. These are only mounted when the
 * corresponding sinks are provided (memory log sink for logs+health, metrics
 * sink for the metrics tab). Extracted from startWebServer to cap the main
 * function's cognitive complexity.
 */
function mountConsoleRoutes(app, options, result) {
    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);
    }
}
/**
 * Print the startup banner to stderr.
 *
 * NOTE: Use stderr for terminal output, not stdout. In MCP stdio mode, stdout
 * is reserved for JSON-RPC messages — any non-JSON output corrupts the protocol.
 * stderr is safe for human-readable messages in both MCP and standalone modes.
 */
function printStartupBanner(port, tokenStore) {
    const url = `http://${CONSOLE_HOST}:${port}`;
    const fallbackUrl = `http://127.0.0.1:${port}`;
    logger.info(`[WebUI] Management console running at ${url}`);
    console.error(`\n  DollhouseMCP Management Console\n  ${url}\n  ${fallbackUrl} (fallback)\n`);
    if (tokenStore) {
        console.error(`  Session token: ${tokenStore.getFilePath()}\n`);
    }
    console.error(`  Type "q" or "quit" to exit.\n`);
}
// Stale process recovery — extracted to StaleProcessRecovery.ts for independent testing (#1850).
import { recoverStalePort } from './console/StaleProcessRecovery.js';
export { findPidOnPort, killStaleProcess, recoverStalePort } from './console/StaleProcessRecovery.js';
/**
 * Attempt a single port bind. Returns a BindResult without any recovery logic.
 */
function attemptBind(app, port, options) {
    return new Promise((resolve) => {
        const httpServer = app.listen(port, '127.0.0.1', () => {
            serverRunning = true;
            serverPort = port;
            activeHttpServer = httpServer;
            printStartupBanner(port, options.tokenStore);
            if (options.openBrowser) {
                openInBrowser(`http://${CONSOLE_HOST}:${port}`);
            }
            resolve({ success: true });
        });
        httpServer.on('error', (err) => {
            if (err.code === 'EADDRINUSE') {
                resolve({ success: false, error: 'EADDRINUSE', detail: `Port ${port} already in use` });
            }
            else {
                logger.error(`[WebUI] Failed to bind port ${port}: ${err.message}`);
                resolve({ success: false, error: 'OTHER', detail: err.message });
            }
        });
    });
}
/**
 * Bind the Express app to 127.0.0.1:port. On EADDRINUSE, attempt to find
 * and kill the stale DollhouseMCP process holding the port, then retry once.
 */
async function bindAndListen(app, port, options) {
    const result = await attemptBind(app, port, options);
    if (result.success || result.error !== 'EADDRINUSE')
        return result;
    // Port occupied — attempt stale process recovery and retry
    if (await recoverStalePort(port)) {
        const retryResult = await attemptBind(app, port, options);
        if (retryResult.success)
            return retryResult;
    }
    // Still can't bind — fall through with warning
    logger.warn(`[WebUI] Port ${port} already in use — another process holds this port`);
    console.error(`\n  DollhouseMCP Management Console (existing instance)\n  http://${CONSOLE_HOST}:${port}\n`);
    if (options.openBrowser) {
        openInBrowser(`http://${CONSOLE_HOST}:${port}`);
    }
    return result;
}
/**
 * Self-provision sinks, token store, and ingest routes, then start the web
 * server. Extracted from openPortfolioBrowser to keep cognitive complexity
 * manageable (SonarCloud S3776).
 */
async function startFallbackServer(options, port) {
    let memorySink = options.memorySink;
    let metricsSink = options.metricsSink;
    if (!memorySink) {
        const { MemoryLogSink: LogSink } = await import('../logging/sinks/MemoryLogSink.js');
        memorySink = new LogSink({ appCapacity: 10000, securityCapacity: 5000, perfCapacity: 2000, telemetryCapacity: 1000 });
    }
    if (!metricsSink) {
        const { MemoryMetricsSink: MetricsSink } = await import('../metrics/sinks/MemoryMetricsSink.js');
        metricsSink = new MetricsSink(240);
    }
    // Reuse cached token store — two instances on the same file can race on writes.
    if (!cachedTokenStore) {
        const { ConsoleTokenStore: TokenStore } = await import('./console/consoleToken.js');
        const { pickRandomTokenName } = await import('./console/SessionNames.js');
        cachedTokenStore = new TokenStore(env.DOLLHOUSE_CONSOLE_TOKEN_FILE);
        try {
            await cachedTokenStore.ensureInitialized(pickRandomTokenName());
        }
        catch (err) {
            logger.warn('[WebUI] Failed to init token store for browser open', err);
        }
    }
    // logBroadcast is deferred — wired after startWebServer returns the real broadcast fn.
    let liveBroadcast;
    const { createIngestRoutes } = await import('./console/IngestRoutes.js');
    const ingestResult = createIngestRoutes({
        logBroadcast: (entry) => liveBroadcast?.(entry),
        storeMetricsSnapshot: (snapshot) => metricsSink?.onSnapshot(snapshot),
    });
    ingestResult.registerConsoleSession();
    const webResult = await startWebServer({
        portfolioDir: options.portfolioDir,
        port,
        openBrowser: false,
        mcpAqlHandler: options.mcpAqlHandler,
        memorySink,
        metricsSink,
        tokenStore: cachedTokenStore,
        additionalRouters: [ingestResult.router],
    });
    liveBroadcast = webResult.logBroadcast;
}
export async function openPortfolioBrowser(options) {
    const targetPort = options.port || DEFAULT_PORT;
    const baseUrl = `http://${CONSOLE_HOST}:${targetPort}`;
    // Build URL with optional tab hash and query parameters
    let url = baseUrl;
    if (options.tab) {
        const qs = options.urlParams ? new URLSearchParams(options.urlParams).toString() : '';
        url = `${baseUrl}/#${options.tab}${qs ? '?' + qs : ''}`;
    }
    else if (options.urlParams && Object.keys(options.urlParams).length > 0) {
        const qs = new URLSearchParams(options.urlParams).toString();
        url = `${baseUrl}/#portfolio?${qs}`;
    }
    const alreadyRunning = serverRunning;
    if (!serverRunning) {
        await startFallbackServer(options, targetPort);
    }
    const browserResult = await openInBrowser(url);
    return {
        url,
        alreadyRunning,
        browserOpened: browserResult.success,
        ...(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 * 