@otto-code/server 0.5.0

package/dist/server/server/bootstrap.js

@@ -0,0 +1,1331 @@
+import express from "express";
+import { createServer as createHTTPServer } from "http";
+import { constants, existsSync, unlinkSync } from "fs";
+import { open } from "fs/promises";
+import { randomUUID } from "node:crypto";
+import { hostname as getHostname } from "node:os";
+import path from "node:path";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { z } from "zod";
+import { createBranchChangeRouteHandler } from "./script-route-branch-handler.js";
+function resolveBoundListenTarget(listenTarget, httpServer) {
+    if (listenTarget.type !== "tcp") {
+        return listenTarget;
+    }
+    const address = httpServer.address();
+    if (!address || typeof address === "string") {
+        throw new Error("HTTP server did not expose a TCP address after listening");
+    }
+    return {
+        type: "tcp",
+        host: listenTarget.host,
+        port: address.port,
+    };
+}
+// Matches a Windows drive-letter path like C:\ or D:\
+const WINDOWS_DRIVE_RE = /^[A-Za-z]:\\/;
+export function parseListenString(listen) {
+    // 1. Windows named pipes: \\.\pipe\... or pipe://...
+    if (listen.startsWith("\\\\.\\pipe\\") || listen.startsWith("pipe://")) {
+        return {
+            type: "pipe",
+            path: listen.startsWith("pipe://") ? listen.slice("pipe://".length) : listen,
+        };
+    }
+    // 2. Explicit unix:// prefix
+    if (listen.startsWith("unix://")) {
+        return { type: "socket", path: listen.slice(7) };
+    }
+    // 3. Reject Windows absolute drive paths — they are not Unix sockets
+    if (WINDOWS_DRIVE_RE.test(listen)) {
+        throw new Error(`Invalid listen string (Windows path is not a valid listen target): ${listen}`);
+    }
+    // 4. POSIX absolute path (/ or ~) — Unix socket
+    if (listen.startsWith("/") || listen.startsWith("~")) {
+        return { type: "socket", path: listen };
+    }
+    // 5. Pure numeric — TCP port on 127.0.0.1
+    const trimmed = listen.trim();
+    if (/^\d+$/.test(trimmed)) {
+        const port = parseInt(trimmed, 10);
+        return { type: "tcp", host: "127.0.0.1", port };
+    }
+    // 6. host:port — TCP
+    if (listen.includes(":")) {
+        const lastColonIdx = listen.lastIndexOf(":");
+        const host = listen.slice(0, lastColonIdx);
+        const portStr = listen.slice(lastColonIdx + 1);
+        const parsedPort = parseInt(portStr, 10);
+        if (!Number.isFinite(parsedPort)) {
+            throw new Error(`Invalid port in listen string: ${listen}`);
+        }
+        const cleanHost = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+        return { type: "tcp", host: cleanHost || "127.0.0.1", port: parsedPort };
+    }
+    throw new Error(`Invalid listen string: ${listen}`);
+}
+function formatListenTarget(listenTarget) {
+    if (!listenTarget) {
+        return null;
+    }
+    if (listenTarget.type === "tcp") {
+        return `${listenTarget.host}:${listenTarget.port}`;
+    }
+    return listenTarget.path;
+}
+import { VoiceAssistantWebSocketServer } from "./websocket-server.js";
+import { createGitHubHostingService } from "../services/git-hosting/github-hosting-service.js";
+import { createGitHostingResolver } from "../services/git-hosting/resolver.js";
+import { createGitHostingRouter } from "../services/git-hosting/router.js";
+import { readOttoConfigJson } from "../utils/otto-config-file.js";
+import { createOttoWorktree as createRegisteredOttoWorktree, createLocalCheckoutWorkspace, } from "./otto-worktree-service.js";
+import { createOttoWorktreeWorkflow } from "./worktree-session.js";
+import { DownloadTokenStore } from "./file-download/token-store.js";
+import { createSpeechService } from "./speech/speech-runtime.js";
+import { AgentManager } from "./agent/agent-manager.js";
+import { AgentStorage } from "./agent/agent-storage.js";
+import { PersonalityStatsStore } from "./agent/personality-stats-store.js";
+import { attachAgentStoragePersistence } from "./persistence-hooks.js";
+import { createAgentMcpServer } from "./agent/mcp-server.js";
+import { createOttoToolCatalog } from "./agent/tools/otto-tools.js";
+import { ArtifactService } from "./artifact/artifact-service.js";
+import { DevServerManager } from "./preview/dev-server-manager.js";
+import { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
+import { bootstrapWorkspaceRegistries } from "./workspace-registry-bootstrap.js";
+import { WorkspaceReconciliationService } from "./workspace-reconciliation-service.js";
+import { FileBackedProjectRegistry, FileBackedWorkspaceRegistry } from "./workspace-registry.js";
+import { FileBackedChatService } from "./chat/chat-service.js";
+import { CheckoutDiffManager } from "./checkout-diff-manager.js";
+import { LoopService } from "./loop-service.js";
+import { ScheduleService } from "./schedule/service.js";
+import { DaemonConfigStore } from "./daemon-config-store.js";
+import { BrowserToolsBroker } from "./browser-tools/broker.js";
+import { DaemonConfigBrowserToolsPolicy } from "./browser-tools/policy.js";
+import { WorkspaceGitServiceImpl } from "./workspace-git-service.js";
+import { resolveWorkspaceIdForPath } from "./resolve-workspace-id-for-path.js";
+import { archiveByScope, archivePersistedWorkspaceRecord, killTerminalsForWorkspace, } from "./workspace-archive-service.js";
+import { setupAutoArchiveOnMerge } from "./auto-archive-on-merge/index.js";
+import { wrapSessionMessage } from "./messages.js";
+import { createConfiguredTerminalManager } from "../terminal/terminal-manager-factory.js";
+import { applyTerminalAgentHookSetting } from "../terminal/agent-hooks/terminal-agent-hook-setting.js";
+import { createConnectionOfferV2, encodeOfferToFragmentUrl } from "./connection-offer.js";
+import { loadOrCreateDaemonKeyPair } from "./daemon-keypair.js";
+import { startRelayTransport } from "./relay-transport.js";
+import { getOrCreateServerId } from "./server-id.js";
+import { resolveDaemonVersion } from "./daemon-version.js";
+import { DEFAULT_AGENT_PERSONALITIES } from "@otto-code/protocol/default-personalities";
+import { loadPersistedConfig, } from "./persisted-config.js";
+import { resolveSpeechConfig } from "./speech/speech-config-resolver.js";
+import { DEFAULT_LOCAL_STT_MODEL, DEFAULT_LOCAL_TTS_MODEL, getLocalTtsDefaultSpeakerId, resolveLocalTtsVoiceName, } from "./speech/providers/local/models.js";
+import { createServiceProxySubsystem } from "./service-proxy.js";
+import { ScriptHealthMonitor } from "./script-health-monitor.js";
+import { createScriptStatusEmitter } from "./script-status-projection.js";
+import { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
+import { createManagedProcessRegistry, createSystemManagedProcessTable, } from "./managed-processes/managed-processes.js";
+import { terminateWithTreeKill } from "../utils/tree-kill.js";
+import { isHostnameAllowed } from "./hostnames.js";
+import { createRequireBearerMiddleware, isAgentMcpRequestAuthorized, } from "./auth.js";
+import { createWebUiMiddleware } from "./web-ui.js";
+import { WorkspaceAutoName } from "./workspace-auto-name.js";
+import { createGitMutationService } from "./session/git-mutation/git-mutation-service.js";
+import { workspaceIdsOnCheckout } from "./workspace-directory.js";
+import { resolveFirstAgentPromptTitle } from "./agent/create-agent-title.js";
+import { createAgentCommand, } from "./agent/create-agent/create.js";
+const MAX_MCP_DEBUG_BATCH_ITEMS = 10;
+const REDACTED_LOG_VALUE = "[redacted]";
+const DOWNLOAD_OPEN_FLAGS = process.platform === "win32" ? constants.O_RDONLY : constants.O_RDONLY | constants.O_NOFOLLOW;
+function formatHostForHttpUrl(host) {
+    return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+}
+function resolveAgentMcpClientHost(host) {
+    if (host === "0.0.0.0") {
+        return "127.0.0.1";
+    }
+    if (host === "::" || host === "[::]") {
+        return "::1";
+    }
+    return host;
+}
+function createAgentMcpBaseUrl(listenTarget) {
+    if (!listenTarget || listenTarget.type !== "tcp") {
+        return null;
+    }
+    const host = resolveAgentMcpClientHost(listenTarget.host);
+    return new URL("/mcp/agents", `http://${formatHostForHttpUrl(host)}:${listenTarget.port}`).toString();
+}
+function createTerminalActivityUrl(listenTarget) {
+    if (!listenTarget || listenTarget.type !== "tcp") {
+        return null;
+    }
+    const host = resolveAgentMcpClientHost(listenTarget.host);
+    return new URL("/api/terminal-activity", `http://${formatHostForHttpUrl(host)}:${listenTarget.port}`).toString();
+}
+const TerminalActivityReportSchema = z.object({
+    terminalId: z.string().min(1),
+    token: z.string().min(1),
+    state: z.enum(["running", "idle", "needs-input"]),
+});
+const TERMINAL_ACTIVITY_STATE_MAP = {
+    running: "working",
+    idle: "idle",
+    "needs-input": "attention",
+};
+const LOOPBACK_REMOTE_ADDRESSES = new Set(["127.0.0.1", "::1", "::ffff:127.0.0.1"]);
+function isLoopbackRemoteAddress(remoteAddress) {
+    return remoteAddress !== undefined && LOOPBACK_REMOTE_ADDRESSES.has(remoteAddress);
+}
+export function createTerminalActivityRouteHandler(terminalManager) {
+    return async (req, res) => {
+        if (!isLoopbackRemoteAddress(req.socket.remoteAddress)) {
+            res.status(403).json({ error: "Forbidden" });
+            return;
+        }
+        const parsed = TerminalActivityReportSchema.safeParse(req.body);
+        if (!parsed.success) {
+            res.status(400).json({ error: "Invalid terminal activity report" });
+            return;
+        }
+        const validation = terminalManager.validateTerminalActivityToken(parsed.data.terminalId, parsed.data.token);
+        if (validation !== "valid") {
+            res.status(403).json({ error: "Forbidden" });
+            return;
+        }
+        try {
+            const updated = await terminalManager.setTerminalActivity(parsed.data.terminalId, TERMINAL_ACTIVITY_STATE_MAP[parsed.data.state]);
+            if (!updated) {
+                res.status(403).json({ error: "Forbidden" });
+                return;
+            }
+            res.status(204).end();
+        }
+        catch {
+            res.status(500).json({ error: "Failed to update terminal activity" });
+        }
+    };
+}
+function summarizeAgentMcpDebugMessage(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body)) {
+        return {
+            type: body === null ? "null" : typeof body,
+        };
+    }
+    const record = body;
+    const method = typeof record.method === "string" ? record.method : undefined;
+    return {
+        type: "object",
+        ...(typeof record.jsonrpc === "string" ? { jsonrpc: record.jsonrpc } : {}),
+        ...(method ? { method } : {}),
+        hasId: Object.prototype.hasOwnProperty.call(record, "id"),
+        hasParams: Object.prototype.hasOwnProperty.call(record, "params"),
+    };
+}
+function summarizeAgentMcpDebugBody(body) {
+    if (!Array.isArray(body)) {
+        return summarizeAgentMcpDebugMessage(body);
+    }
+    const messages = body.slice(0, MAX_MCP_DEBUG_BATCH_ITEMS).map(summarizeAgentMcpDebugMessage);
+    return {
+        type: "batch",
+        count: body.length,
+        messages,
+        ...(body.length > messages.length ? { omitted: body.length - messages.length } : {}),
+    };
+}
+function createBootstrapManagedProcessRegistry(config, logger) {
+    if (config.managedProcesses) {
+        return config.managedProcesses;
+    }
+    return createManagedProcessRegistry({
+        ottoHome: config.ottoHome,
+        processTable: createSystemManagedProcessTable(),
+        terminateProcess: terminateWithTreeKill,
+        logger,
+    });
+}
+async function reconcileManagedProcessLedger(managedProcesses, logger) {
+    const reapResult = await managedProcesses.reapStale();
+    if (reapResult.checked > 0 || reapResult.errors.length > 0) {
+        logger.info(reapResult, "Managed helper process ledger reconciled");
+    }
+}
+function mountWebUi(app, config, logger) {
+    app.use(createWebUiMiddleware({
+        enabled: config.webUi?.enabled ?? false,
+        distDir: config.webUi?.distDir ?? null,
+        label: getHostname(),
+        logger,
+    }));
+}
+function resolveExpressTrustProxySetting(config) {
+    return config.trustedProxies ?? ["loopback"];
+}
+function initialMutableSttConfig(input) {
+    const model = input.provider === "local" ? input.localModel : input.openaiModel;
+    return {
+        provider: input.provider,
+        ...(model ? { model } : {}),
+        ...(input.language ? { language: input.language } : {}),
+    };
+}
+function initialMutableTtsConfig(input) {
+    if (input.provider !== "local") {
+        return {
+            provider: input.provider,
+            ...(input.openai.model ? { model: input.openai.model } : {}),
+            ...(input.openai.voice ? { voice: input.openai.voice } : {}),
+        };
+    }
+    return {
+        provider: input.provider,
+        model: input.local.model,
+        ...(input.local.voice ? { voice: input.local.voice } : {}),
+        ...(input.local.speed !== undefined ? { speed: input.local.speed } : {}),
+    };
+}
+function collectInitialMutableSpeechInputs(config) {
+    return {
+        requested: config.speech?.providers,
+        localModels: config.speech?.local?.models,
+        openai: config.openai,
+        languages: {
+            dictation: config.speech?.sttLanguages?.dictation,
+            voice: config.speech?.sttLanguages?.voice,
+        },
+    };
+}
+function initialMutableDictationSection(inputs) {
+    return {
+        enabled: inputs.requested?.dictationStt.enabled !== false,
+        stt: initialMutableSttConfig({
+            provider: inputs.requested?.dictationStt.provider ?? "local",
+            localModel: inputs.localModels?.dictationStt ?? DEFAULT_LOCAL_STT_MODEL,
+            openaiModel: inputs.openai?.stt?.model,
+            language: inputs.languages.dictation,
+        }),
+    };
+}
+function resolveInitialLocalTtsSelection(localModels) {
+    const model = localModels?.voiceTts ?? DEFAULT_LOCAL_TTS_MODEL;
+    const voice = resolveLocalTtsVoiceName(model, localModels?.voiceTtsSpeakerId ?? getLocalTtsDefaultSpeakerId(model));
+    return { model, voice, speed: localModels?.voiceTtsSpeed };
+}
+function initialMutableVoiceModeSection(inputs) {
+    const voiceTtsEnabled = inputs.requested?.voiceTts.enabled !== false;
+    const voiceSttEnabled = inputs.requested?.voiceStt.enabled !== false;
+    return {
+        enabled: voiceTtsEnabled || voiceSttEnabled,
+        stt: initialMutableSttConfig({
+            provider: inputs.requested?.voiceStt.provider ?? "local",
+            localModel: inputs.localModels?.voiceStt ?? DEFAULT_LOCAL_STT_MODEL,
+            openaiModel: inputs.openai?.stt?.model,
+            language: inputs.languages.voice,
+        }),
+        tts: initialMutableTtsConfig({
+            provider: inputs.requested?.voiceTts.provider ?? "local",
+            local: resolveInitialLocalTtsSelection(inputs.localModels),
+            openai: { model: inputs.openai?.tts?.model, voice: inputs.openai?.tts?.voice },
+        }),
+    };
+}
+// The mutable speech section mirrors the resolved speech config so clients see
+// effective values (defaults included), not just what config.json happens to pin.
+function createInitialMutableSpeechConfig(config) {
+    const inputs = collectInitialMutableSpeechInputs(config);
+    // Only the key stored in config.json is echoed to clients — an env-only key
+    // (OPENAI_API_KEY) stays out of the mutable config so unrelated speech
+    // patches can never copy it onto disk.
+    const persistedOpenAiApiKey = loadPersistedConfig(config.ottoHome).providers?.openai?.apiKey;
+    return {
+        dictation: initialMutableDictationSection(inputs),
+        voiceMode: initialMutableVoiceModeSection(inputs),
+        ...(persistedOpenAiApiKey ? { openai: { apiKey: persistedOpenAiApiKey } } : {}),
+    };
+}
+function createInitialMutableDaemonConfig(config) {
+    const providers = Object.fromEntries(Object.entries(config.providerOverrides ?? {}).map(([providerId, override]) => {
+        // Carry the full override so clients can inspect and edit custom
+        // provider config (extends, env, models). The provider config schema is
+        // passthrough, and persistence re-validates via ProviderOverrideSchema.
+        const providerConfig = { ...override };
+        return [providerId, providerConfig];
+    }));
+    // Per-project git hosting credentials round-trip config.json ⇄ mutable
+    // config the same way the speech OpenAI key does.
+    const persistedGitHosting = loadPersistedConfig(config.ottoHome).gitHosting;
+    const initialConfig = {
+        mcp: { injectIntoAgents: config.mcpInjectIntoAgents ?? true },
+        browserTools: { enabled: config.browserToolsEnabled ?? false },
+        providers,
+        metadataGeneration: {
+            providers: config.metadataGeneration?.providers ?? [],
+        },
+        autoArchiveAfterMerge: config.autoArchiveAfterMerge ?? false,
+        enableTerminalAgentHooks: config.enableTerminalAgentHooks ?? false,
+        appendSystemPrompt: config.appendSystemPrompt ?? "",
+        speech: createInitialMutableSpeechConfig(config),
+        ...(persistedGitHosting ? { gitHosting: persistedGitHosting } : {}),
+        agentPersonalities: {
+            // A host that has never carried a personalities section (undefined, not an
+            // empty roster the user cleared) is seeded with the shipped starter team so
+            // a fresh install opens with a working, role-complete roster. The one-time
+            // seed is also recorded on disk right after the store is built (see
+            // seedDefaultPersonalitiesIfAbsent) so clearing the whole team sticks.
+            personalities: config.agentPersonalities === undefined
+                ? [...DEFAULT_AGENT_PERSONALITIES]
+                : (config.agentPersonalities.personalities ?? []),
+        },
+    };
+    if (config.terminalProfiles !== undefined) {
+        initialConfig.terminalProfiles = config.terminalProfiles;
+    }
+    return initialConfig;
+}
+export async function createOttoDaemon(config, rootLogger) {
+    const logger = rootLogger.child({ module: "bootstrap" });
+    const bootstrapStart = performance.now();
+    const elapsed = () => `${(performance.now() - bootstrapStart).toFixed(0)}ms`;
+    const daemonVersion = resolveDaemonVersion(import.meta.url);
+    const daemonConfigStore = new DaemonConfigStore(config.ottoHome, createInitialMutableDaemonConfig(config), logger);
+    // Record the first-run seed on disk so the shipped starter team survives a
+    // restart AND a subsequent "delete every personality" stays deleted.
+    daemonConfigStore.seedDefaultPersonalitiesIfAbsent(DEFAULT_AGENT_PERSONALITIES);
+    const browserToolsPolicy = new DaemonConfigBrowserToolsPolicy(daemonConfigStore);
+    const browserToolsBroker = new BrowserToolsBroker({});
+    const previewDevServers = new DevServerManager({ logger });
+    const serverId = getOrCreateServerId(config.ottoHome, { logger });
+    const daemonKeyPair = await loadOrCreateDaemonKeyPair(config.ottoHome, logger);
+    const managedProcesses = createBootstrapManagedProcessRegistry(config, logger);
+    // Reconcile the helper-process ledger in the background so it never blocks the
+    // daemon from coming up; terminating a live leftover can take a few seconds.
+    // Best-effort, so a failure is logged here rather than crashing startup.
+    void reconcileManagedProcessLedger(managedProcesses, logger).catch((error) => {
+        logger.warn({ err: error }, "Failed to reconcile managed helper process ledger");
+    });
+    let relayTransport = null;
+    const staticDir = config.staticDir;
+    const downloadTokenTtlMs = config.downloadTokenTtlMs ?? 60000;
+    const downloadTokenStore = new DownloadTokenStore({
+        ttlMs: downloadTokenTtlMs,
+    });
+    // Capability token authenticating the daemon's own agents to the loopback
+    // Agent MCP endpoint (/mcp/agents). Random per daemon run, injected only into
+    // local agent configs and the daemon's own MCP client — never sent to remote
+    // clients — so it cannot be replayed off-box. This lets the injected MCP
+    // authenticate even when the daemon password is set via the app (hash only,
+    // no plaintext available). Mirrors the /api/files/download capability-token
+    // pattern.
+    const agentMcpAuthToken = randomUUID();
+    const listenTarget = parseListenString(config.listen);
+    const app = express();
+    app.set("trust proxy", resolveExpressTrustProxySetting(config));
+    let boundListenTarget = null;
+    let workspaceRegistry = null;
+    const terminalManager = createConfiguredTerminalManager({
+        getTerminalActivityUrl: () => createTerminalActivityUrl(boundListenTarget),
+    });
+    applyTerminalAgentHookSetting({ store: daemonConfigStore, logger });
+    const serviceProxyPublicBaseUrl = config.serviceProxy?.publicBaseUrl
+        ? config.serviceProxy.publicBaseUrl
+        : null;
+    const serviceProxy = createServiceProxySubsystem({
+        logger,
+        publicBaseUrl: serviceProxyPublicBaseUrl,
+    });
+    const scriptRuntimeStore = new WorkspaceScriptRuntimeStore();
+    const configuredHostnames = config.hostnames ?? config.allowedHosts;
+    let wsServer = null;
+    let serviceProxyListenTarget = null;
+    const scriptHealthMonitor = new ScriptHealthMonitor({
+        serviceProxy,
+        onChange: createScriptStatusEmitter({
+            sessions: () => wsServer?.listActiveSessions().map((session) => ({
+                emit: (message) => session.emitServerMessage(message),
+            })) ?? [],
+            serviceProxy,
+            runtimeStore: scriptRuntimeStore,
+            daemonPort: () => (boundListenTarget?.type === "tcp" ? boundListenTarget.port : null),
+            resolveWorkspaceDirectory: async (workspaceId) => (await workspaceRegistry?.get(workspaceId))?.cwd ?? null,
+            logger,
+            serviceProxyPublicBaseUrl,
+        }),
+    });
+    const handleBranchChange = createBranchChangeRouteHandler({
+        serviceProxy,
+        onRoutesChanged: (workspaceId) => {
+            scriptHealthMonitor.invalidateWorkspace(workspaceId);
+        },
+        logger,
+    });
+    // Service proxy classifies service hosts before daemon auth/route fallthrough.
+    // Registered service hosts proxy directly; known service namespaces without a
+    // route return 404 and never reach daemon APIs.
+    app.use(serviceProxy.middleware());
+    // Host allowlist / DNS rebinding protection (vite-like semantics).
+    // For non-TCP (unix sockets), skip host validation.
+    if (listenTarget.type === "tcp") {
+        app.use((req, res, next) => {
+            const hostHeader = typeof req.headers.host === "string" ? req.headers.host : undefined;
+            if (!isHostnameAllowed(hostHeader, configuredHostnames)) {
+                res.status(403).json({ error: "Invalid Host header" });
+                return;
+            }
+            next();
+        });
+    }
+    // CORS - allow same-origin + configured origins
+    const allowedOrigins = new Set([
+        ...config.corsAllowedOrigins,
+        // Packaged desktop renderers use the custom otto:// protocol scheme.
+        "otto://app",
+        // For TCP, add localhost variants
+        ...(listenTarget.type === "tcp"
+            ? [
+                `http://${listenTarget.host}:${listenTarget.port}`,
+                `http://localhost:${listenTarget.port}`,
+                `http://127.0.0.1:${listenTarget.port}`,
+            ]
+            : []),
+    ]);
+    app.use((req, res, next) => {
+        const origin = req.headers.origin;
+        if (origin && (allowedOrigins.has("*") || allowedOrigins.has(origin))) {
+            res.setHeader("Access-Control-Allow-Origin", origin);
+            res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+            res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+            res.setHeader("Access-Control-Allow-Credentials", "true");
+        }
+        if (req.method === "OPTIONS") {
+            res.status(204).end();
+            return;
+        }
+        next();
+    });
+    // Local, harmless, and token-gated; deliberately skips daemon auth.
+    app.post("/api/terminal-activity", express.json(), createTerminalActivityRouteHandler(terminalManager));
+    // Serve the bundled browser web UI when enabled. Mounted after service-proxy
+    // classification and host/CORS handling, but before daemon bearer auth, so
+    // static app files load without the daemon password while API/WebSocket calls
+    // remain protected.
+    mountWebUi(app, config, logger);
+    app.use(createRequireBearerMiddleware(config.auth, (context) => {
+        logger.warn(context, "Rejected HTTP request with invalid daemon password");
+    }));
+    app.use(express.json());
+    // Serve static files from public directory
+    app.use("/public", express.static(staticDir));
+    // Health check endpoint
+    app.get("/api/health", (_req, res) => {
+        res.json({ status: "ok", timestamp: new Date().toISOString() });
+    });
+    app.get("/api/status", (_req, res) => {
+        res.json({
+            status: "server_info",
+            serverId,
+            hostname: getHostname(),
+            version: daemonVersion,
+            listen: formatListenTarget(boundListenTarget ?? listenTarget),
+        });
+    });
+    const handleFileDownload = async (req, res) => {
+        const token = typeof req.query.token === "string" && req.query.token.trim().length > 0
+            ? req.query.token.trim()
+            : null;
+        if (!token) {
+            res.status(400).json({ error: "Missing download token" });
+            return;
+        }
+        const entry = downloadTokenStore.consumeToken(token);
+        if (!entry) {
+            res.status(403).json({ error: "Invalid or expired token" });
+            return;
+        }
+        let fileHandle = null;
+        try {
+            fileHandle = await open(entry.absolutePath, DOWNLOAD_OPEN_FLAGS);
+            const fileStats = await fileHandle.stat();
+            if (!fileStats.isFile()) {
+                res.status(404).json({ error: "File not found" });
+                return;
+            }
+            const safeFileName = entry.fileName.replace(/["\r\n]/g, "_");
+            res.setHeader("Content-Type", entry.mimeType);
+            res.setHeader("Content-Disposition", `attachment; filename="${safeFileName}"`);
+            res.setHeader("Content-Length", fileStats.size.toString());
+            const stream = fileHandle.createReadStream();
+            fileHandle = null;
+            stream.on("error", (err) => {
+                logger.error({ err }, "Failed to stream download");
+                if (!res.headersSent) {
+                    res.status(500).json({ error: "Failed to read file" });
+                }
+                else {
+                    res.end();
+                }
+            });
+            stream.pipe(res);
+        }
+        catch (err) {
+            logger.error({ err }, "Failed to download file");
+            if (!res.headersSent) {
+                res.status(404).json({ error: "File not found" });
+            }
+        }
+        finally {
+            await fileHandle?.close().catch(() => undefined);
+        }
+    };
+    app.get("/api/files/download", (req, res) => {
+        void handleFileDownload(req, res);
+    });
+    const httpServer = createHTTPServer(app);
+    // Script proxy WebSocket upgrade handler — must be registered before the
+    // VoiceAssistantWebSocketServer attaches its own "upgrade" listener so that
+    // script-bound upgrades are forwarded first. The handler is a no-op for
+    // requests that don't match a registered script route.
+    httpServer.on("upgrade", serviceProxy.upgradeHandler({ passthroughUnknown: true }));
+    if (config.serviceProxy?.standaloneListen) {
+        serviceProxyListenTarget = parseListenString(config.serviceProxy.standaloneListen);
+    }
+    const agentStorage = new AgentStorage(config.agentStoragePath, logger);
+    const personalityStatsStore = new PersonalityStatsStore(path.join(config.ottoHome, "stats", "personality-usage.json"), logger);
+    const projectRegistry = new FileBackedProjectRegistry(path.join(config.ottoHome, "projects", "projects.json"), logger);
+    workspaceRegistry = new FileBackedWorkspaceRegistry(path.join(config.ottoHome, "projects", "workspaces.json"), logger);
+    const chatService = new FileBackedChatService({
+        ottoHome: config.ottoHome,
+        logger,
+    });
+    // All PR/issue functionality routes through the git hosting layer: each
+    // call resolves the target project's configured provider (GitHub via gh
+    // CLI, Bitbucket Cloud via REST). `github` keeps its historical name — it
+    // is the provider-routing facade, not the gh CLI.
+    const gitHostingResolver = createGitHostingResolver({
+        github: createGitHubHostingService(),
+        getDaemonConfig: () => daemonConfigStore.get(),
+        readOttoConfigJson,
+        ottoHome: config.ottoHome,
+    });
+    const github = createGitHostingRouter(gitHostingResolver);
+    const unsubscribeGitHostingConfigChange = daemonConfigStore.onChange(() => {
+        // Provider credentials may have changed; re-resolve on next use.
+        gitHostingResolver.invalidateAll();
+    });
+    const workspaceGitService = new WorkspaceGitServiceImpl({
+        logger,
+        ottoHome: config.ottoHome,
+        worktreesRoot: config.worktreesRoot,
+        deps: {
+            github,
+            resolveHostingForCwd: async (cwd) => {
+                const resolved = await gitHostingResolver.resolveForCwd(cwd);
+                return {
+                    providerId: resolved.providerId,
+                    capabilities: resolved.capabilities,
+                    credentialsMissing: resolved.credentialsMissing,
+                };
+            },
+        },
+    });
+    const providerSnapshotLogger = logger.child({ module: "provider-snapshot-manager" });
+    const providerSnapshotManager = new ProviderSnapshotManager({
+        logger: providerSnapshotLogger,
+        runtimeSettings: config.agentProviderSettings,
+        providerOverrides: config.providerOverrides,
+        workspaceGitService,
+        managedProcesses,
+        isDev: config.isDev === true,
+        extraClients: config.agentClients,
+    });
+    const initialAgentManagerState = providerSnapshotManager.getAgentManagerProviderState();
+    const agentManager = new AgentManager({
+        clients: initialAgentManagerState.clients,
+        providerDefinitions: initialAgentManagerState.providerDefinitions,
+        registry: agentStorage,
+        appendSystemPrompt: config.appendSystemPrompt,
+        onWorkspaceStateMayHaveChanged: ({ cwd }) => {
+            workspaceGitService.onWorkspaceStateMayHaveChanged(cwd);
+        },
+        // Counted at the createAgent choke point so composer, MCP create_agent,
+        // and schedule spawns all land in the per-personality usage stats.
+        onPersonalitySpawn: (personalityId) => {
+            void personalityStatsStore.increment(personalityId);
+        },
+        mcpAuthToken: agentMcpAuthToken,
+        logger,
+    });
+    const detachAgentStoragePersistence = attachAgentStoragePersistence(logger, agentManager, agentStorage);
+    await agentStorage.initialize();
+    logger.info({ elapsed: elapsed() }, "Agent storage initialized");
+    await bootstrapWorkspaceRegistries({
+        ottoHome: config.ottoHome,
+        agentStorage,
+        projectRegistry,
+        workspaceRegistry,
+        workspaceGitService,
+        logger,
+    });
+    logger.info({ elapsed: elapsed() }, "Workspace registries bootstrapped");
+    const workspaceReconciliation = new WorkspaceReconciliationService({
+        projectRegistry,
+        workspaceRegistry,
+        logger,
+        workspaceGitService,
+    });
+    void (async () => {
+        try {
+            const result = await workspaceReconciliation.runOnce();
+            logger.info({
+                elapsed: elapsed(),
+                changeCount: result.changesApplied.length,
+            }, "Workspace registries reconciled");
+        }
+        catch (error) {
+            logger.error({ err: error }, "Background workspace reconciliation failed");
+        }
+    })();
+    await chatService.initialize();
+    logger.info({ elapsed: elapsed() }, "Chat service initialized");
+    const checkoutDiffManager = new CheckoutDiffManager({
+        logger,
+        ottoHome: config.ottoHome,
+        workspaceGitService,
+    });
+    const archiveWorkspaceRecordExternal = async (workspaceId) => {
+        const sessions = wsServer?.listActiveSessions() ?? [];
+        if (sessions.length > 0) {
+            await Promise.all(sessions.map((session) => session.archiveWorkspaceRecordForExternalMutation(workspaceId)));
+            return;
+        }
+        await archivePersistedWorkspaceRecord({
+            workspaceId,
+            workspaceRegistry,
+        });
+    };
+    // external path→workspace adapter, not ownership: archive-by-path requests that
+    // arrive with a worktree path and no workspaceId (old clients / CLI).
+    const findWorkspaceIdForCwdExternal = async (cwd) => {
+        return resolveWorkspaceIdForPath(cwd, await workspaceRegistry.list());
+    };
+    const ensureWorkspaceForCreateExternal = async (cwd, firstAgentContext) => {
+        const workspace = await createLocalCheckoutWorkspace({ cwd, title: resolveFirstAgentPromptTitle(firstAgentContext) }, { projectRegistry, workspaceRegistry, workspaceGitService });
+        if (firstAgentContext) {
+            workspaceAutoName.scheduleForDirectory({
+                workspaceId: workspace.workspaceId,
+                cwd: workspace.cwd,
+                firstAgentContext,
+            });
+        }
+        return workspace.workspaceId;
+    };
+    const listActiveWorkspacesExternal = async () => {
+        const workspaces = await workspaceRegistry.list();
+        return workspaces
+            .filter((workspace) => !workspace.archivedAt)
+            .map((workspace) => ({
+            workspaceId: workspace.workspaceId,
+            cwd: workspace.cwd,
+            kind: workspace.kind,
+        }));
+    };
+    const markWorkspaceArchivingExternal = (workspaceIds, archivingAt) => {
+        const workspaceIdList = Array.from(workspaceIds);
+        for (const session of wsServer?.listActiveSessions() ?? []) {
+            session.markWorkspaceArchivingForExternalMutation(workspaceIdList, archivingAt);
+        }
+    };
+    const clearWorkspaceArchivingExternal = (workspaceIds) => {
+        const workspaceIdList = Array.from(workspaceIds);
+        for (const session of wsServer?.listActiveSessions() ?? []) {
+            session.clearWorkspaceArchivingForExternalMutation(workspaceIdList);
+        }
+    };
+    const emitWorkspaceUpdatesExternal = async (workspaceIds) => {
+        const workspaceIdList = Array.from(workspaceIds);
+        await Promise.all((wsServer?.listActiveSessions() ?? []).map((session) => session.emitWorkspaceUpdatesForExternalWorkspaceIds(workspaceIdList)));
+    };
+    const ensureWorkspaceForCreateAndBroadcastExternal = async (cwd, firstAgentContext) => {
+        const workspaceId = await ensureWorkspaceForCreateExternal(cwd, firstAgentContext);
+        await emitWorkspaceUpdatesExternal([workspaceId]);
+        return workspaceId;
+    };
+    const emitWorkspaceUpdateForCwdExternal = async (cwd) => {
+        const workspaceIds = workspaceIdsOnCheckout(await workspaceRegistry.list(), cwd);
+        await emitWorkspaceUpdatesExternal(workspaceIds);
+    };
+    const emitExternalSessionMessage = (message) => {
+        wsServer?.broadcast(wrapSessionMessage(message));
+    };
+    // Daemon-global artifact service backing the create_artifact agent tool.
+    // Client-initiated artifact RPCs go through each session's own service
+    // instance; both share the same file-backed store under $OTTO_HOME. Status
+    // notifications broadcast to every client so artifacts created by agents
+    // show up live everywhere.
+    const toolArtifactService = new ArtifactService({
+        projectCwd: config.ottoHome,
+        logger,
+        agentManager,
+        providerSnapshotManager,
+        broadcastArtifactUpdate: (metadata) => {
+            emitExternalSessionMessage({
+                type: "artifact.updated.notification",
+                payload: { artifact: metadata },
+            });
+        },
+    });
+    const workspaceAutoName = new WorkspaceAutoName({
+        agentManager,
+        workspaceRegistry,
+        workspaceGitService,
+        providerSnapshotManager,
+        readDaemonConfig: () => ({ metadataGeneration: daemonConfigStore.get().metadataGeneration }),
+        gitMutation: createGitMutationService({
+            workspaceGitService,
+            github,
+            logger,
+        }),
+        emitWorkspaceUpdateForCwd: emitWorkspaceUpdateForCwdExternal,
+        emitWorkspaceUpdateForWorkspaceId: async (workspaceId) => {
+            await emitWorkspaceUpdatesExternal([workspaceId]);
+        },
+        logger,
+    });
+    setupAutoArchiveOnMerge({
+        ottoHome: config.ottoHome,
+        ottoWorktreesBaseRoot: config.worktreesRoot,
+        daemonConfigStore,
+        workspaceGitService,
+        github,
+        agentManager,
+        agentStorage,
+        terminalManager,
+        logger,
+        findWorkspaceIdForCwd: findWorkspaceIdForCwdExternal,
+        listActiveWorkspaces: listActiveWorkspacesExternal,
+        archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
+        markWorkspaceArchiving: markWorkspaceArchivingExternal,
+        clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
+        emitWorkspaceUpdatesForWorkspaceIds: emitWorkspaceUpdatesExternal,
+    });
+    const createOttoWorktreeForTools = async (input, serviceOptions) => {
+        return createOttoWorktreeWorkflow({
+            ottoHome: config.ottoHome,
+            worktreesRoot: config.worktreesRoot,
+            createOttoWorktree: async (workflowInput, workflowOptions) => {
+                return createRegisteredOttoWorktree(workflowInput, {
+                    github,
+                    ...(workflowOptions?.resolveDefaultBranch
+                        ? {
+                            resolveDefaultBranch: workflowOptions.resolveDefaultBranch,
+                        }
+                        : {}),
+                    projectRegistry,
+                    workspaceRegistry,
+                    workspaceGitService,
+                });
+            },
+            warmWorkspaceGitData: async (workspace) => {
+                await Promise.all(wsServer
+                    ?.listActiveSessions()
+                    .map((session) => session.warmWorkspaceGitDataForWorkspace(workspace)) ?? []);
+            },
+            autoNameWorkspaceBranchForFirstAgent: (autoNameInput) => workspaceAutoName.scheduleForWorktree(autoNameInput),
+            emitWorkspaceUpdateForWorkspaceId: async (workspaceId) => {
+                await emitWorkspaceUpdatesExternal([workspaceId]);
+            },
+            cacheWorkspaceSetupSnapshot: () => { },
+            emit: emitExternalSessionMessage,
+            sessionLogger: logger,
+            terminalManager,
+            archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
+            serviceProxy,
+            scriptRuntimeStore,
+            getDaemonTcpPort: () => (boundListenTarget?.type === "tcp" ? boundListenTarget.port : null),
+            getDaemonTcpHost: () => (boundListenTarget?.type === "tcp" ? boundListenTarget.host : null),
+            serviceProxyPublicBaseUrl,
+            onScriptsChanged: null,
+        }, input, serviceOptions);
+    };
+    const createAgentCommandDependencies = {
+        agentManager,
+        agentStorage,
+        logger,
+        ottoHome: config.ottoHome,
+        worktreesRoot: config.worktreesRoot,
+        terminalManager,
+        providerSnapshotManager,
+        createOttoWorktree: createOttoWorktreeForTools,
+        ensureWorkspaceForCreate: ensureWorkspaceForCreateAndBroadcastExternal,
+    };
+    const createAgent = (input) => createAgentCommand(createAgentCommandDependencies, input);
+    const loopService = new LoopService({
+        ottoHome: config.ottoHome,
+        logger,
+        agentManager,
+        createAgent,
+        ensureWorkspaceForCreate: ensureWorkspaceForCreateAndBroadcastExternal,
+    });
+    await loopService.initialize();
+    logger.info({ elapsed: elapsed() }, "Loop service initialized");
+    const createScheduleLocalWorkspaceExternal = async (input) => {
+        const workspace = await createLocalCheckoutWorkspace({ cwd: input.cwd, title: resolveFirstAgentPromptTitle(input.firstAgentContext) }, { projectRegistry, workspaceRegistry, workspaceGitService });
+        workspaceAutoName.scheduleForDirectory({
+            workspaceId: workspace.workspaceId,
+            cwd: workspace.cwd,
+            firstAgentContext: input.firstAgentContext,
+        });
+        await emitWorkspaceUpdatesExternal([workspace.workspaceId]);
+        return workspace;
+    };
+    const createScheduleOttoWorktreeExternal = async (input) => {
+        const result = await createOttoWorktreeForTools({
+            cwd: input.cwd,
+            firstAgentContext: input.firstAgentContext,
+        });
+        await emitWorkspaceUpdatesExternal([result.workspace.workspaceId]);
+        return result;
+    };
+    const archiveScheduleWorkspaceExternal = async (workspaceId, repoRoot) => {
+        await archiveByScope({
+            ottoHome: config.ottoHome,
+            ottoWorktreesBaseRoot: config.worktreesRoot,
+            github,
+            workspaceGitService,
+            agentManager,
+            agentStorage,
+            findWorkspaceIdForCwd: findWorkspaceIdForCwdExternal,
+            listActiveWorkspaces: listActiveWorkspacesExternal,
+            archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
+            emitWorkspaceUpdatesForWorkspaceIds: emitWorkspaceUpdatesExternal,
+            markWorkspaceArchiving: markWorkspaceArchivingExternal,
+            clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
+            killTerminalsForWorkspace: (workspaceIdToKill) => killTerminalsForWorkspace({
+                terminalManager,
+                sessionLogger: logger,
+            }, workspaceIdToKill),
+            sessionLogger: logger,
+        }, {
+            scope: { kind: "workspace", workspaceId },
+            repoRoot,
+            ottoWorktreesBaseRoot: config.worktreesRoot,
+            requestId: "schedule-run-finish",
+        });
+    };
+    const scheduleService = new ScheduleService({
+        ottoHome: config.ottoHome,
+        logger,
+        agentManager,
+        agentStorage,
+        createAgent,
+        createLocalCheckoutWorkspace: createScheduleLocalWorkspaceExternal,
+        createOttoWorktreeWorkspace: createScheduleOttoWorktreeExternal,
+        archiveWorkspace: archiveScheduleWorkspaceExternal,
+        providerSnapshotManager,
+        readAgentPersonalities: () => daemonConfigStore.get().agentPersonalities?.personalities ?? [],
+    });
+    await scheduleService.start();
+    agentManager.setAgentArchivedCallback(async (agentId) => {
+        try {
+            await scheduleService.completeForAgent(agentId);
+        }
+        catch (error) {
+            logger.warn({ err: error, agentId }, "Failed to complete schedules for archived agent");
+        }
+    });
+    logger.info({ elapsed: elapsed() }, "Schedule service initialized");
+    logger.info({ elapsed: elapsed() }, "Loading persisted agent registry");
+    const persistedRecords = await agentStorage.list();
+    logger.info({ elapsed: elapsed() }, `Agent registry loaded (${persistedRecords.length} record${persistedRecords.length === 1 ? "" : "s"}); agents will initialize on demand`);
+    logger.info("Voice mode configured for agent-scoped resume flow (no dedicated voice assistant provider)");
+    logger.info({ elapsed: elapsed() }, "Preparing voice and MCP runtime");
+    const createAgentToolHostDependencies = (runtime) => ({
+        agentManager,
+        agentStorage,
+        terminalManager,
+        getDaemonTcpPort: () => (boundListenTarget?.type === "tcp" ? boundListenTarget.port : null),
+        scheduleService,
+        providerSnapshotManager,
+        readAgentPersonalities: () => daemonConfigStore.get().agentPersonalities?.personalities ?? [],
+        github,
+        workspaceGitService,
+        findWorkspaceIdForCwd: findWorkspaceIdForCwdExternal,
+        listActiveWorkspaces: listActiveWorkspacesExternal,
+        archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
+        emitWorkspaceUpdatesForWorkspaceIds: emitWorkspaceUpdatesExternal,
+        workspaceRegistry,
+        projectRegistry,
+        markWorkspaceArchiving: markWorkspaceArchivingExternal,
+        clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
+        ensureWorkspaceForCreate: createAgentCommandDependencies.ensureWorkspaceForCreate,
+        createOttoWorktree: createAgentCommandDependencies.createOttoWorktree,
+        browserToolsEnabled: browserToolsPolicy.isEnabled(),
+        browserToolsBroker,
+        previewDevServers,
+        artifactService: toolArtifactService,
+        emitArtifactCreated: (artifact) => {
+            emitExternalSessionMessage({
+                type: "artifact.created.notification",
+                payload: { artifact },
+            });
+        },
+        emitArtifactUpdated: (artifact) => {
+            emitExternalSessionMessage({
+                type: "artifact.updated.notification",
+                payload: { artifact },
+            });
+        },
+        ottoHome: config.ottoHome,
+        worktreesRoot: config.worktreesRoot,
+        callerAgentId: runtime.callerAgentId,
+        enableVoiceTools: runtime.enableVoiceTools,
+        voiceOnly: runtime.voiceOnly,
+        resolveSpeakHandler: (agentId) => wsServer?.resolveVoiceSpeakHandler(agentId) ?? null,
+        resolveCallerContext: (agentId) => wsServer?.resolveVoiceCallerContext(agentId) ?? null,
+        logger,
+    });
+    const createAgentToolCatalog = (runtime) => createOttoToolCatalog(createAgentToolHostDependencies(runtime));
+    agentManager.setOttoToolCatalogFactory(createAgentToolCatalog);
+    agentManager.setOttoToolsEnabled(config.mcpInjectIntoAgents !== false);
+    const mcpEnabled = config.mcpEnabled ?? true;
+    let agentMcpBaseUrl = null;
+    if (mcpEnabled) {
+        const agentMcpRoute = "/mcp/agents";
+        const createAgentMcpSession = async (callerAgentId) => {
+            const agentMcpServer = await createAgentMcpServer(createAgentToolHostDependencies({ callerAgentId }));
+            // Stateless mode: each HTTP request builds a fresh server + transport that is
+            // torn down when the response closes, so no per-session state is retained between
+            // requests. The agent control plane only lists and calls tools, neither of which
+            // needs cross-request state, so sessions would only pin memory for the life of the
+            // daemon (agents that exit without a clean DELETE never get reaped).
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+                // NOTE: We enforce a Vite-like host allowlist at the app/websocket layer.
+                // StreamableHTTPServerTransport's built-in check requires exact Host header matches.
+                enableDnsRebindingProtection: false,
+            });
+            Object.assign(transport, {
+                onerror: (err) => {
+                    logger.error({ err }, "Agent MCP transport error");
+                },
+            });
+            await agentMcpServer.connect(transport);
+            return { server: agentMcpServer, transport };
+        };
+        const runAgentMcpRequest = async (req, res) => {
+            // This route is exempt from the global daemon-password middleware, so it
+            // authenticates here using the injected capability token (or a valid
+            // daemon password). Without this, a password-protected daemon would be
+            // wide open on its agent control plane.
+            if (!(await isAgentMcpRequestAuthorized({
+                password: config.auth?.password,
+                capabilityToken: agentMcpAuthToken,
+                authorizationHeader: req.header("authorization"),
+            }))) {
+                res.status(401).json({ error: "Unauthorized" });
+                return;
+            }
+            if (config.mcpDebug) {
+                logger.debug({
+                    method: req.method,
+                    url: req.originalUrl,
+                    sessionId: req.header("mcp-session-id"),
+                    authorization: req.header("authorization") ? REDACTED_LOG_VALUE : undefined,
+                    body: summarizeAgentMcpDebugBody(req.body),
+                }, "Agent MCP request");
+            }
+            try {
+                // Stateless: GET (standalone SSE) and DELETE (session termination) have no
+                // meaning without sessions. The MCP client tolerates 405 on the GET stream
+                // and never issues a DELETE because it is never handed a session id.
+                if (req.method !== "POST") {
+                    res.status(405).json({
+                        jsonrpc: "2.0",
+                        error: {
+                            code: -32000,
+                            message: "Method not allowed",
+                        },
+                        id: null,
+                    });
+                    return;
+                }
+                const callerAgentIdRaw = req.query.callerAgentId;
+                let callerAgentId;
+                if (typeof callerAgentIdRaw === "string") {
+                    callerAgentId = callerAgentIdRaw;
+                }
+                else if (Array.isArray(callerAgentIdRaw) && typeof callerAgentIdRaw[0] === "string") {
+                    callerAgentId = callerAgentIdRaw[0];
+                }
+                const { server, transport } = await createAgentMcpSession(callerAgentId);
+                res.on("close", () => {
+                    void transport.close();
+                    void server.close();
+                });
+                await transport.handleRequest(req, res, req.body);
+            }
+            catch (err) {
+                logger.error({ err }, "Failed to handle Agent MCP request");
+                if (!res.headersSent) {
+                    res.status(500).json({
+                        jsonrpc: "2.0",
+                        error: {
+                            code: -32603,
+                            message: "Internal MCP server error",
+                        },
+                        id: null,
+                    });
+                }
+            }
+        };
+        const handleAgentMcpRequest = (req, res) => {
+            void runAgentMcpRequest(req, res);
+        };
+        app.post(agentMcpRoute, handleAgentMcpRequest);
+        app.get(agentMcpRoute, handleAgentMcpRequest);
+        app.delete(agentMcpRoute, handleAgentMcpRequest);
+        logger.info({ route: agentMcpRoute }, "Agent MCP server mounted on main app");
+    }
+    else {
+        logger.info("Agent MCP HTTP endpoint disabled");
+    }
+    const speechService = createSpeechService({
+        logger,
+        openaiConfig: config.openai,
+        speechConfig: config.speech,
+    });
+    logger.info({ elapsed: elapsed() }, "Speech service created");
+    // Hot-reload speech providers when daemon config changes (settings UI writes
+    // features.dictation/voiceMode via the daemon config store). reconfigure()
+    // no-ops when the resolved speech config is unchanged, so unrelated config
+    // patches never churn the speech worker.
+    const unsubscribeSpeechConfigChange = daemonConfigStore.onChange(() => {
+        try {
+            const persisted = loadPersistedConfig(config.ottoHome, logger);
+            const resolved = resolveSpeechConfig({
+                ottoHome: config.ottoHome,
+                env: process.env,
+                persisted,
+            });
+            void speechService
+                .reconfigure({ openaiConfig: resolved.openai, speechConfig: resolved.speech })
+                .catch((error) => {
+                logger.warn({ err: error }, "Speech reconfigure failed after config change");
+            });
+        }
+        catch (error) {
+            logger.warn({ err: error }, "Failed to re-resolve speech config after config change");
+        }
+    });
+    logger.info({ elapsed: elapsed() }, "Bootstrap complete, ready to start listening");
+    const start = async () => {
+        let mainStarted = false;
+        try {
+            if (serviceProxyListenTarget) {
+                const boundServiceProxyTarget = await serviceProxy.startStandalone({
+                    listenTarget: serviceProxyListenTarget,
+                });
+                serviceProxyListenTarget = boundServiceProxyTarget;
+                logger.info({
+                    listen: formatListenTarget(serviceProxyListenTarget),
+                    publicBaseUrl: serviceProxyPublicBaseUrl,
+                    elapsed: elapsed(),
+                }, "Service proxy listening");
+            }
+            // Start main HTTP server
+            await new Promise((resolve, reject) => {
+                const onError = (err) => {
+                    httpServer.off("listening", onListening);
+                    reject(err);
+                };
+                const onListening = () => {
+                    httpServer.off("error", onError);
+                    mainStarted = true;
+                    const logAndResolve = async () => {
+                        boundListenTarget = resolveBoundListenTarget(listenTarget, httpServer);
+                        const mcpBaseUrl = mcpEnabled ? createAgentMcpBaseUrl(boundListenTarget) : null;
+                        agentMcpBaseUrl = config.mcpInjectIntoAgents === false ? null : mcpBaseUrl;
+                        agentManager.setMcpBaseUrl(agentMcpBaseUrl);
+                        agentManager.setOttoToolsEnabled(config.mcpInjectIntoAgents !== false);
+                        daemonConfigStore.onFieldChange("mcp.injectIntoAgents", (value) => {
+                            agentManager.setMcpBaseUrl(value ? mcpBaseUrl : null);
+                            agentManager.setOttoToolsEnabled(value !== false);
+                        });
+                        daemonConfigStore.onFieldChange("appendSystemPrompt", (value) => {
+                            agentManager.setAppendSystemPrompt(typeof value === "string" ? value : "");
+                        });
+                        const relayEnabled = config.relayEnabled ?? true;
+                        const relayEndpoint = config.relayEndpoint ?? "relay.otto-code.me:443";
+                        const relayPublicEndpoint = config.relayPublicEndpoint ?? relayEndpoint;
+                        const relayUseTls = config.relayUseTls ?? relayEndpoint === "relay.otto-code.me:443";
+                        const relayPublicUseTls = config.relayPublicUseTls ?? relayUseTls;
+                        const appBaseUrl = config.appBaseUrl ?? "https://app.otto-code.me";
+                        if (boundListenTarget.type === "tcp") {
+                            logger.info({
+                                host: boundListenTarget.host,
+                                port: boundListenTarget.port,
+                                authRequired: !!config.auth?.password,
+                                elapsed: elapsed(),
+                            }, `Server listening on http://${boundListenTarget.host}:${boundListenTarget.port}`);
+                        }
+                        else {
+                            logger.info({
+                                path: boundListenTarget.path,
+                                authRequired: !!config.auth?.password,
+                                elapsed: elapsed(),
+                            }, `Server listening on ${boundListenTarget.path}`);
+                        }
+                        if (config.auth?.password) {
+                            logger.info("Daemon password authentication enabled");
+                        }
+                        wsServer = new VoiceAssistantWebSocketServer(httpServer, logger, serverId, agentManager, agentStorage, downloadTokenStore, config.ottoHome, daemonConfigStore, mcpBaseUrl, { allowedOrigins, hostnames: configuredHostnames }, workspaceAutoName, config.auth, speechService, terminalManager, {
+                            finalTimeoutMs: config.dictationFinalTimeoutMs,
+                        }, daemonVersion, (intent) => {
+                            try {
+                                config.onLifecycleIntent?.(intent);
+                            }
+                            catch (error) {
+                                logger.error({ err: error, intent }, "Failed to handle daemon lifecycle intent");
+                            }
+                        }, projectRegistry, workspaceRegistry, chatService, loopService, scheduleService, checkoutDiffManager, serviceProxy, scriptRuntimeStore, handleBranchChange, () => (boundListenTarget?.type === "tcp" ? boundListenTarget.port : null), () => (boundListenTarget?.type === "tcp" ? boundListenTarget.host : null), (hostname) => scriptHealthMonitor.getHealthForHostname(hostname), workspaceGitService, github, config.pushNotificationSender, providerSnapshotManager, {
+                            listen: formatListenTarget(boundListenTarget ?? listenTarget),
+                            worktreesRoot: config.worktreesRoot,
+                            appBaseUrl: config.appBaseUrl,
+                            relay: {
+                                enabled: relayEnabled,
+                                endpoint: relayEndpoint,
+                                publicEndpoint: relayPublicEndpoint,
+                                useTls: relayUseTls,
+                                publicUseTls: relayPublicUseTls,
+                            },
+                        }, serviceProxyPublicBaseUrl, browserToolsBroker, previewDevServers, gitHostingResolver);
+                        wsServer.setPersonalityStatsProvider(() => personalityStatsStore.get());
+                        // Sanity guard: never let preview "stop external server" tree-kill
+                        // Otto's own runtime — the daemon's listen port or a loopback dev
+                        // server hosting a connected client (e.g. Metro serving this app).
+                        const wsServerForProtectedPorts = wsServer;
+                        previewDevServers.setProtectedPortsProvider(() => {
+                            const ports = new Set();
+                            const bound = boundListenTarget ?? listenTarget;
+                            if (bound.type === "tcp") {
+                                ports.add(bound.port);
+                            }
+                            for (const port of wsServerForProtectedPorts.getConnectedClientOriginPorts()) {
+                                ports.add(port);
+                            }
+                            return [...ports];
+                        });
+                        if (relayEnabled) {
+                            const offer = await createConnectionOfferV2({
+                                serverId,
+                                daemonPublicKeyB64: daemonKeyPair.publicKeyB64,
+                                relay: {
+                                    endpoint: relayPublicEndpoint,
+                                    useTls: relayPublicUseTls,
+                                },
+                            });
+                            encodeOfferToFragmentUrl({ offer, appBaseUrl });
+                            relayTransport?.stop().catch(() => undefined);
+                            relayTransport = startRelayTransport({
+                                logger,
+                                attachSocket: (ws, metadata) => {
+                                    if (!wsServer) {
+                                        throw new Error("WebSocket server not initialized");
+                                    }
+                                    return wsServer.attachExternalSocket(ws, metadata);
+                                },
+                                relayEndpoint,
+                                relayUseTls,
+                                serverId,
+                                daemonKeyPair: daemonKeyPair.keyPair,
+                            });
+                        }
+                    };
+                    logAndResolve().then(resolve, reject);
+                };
+                httpServer.once("error", onError);
+                httpServer.once("listening", onListening);
+                if (listenTarget.type === "tcp") {
+                    httpServer.listen(listenTarget.port, listenTarget.host);
+                }
+                else {
+                    if (listenTarget.type === "socket" && existsSync(listenTarget.path)) {
+                        unlinkSync(listenTarget.path);
+                    }
+                    httpServer.listen(listenTarget.path);
+                }
+            });
+            // Start speech service after listening so synchronous Sherpa native
+            // model loading doesn't block the server from accepting connections.
+            speechService.start();
+            scriptHealthMonitor.start();
+        }
+        catch (error) {
+            await serviceProxy.stopStandalone().catch(() => undefined);
+            if (mainStarted) {
+                httpServer.closeAllConnections();
+                await new Promise((resolve) => httpServer.close(() => resolve()));
+            }
+            throw error;
+        }
+    };
+    const stop = async () => {
+        scriptHealthMonitor.stop();
+        // Dev servers first: they are children of this daemon and hold ports the
+        // next daemon instance may want.
+        await previewDevServers.shutdown().catch(() => undefined);
+        await closeAllAgents(logger, agentManager);
+        await agentManager.flush().catch(() => undefined);
+        detachAgentStoragePersistence();
+        await agentStorage.flush().catch(() => undefined);
+        await providerSnapshotManager.shutdown();
+        terminalManager.killAll();
+        unsubscribeSpeechConfigChange();
+        unsubscribeGitHostingConfigChange();
+        github.dispose?.();
+        speechService.stop();
+        toolArtifactService.stop();
+        await scheduleService.stop().catch(() => undefined);
+        await relayTransport?.stop().catch(() => undefined);
+        if (wsServer) {
+            await wsServer.close();
+        }
+        await serviceProxy.stopStandalone();
+        // Force-drop remaining sockets so httpServer.close() resolves promptly.
+        // We've already closed wsServer (which sent ws-layer close frames) and
+        // stopped every other service, so anything still attached is a TCP
+        // socket whose higher-level shutdown hasn't fully released it (e.g.
+        // upgraded WS sockets in the closing handshake, or HTTP keep-alive
+        // sockets in CLOSE_WAIT). closeIdleConnections() does not catch
+        // upgraded sockets, so we use closeAllConnections() here.
+        httpServer.closeAllConnections();
+        await new Promise((resolve) => {
+            httpServer.close(() => resolve());
+        });
+        // Clean up socket files
+        if (listenTarget.type === "socket" && existsSync(listenTarget.path)) {
+            unlinkSync(listenTarget.path);
+        }
+    };
+    return {
+        config,
+        agentManager,
+        agentStorage,
+        terminalManager,
+        serviceProxy,
+        scriptRuntimeStore,
+        browserToolsBroker,
+        start,
+        stop,
+        getListenTarget: () => boundListenTarget,
+    };
+}
+async function closeAllAgents(logger, agentManager) {
+    const agents = agentManager.listAgents();
+    await Promise.all(agents.map(async (agent) => {
+        try {
+            await agentManager.closeAgent(agent.id);
+        }
+        catch (err) {
+            logger.error({ err, agentId: agent.id }, "Failed to close agent");
+        }
+    }));
+}
+//# sourceMappingURL=bootstrap.js.map