@ouro.bot/cli 0.1.0-alpha.32 → 0.1.0-alpha.320

package/dist/heart/migrate-config.js

@@ -0,0 +1,127 @@
+"use strict";
+// v1 → v2 agent.json migration.
+// Moves model from secrets.json into agent.json under humanFacing/agentFacing.
+// Uses raw fs — NO import from config.ts (avoids circular dependency).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateAgentConfigV1ToV2 = migrateAgentConfigV1ToV2;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const MODEL_FIELD = {
+    azure: "modelName",
+    minimax: "model",
+    anthropic: "model",
+    "openai-codex": "model",
+    "github-copilot": "model",
+};
+function resolveSecretsPath(agentRoot, deps) {
+    const agentName = path.basename(agentRoot).replace(/\.ouro$/, "");
+    const secretsBase = deps?.secretsRoot ?? path.join(require("os").homedir(), ".agentsecrets");
+    return path.join(secretsBase, agentName, "secrets.json");
+}
+function migrateAgentConfigV1ToV2(agentRoot, deps) {
+    const configPath = path.join(agentRoot, "agent.json");
+    let raw;
+    try {
+        raw = fs.readFileSync(configPath, "utf-8");
+    }
+    catch {
+        return; // No agent.json — nothing to migrate
+    }
+    let config;
+    try {
+        config = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Cannot parse agent.json at ${configPath} — invalid JSON`);
+    }
+    const version = typeof config.version === "number" ? config.version : 1;
+    if (version >= 2) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "config/identity",
+            event: "config_identity.migrate_skip",
+            message: "agent config already v2, skipping migration",
+            meta: { agentRoot },
+        });
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config_identity.migrate_start",
+        message: "migrating agent config v1 → v2",
+        meta: { agentRoot },
+    });
+    const provider = config.provider;
+    let model = "";
+    if (provider) {
+        const secretsPath = resolveSecretsPath(agentRoot, deps);
+        try {
+            const secretsRaw = fs.readFileSync(secretsPath, "utf-8");
+            const secrets = JSON.parse(secretsRaw);
+            const providers = secrets.providers;
+            if (providers) {
+                const providerSecrets = providers[provider];
+                if (providerSecrets) {
+                    /* v8 ignore next -- fallback: all known providers are in MODEL_FIELD @preserve */
+                    const fieldName = MODEL_FIELD[provider] ?? "model";
+                    const rawModel = providerSecrets[fieldName];
+                    model = typeof rawModel === "string" ? rawModel : "";
+                    // Strip model from secrets
+                    delete providerSecrets[fieldName];
+                    fs.writeFileSync(secretsPath, JSON.stringify(secrets, null, 2) + "\n", "utf-8");
+                }
+            }
+        }
+        catch {
+            // Missing or malformed secrets.json — leave model as empty string
+        }
+    }
+    // Write v2 config
+    const { provider: _removed, ...rest } = config;
+    const v2Config = {
+        ...rest,
+        version: 2,
+        humanFacing: { provider: provider ?? "anthropic", model },
+        agentFacing: { provider: provider ?? "anthropic", model },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(v2Config, null, 2) + "\n", "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config_identity.migrate_end",
+        message: "agent config migration complete",
+        meta: { agentRoot, provider: provider ?? "unknown", model },
+    });
+}

package/dist/heart/model-capabilities.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_CAPABILITIES = void 0;
+exports.getModelCapabilities = getModelCapabilities;
+const runtime_1 = require("../nerves/runtime");
+exports.MODEL_CAPABILITIES = {
+    "claude-opus-4-6": {
+        reasoningEffort: ["low", "medium", "high", "max"],
+        thinkingFormat: "anthropic",
+        maxOutputTokens: 128000,
+        vision: true,
+    },
+    "claude-sonnet-4-6": {
+        reasoningEffort: ["low", "medium", "high"],
+        thinkingFormat: "anthropic",
+        maxOutputTokens: 64000,
+        vision: true,
+    },
+    "claude-opus-4.6": {
+        reasoningEffort: ["low", "medium", "high", "max"],
+        maxOutputTokens: 128000,
+        vision: true,
+    },
+    "claude-sonnet-4.6": {
+        reasoningEffort: ["low", "medium", "high"],
+        maxOutputTokens: 64000,
+        vision: true,
+    },
+    "gpt-5.4": {
+        reasoningEffort: ["low", "medium", "high"],
+        phase: true,
+        maxOutputTokens: 100000,
+        vision: true,
+    },
+    "gpt-5.3-codex": {
+        reasoningEffort: ["low", "medium", "high"],
+        phase: true,
+        maxOutputTokens: 100000,
+    },
+    "MiniMax-Text-01": {
+        vision: true,
+    },
+    "MiniMax-VL-01": {
+        vision: true,
+    },
+};
+const EMPTY_CAPABILITIES = Object.freeze({});
+function getModelCapabilities(modelId) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.model_capabilities_lookup",
+        message: `model capabilities lookup: ${modelId}`,
+        meta: { modelId, found: modelId in exports.MODEL_CAPABILITIES },
+    });
+    const entry = exports.MODEL_CAPABILITIES[modelId];
+    if (entry)
+        return entry;
+    return { ...EMPTY_CAPABILITIES };
+}

package/dist/heart/outlook/outlook-http.js

@@ -0,0 +1,439 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startOutlookHttpServer = startOutlookHttpServer;
+const fs = __importStar(require("fs"));
+const http = __importStar(require("http"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const outlook_read_1 = require("./outlook-read");
+function createSseBroadcaster() {
+    let nextId = 1;
+    const clients = new Set();
+    function add(response) {
+        const client = { id: nextId++, response };
+        clients.add(client);
+        response.on("close", () => clients.delete(client));
+        return client;
+    }
+    function broadcast(event, data = {}) {
+        const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+        for (const client of clients) {
+            try {
+                client.response.write(payload);
+                /* v8 ignore start */
+            }
+            catch {
+                clients.delete(client);
+            }
+            /* v8 ignore stop */
+        }
+    }
+    function disconnectAll() {
+        for (const client of clients) {
+            try {
+                client.response.end();
+                /* v8 ignore start */
+            }
+            catch {
+                /* already closed */
+            }
+            /* v8 ignore stop */
+        }
+        clients.clear();
+    }
+    return { add, broadcast, disconnectAll };
+}
+/* v8 ignore start — filesystem watcher, tested via integration */
+function createBundleWatcher(bundlesRoot, onChange) {
+    const watchers = [];
+    let debounceTimer = null;
+    const DEBOUNCE_MS = 500;
+    function debouncedOnChange() {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(onChange, DEBOUNCE_MS);
+    }
+    try {
+        if (fs.existsSync(bundlesRoot)) {
+            const watcher = fs.watch(bundlesRoot, { recursive: true }, debouncedOnChange);
+            watchers.push(watcher);
+        }
+    }
+    catch {
+        // watch not available — SSE will rely on manual broadcast
+    }
+    return {
+        stop() {
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            for (const w of watchers)
+                try {
+                    w.close();
+                }
+                catch { /* ignore */ }
+            watchers.length = 0;
+        },
+    };
+}
+/* v8 ignore stop */
+function writeJson(response, statusCode, payload) {
+    response.writeHead(statusCode, { "content-type": "application/json; charset=utf-8" });
+    response.end(`${JSON.stringify(payload, null, 2)}\n`);
+}
+/* v8 ignore start — SPA static file serving infrastructure */
+const MIME_TYPES = {
+    ".html": "text/html",
+    ".js": "application/javascript",
+    ".css": "text/css",
+    ".json": "application/json",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".ico": "image/x-icon",
+    ".woff2": "font/woff2",
+};
+function resolveSpaDistDir() {
+    // Look for the built SPA relative to this file's location
+    // In production: dist/heart/daemon/outlook-http.js -> ../../packages/outlook-ui/dist/
+    // In dev: packages/outlook-ui/dist/
+    const candidates = [
+        path.resolve(__dirname, "..", "..", "..", "packages", "outlook-ui", "dist"),
+        path.resolve(__dirname, "..", "..", "packages", "outlook-ui", "dist"),
+        path.resolve(__dirname, "..", "..", "..", "..", "packages", "outlook-ui", "dist"),
+        // npm-published layout: the SPA dist is copied to dist/outlook-ui/
+        path.resolve(__dirname, "..", "..", "outlook-ui"),
+        path.resolve(__dirname, "..", "outlook-ui"),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(path.join(candidate, "index.html")))
+            return candidate;
+    }
+    return null;
+}
+function serveStaticFile(response, filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return false;
+        const ext = path.extname(filePath);
+        const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+        const content = fs.readFileSync(filePath);
+        response.writeHead(200, {
+            "content-type": contentType,
+            "cache-control": ext === ".html" ? "no-cache" : "public, max-age=31536000, immutable",
+        });
+        response.end(content);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/* v8 ignore stop */
+function normalizePath(urlValue = "/") {
+    const parsed = new URL(urlValue, "http://127.0.0.1");
+    const normalizedPath = parsed.pathname.replace(/\/+$/, "");
+    if (normalizedPath.length === 0)
+        return "/";
+    return normalizedPath;
+}
+async function startOutlookHttpServer(options = {}) {
+    const host = options.host ?? "127.0.0.1";
+    const port = options.port ?? 0;
+    const bundlesRoot = options.bundlesRoot;
+    const opts = bundlesRoot ? { bundlesRoot } : undefined;
+    const readMachineState = options.readMachineState ?? (() => (0, outlook_read_1.readOutlookMachineState)(opts));
+    const readMachineView = options.readMachineView;
+    /* v8 ignore start */
+    const readAgentState = options.readAgentState ?? ((agentName) => {
+        if (opts)
+            return (0, outlook_read_1.readOutlookAgentState)(agentName, opts);
+        return (0, outlook_read_1.readOutlookAgentState)(agentName);
+    });
+    /* v8 ignore stop */
+    const readAgentView = options.readAgentView;
+    /* v8 ignore start — default hook wiring, tested via integration */
+    const agentRoot = (agentName) => {
+        const base = bundlesRoot ?? "";
+        return path.join(base, `${agentName}.ouro`);
+    };
+    const hooks = {
+        readAgentSessions: options.readAgentSessions ?? ((agentName) => (0, outlook_read_1.readSessionInventory)(agentName, bundlesRoot ? { bundlesRoot } : undefined)),
+        readAgentTranscript: options.readAgentTranscript ?? ((agentName, friendId, channel, key) => (0, outlook_read_1.readSessionTranscript)(agentName, friendId, channel, key, bundlesRoot ? { bundlesRoot } : undefined)),
+        readAgentCoding: options.readAgentCoding ?? ((agentName) => (0, outlook_read_1.readCodingDeep)(agentRoot(agentName))),
+        readAgentAttention: options.readAgentAttention ?? ((agentName) => (0, outlook_read_1.readAttentionView)(agentName, bundlesRoot ? { bundlesRoot } : undefined)),
+        readAgentBridges: options.readAgentBridges ?? ((agentName) => (0, outlook_read_1.readBridgeInventory)(agentRoot(agentName))),
+        readAgentMemory: options.readAgentMemory ?? ((agentName) => (0, outlook_read_1.readMemoryView)(agentRoot(agentName))),
+        readAgentFriends: options.readAgentFriends ?? ((agentName) => (0, outlook_read_1.readFriendView)(agentName, bundlesRoot ? { bundlesRoot } : undefined)),
+        readAgentContinuity: options.readAgentContinuity ?? ((agentName) => (0, outlook_read_1.readOutlookContinuity)(agentRoot(agentName), agentName)),
+        readAgentOrientation: options.readAgentOrientation ?? ((agentName) => (0, outlook_read_1.readOrientationView)(agentRoot(agentName), agentName)),
+        readAgentObligations: options.readAgentObligations ?? ((agentName) => (0, outlook_read_1.readObligationDetailView)(agentRoot(agentName))),
+        readAgentChanges: options.readAgentChanges ?? ((agentName) => (0, outlook_read_1.readChangesView)(agentRoot(agentName))),
+        readAgentSelfFix: options.readAgentSelfFix ?? ((agentName) => (0, outlook_read_1.readSelfFixView)(agentRoot(agentName))),
+        readAgentMemoryDecisions: options.readAgentMemoryDecisions ?? ((agentName) => (0, outlook_read_1.readMemoryDecisionView)(agentRoot(agentName))),
+        readAgentHabits: options.readAgentHabits ?? ((agentName) => (0, outlook_read_1.readHabitView)(agentRoot(agentName))),
+        readDaemonHealth: options.readDaemonHealth ?? (() => (0, outlook_read_1.readDaemonHealthDeep)(options.healthPath)),
+        readLogs: options.readLogs ?? (() => (0, outlook_read_1.readLogView)(options.logPath ?? null)),
+    };
+    /* v8 ignore stop */
+    const sse = createSseBroadcaster();
+    /* v8 ignore start — watcher callback fires on filesystem changes */
+    const bundleWatcher = bundlesRoot ? createBundleWatcher(bundlesRoot, () => {
+        sse.broadcast("state-changed", { at: new Date().toISOString() });
+    }) : null;
+    /* v8 ignore stop */
+    const server = http.createServer((request, response) => {
+        let pathname = normalizePath(request.url);
+        const origin = `http://${host}:${server.address().port}`;
+        /* v8 ignore start — SPA static asset serving */
+        // Serve built SPA static assets: /assets/*
+        if (pathname.startsWith("/assets/")) {
+            const spaDir = resolveSpaDistDir();
+            if (spaDir) {
+                const assetPath = path.join(spaDir, pathname);
+                if (serveStaticFile(response, assetPath))
+                    return;
+            }
+            writeJson(response, 404, { ok: false, error: "asset not found" });
+            return;
+        }
+        /* v8 ignore stop */
+        // Legacy /outlook route — redirect to root
+        if (pathname === "/outlook") {
+            response.writeHead(301, { location: "/" });
+            response.end();
+            return;
+        }
+        // Compatibility alias: /outlook/api/* → /api/*
+        /* v8 ignore start -- legacy compat path: tested via integration @preserve */
+        if (pathname.startsWith("/outlook/api/")) {
+            pathname = pathname.slice("/outlook".length);
+        }
+        else if (pathname === "/outlook/api") {
+            pathname = "/api";
+        }
+        /* v8 ignore stop */
+        // SSE event stream
+        if (pathname === "/api/events") {
+            response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", "connection": "keep-alive", "access-control-allow-origin": "*" });
+            response.write(":ok\n\n");
+            sse.add(response);
+            return;
+        }
+        if (pathname === "/api/machine") {
+            const machine = readMachineState();
+            const machineView = readMachineView?.({ origin, machine });
+            writeJson(response, 200, machineView ?? machine);
+            return;
+        }
+        if (pathname === "/api/machine/health") {
+            const health = hooks.readDaemonHealth();
+            writeJson(response, 200, health ?? { status: "unavailable" });
+            return;
+        }
+        if (pathname === "/api/machine/logs") {
+            writeJson(response, 200, hooks.readLogs());
+            return;
+        }
+        // Agent-level endpoints: /api/agents/:agent[/:surface[/:params...]]
+        const agentMatch = /^\/api\/agents\/([^/]+)(?:\/(.+))?$/.exec(pathname);
+        if (agentMatch) {
+            const agent = decodeURIComponent(agentMatch[1]);
+            const surface = agentMatch[2] ?? null;
+            if (!surface) {
+                const view = readAgentView?.(agent);
+                if (view) {
+                    writeJson(response, 200, view);
+                    return;
+                }
+                const state = readAgentState(agent);
+                if (!state) {
+                    writeJson(response, 404, { ok: false, error: `unknown agent: ${agent}` });
+                    return;
+                }
+                writeJson(response, 200, state);
+                return;
+            }
+            if (surface === "sessions") {
+                writeJson(response, 200, hooks.readAgentSessions(agent));
+                return;
+            }
+            const transcriptMatch = /^sessions\/([^/]+)\/([^/]+)\/([^/]+)$/.exec(surface);
+            if (transcriptMatch) {
+                const friendId = decodeURIComponent(transcriptMatch[1]);
+                const channel = decodeURIComponent(transcriptMatch[2]);
+                const key = decodeURIComponent(transcriptMatch[3]);
+                const transcript = hooks.readAgentTranscript(agent, friendId, channel, key);
+                if (!transcript) {
+                    writeJson(response, 404, { ok: false, error: "session not found" });
+                    return;
+                }
+                writeJson(response, 200, transcript);
+                return;
+            }
+            if (surface === "coding") {
+                writeJson(response, 200, hooks.readAgentCoding(agent));
+                return;
+            }
+            if (surface === "attention") {
+                writeJson(response, 200, hooks.readAgentAttention(agent));
+                return;
+            }
+            if (surface === "bridges") {
+                writeJson(response, 200, hooks.readAgentBridges(agent));
+                return;
+            }
+            if (surface === "memory") {
+                writeJson(response, 200, hooks.readAgentMemory(agent));
+                return;
+            }
+            if (surface === "friends") {
+                writeJson(response, 200, hooks.readAgentFriends(agent));
+                return;
+            }
+            if (surface === "continuity") {
+                writeJson(response, 200, hooks.readAgentContinuity(agent));
+                return;
+            }
+            if (surface === "orientation") {
+                writeJson(response, 200, hooks.readAgentOrientation(agent));
+                return;
+            }
+            if (surface === "obligations") {
+                writeJson(response, 200, hooks.readAgentObligations(agent));
+                return;
+            }
+            if (surface === "changes") {
+                writeJson(response, 200, hooks.readAgentChanges(agent));
+                return;
+            }
+            if (surface === "self-fix") {
+                writeJson(response, 200, hooks.readAgentSelfFix(agent));
+                return;
+            }
+            if (surface === "memory-decisions") {
+                writeJson(response, 200, hooks.readAgentMemoryDecisions(agent));
+                return;
+            }
+            /* v8 ignore start — desk prefs write + reads */
+            if (surface === "dismiss-obligation" && request.method === "POST") {
+                let body = "";
+                request.on("data", (chunk) => { body += chunk; });
+                request.on("end", () => {
+                    try {
+                        const { obligationId } = JSON.parse(body);
+                        if (!obligationId) {
+                            writeJson(response, 400, { ok: false, error: "obligationId required" });
+                            return;
+                        }
+                        const prefsPath = path.join(agentRoot(agent), "state", "outlook-prefs.json");
+                        let prefs = {};
+                        try {
+                            prefs = JSON.parse(fs.readFileSync(prefsPath, "utf-8"));
+                        }
+                        catch { /* new file */ }
+                        const dismissed = Array.isArray(prefs.dismissedObligations) ? prefs.dismissedObligations : [];
+                        if (!dismissed.includes(obligationId))
+                            dismissed.push(obligationId);
+                        prefs.dismissedObligations = dismissed;
+                        fs.mkdirSync(path.dirname(prefsPath), { recursive: true });
+                        fs.writeFileSync(prefsPath, JSON.stringify(prefs, null, 2) + "\n", "utf-8");
+                        writeJson(response, 200, { ok: true, dismissed: dismissed.length });
+                    }
+                    catch (error) {
+                        writeJson(response, 500, { ok: false, error: String(error) });
+                    }
+                });
+                return;
+            }
+            if (surface === "desk-prefs") {
+                writeJson(response, 200, (0, outlook_read_1.readDeskPrefs)(agentRoot(agent)));
+                return;
+            }
+            if (surface === "needs-me") {
+                writeJson(response, 200, (0, outlook_read_1.readNeedsMeView)(agent, opts));
+                return;
+            }
+            /* v8 ignore stop */
+            if (surface === "habits") {
+                writeJson(response, 200, hooks.readAgentHabits(agent));
+                return;
+            }
+            if (surface === "inner-transcript") {
+                const transcript = hooks.readAgentTranscript(agent, "self", "inner", "dialog");
+                writeJson(response, 200, transcript ?? { messageCount: 0, messages: [] });
+                return;
+            }
+            writeJson(response, 404, { ok: false, error: `unknown agent surface: ${surface}` });
+            return;
+        }
+        /* v8 ignore start — SPA fallback for client-side routing @preserve */
+        const spaDir = resolveSpaDistDir();
+        if (spaDir) {
+            if (serveStaticFile(response, path.join(spaDir, "index.html")))
+                return;
+        }
+        writeJson(response, 404, { ok: false, error: `not found: ${pathname}` });
+        /* v8 ignore stop */
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => resolve());
+    });
+    const address = server.address();
+    const origin = `http://${host}:${address.port}`;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.outlook_http_started",
+        message: "started Outlook HTTP server",
+        meta: { origin },
+    });
+    return {
+        origin,
+        broadcast(event, data) {
+            sse.broadcast(event, data);
+        },
+        async stop() {
+            bundleWatcher?.stop();
+            sse.disconnectAll();
+            await new Promise((resolve) => server.close(() => resolve()));
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.outlook_http_stopped",
+                message: "stopped Outlook HTTP server",
+                meta: { origin },
+            });
+        },
+    };
+}