@ouro.bot/cli 0.1.0-alpha.159 → 0.1.0-alpha.160

package/changelog.json

@@ -1,6 +1,17 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.160",
+      "changes": [
+        "feat(outlook): total inspectability expansion \u2014 14 API endpoints, session x-ray, obligation chain tracing, coding deep inspection, attention/pending queue, bridge inventory, habit triage, memory/journal, friend economics, SSE live updates",
+        "feat(outlook): React SPA with Catalyst UI \u2014 sidebar layout, 7-tab agent inspector, chat bubble transcripts with mechanism-tool awareness, hash URL routing",
+        "feat(outlook): agent desk customization \u2014 carrying block, pinned constellations, tab ordering, starred friends, status line, closure memory, needs-me urgency queue",
+        "feat(outlook): nerves observation layer \u2014 shared typed readers, eliminates bespoke type mirrors",
+        "fix(auth): ouro auth for openai-codex always refreshes token, provider verification uses correct endpoint",
+        "fix(daemon): use OUTLOOK_DEFAULT_PORT (6876) for Outlook server"
+      ]
+    },
     {
       "version": "0.1.0-alpha.159",
       "changes": [
@@ -14,12 +25,12 @@
     {
       "version": "0.1.0-alpha.158",
       "changes": [
-        "Task scanner v2: explicit identity via kind: task field. Scanner only parses files that declare themselves as task cards — doing docs, planning docs, and artifacts silently skipped. Eliminates 184 false parse errors on real bundles.",
+        "Task scanner v2: explicit identity via kind: task field. Scanner only parses files that declare themselves as task cards \u2014 doing docs, planning docs, and artifacts silently skipped. Eliminates 184 false parse errors on real bundles.",
         "Typed issue model: every scanner issue has a code, description, proposed fix, confidence (safe/needs_review), and category (live/migration). Replaces flat parseErrors/invalidFilenames arrays.",
         "Board health line: compact board shows health: clean or health: 1 live, 10 migration. Live vs migration split prevents cleanup noise from looking like breakage.",
         "Fix command: ouro task fix (dry-run), ouro task fix --safe (apply deterministic fixes), ouro task fix <id> (inspect/apply individual issues). Currently auto-fixes schema-missing-kind.",
         "Cancelled status: new terminal state reachable from any active status. Auto-archives with work directory, hidden from active board view.",
-        "Derived child_tasks: computed at scan time from parent_task links. child_tasks removed from authored schema — no more hand-maintained stale arrays.",
+        "Derived child_tasks: computed at scan time from parent_task links. child_tasks removed from authored schema \u2014 no more hand-maintained stale arrays.",
         "Work directory awareness: same-stem directories detected and listed on TaskFile (hasWorkDir, workDirFiles). Scanner never descends into them.",
         "Collection root clutter detection: non-task support docs at collection root summarized as one aggregated migration issue per collection.",
         "Root-only scanning: flat directory reads replace recursive walks. Faster and correct."

package/dist/heart/daemon/daemon-cli.js

@@ -100,6 +100,7 @@ function parseStatusPayload(data) {
         daemon: stringField(overview.daemon) ?? "unknown",
         health: stringField(overview.health) ?? "unknown",
         socketPath: stringField(overview.socketPath) ?? "unknown",
+        outlookUrl: stringField(overview.outlookUrl) ?? "unavailable",
         version: stringField(overview.version) ?? "unknown",
         lastUpdated: stringField(overview.lastUpdated) ?? "unknown",
         repoRoot: stringField(overview.repoRoot) ?? "unknown",
@@ -173,7 +174,9 @@ function humanizeSenseName(sense, label) {
 }
 function formatTable(headers, rows) {
     const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index].length)));
-    const renderRow = (row) => `| ${row.map((cell, index) => cell.padEnd(widths[index])).join(" | ")} |`;
+    const renderRow = (row) => `| ${row.map((cell, index) => (index === row.length - 1
+        ? cell
+        : cell.padEnd(widths[index]))).join(" | ")} |`;
     const divider = `|-${widths.map((width) => "-".repeat(width)).join("-|-")}-|`;
     return [
         renderRow(headers),
@@ -190,6 +193,7 @@ function formatDaemonStatusOutput(response, fallback) {
         ["Socket", payload.overview.socketPath],
         ["Version", payload.overview.version],
         ["Last Updated", payload.overview.lastUpdated],
+        ["Outlook", payload.overview.outlookUrl],
         ["Entry Path", payload.overview.entryPath],
         ["Mode", payload.overview.mode],
         ["Workers", String(payload.overview.workerCount)],
@@ -289,6 +293,7 @@ function usage() {
         "  ouro [up]",
         "  ouro dev [--repo-path <path>] [--clone [--clone-path <path>]]",
         "  ouro stop|down|status|logs|hatch",
+        "  ouro outlook [--json]",
         "  ouro -v|--version",
         "  ouro config model --agent <name> <model-name>",
         "  ouro config models --agent <name>",
@@ -340,6 +345,7 @@ function buildStoppedStatusPayload(socketPath) {
             daemon: "stopped",
             health: "warn",
             socketPath,
+            outlookUrl: "unavailable",
             version: metadata.version,
             lastUpdated: metadata.lastUpdated,
             repoRoot: metadata.repoRoot,
@@ -1126,6 +1132,8 @@ function parseOuroCommand(args) {
         return { kind: "daemon.status" };
     if (head === "logs")
         return { kind: "daemon.logs" };
+    if (head === "outlook")
+        return { kind: "outlook", ...(args.includes("--json") ? { json: true } : {}) };
     if (head === "hatch")
         return parseHatchCommand(args.slice(1));
     if (head === "auth")
@@ -2513,6 +2521,41 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         deps.tailLogs();
         return "";
     }
+    if (command.kind === "outlook") {
+        let status;
+        try {
+            status = await deps.sendCommand(deps.socketPath, { kind: "daemon.status" });
+            /* v8 ignore start — error path: daemon not running */
+        }
+        catch {
+            const message = "daemon unavailable — start with `ouro up` first";
+            deps.writeStdout(message);
+            return message;
+        }
+        /* v8 ignore stop */
+        const payload = parseStatusPayload(status.data);
+        /* v8 ignore start -- ?? branch: outlookUrl always present in test fixtures */
+        const outlookUrl = payload?.overview.outlookUrl ?? "unavailable";
+        /* v8 ignore stop */
+        if (!command.json) {
+            deps.writeStdout(outlookUrl);
+            return outlookUrl;
+        }
+        /* v8 ignore start — error path: outlook URL not available */
+        if (outlookUrl === "unavailable") {
+            deps.writeStdout(outlookUrl);
+            return outlookUrl;
+        }
+        /* v8 ignore stop */
+        /* v8 ignore start -- ?? branch: tests always inject fetchImpl */
+        const fetchImpl = deps.fetchImpl ?? fetch;
+        /* v8 ignore stop */
+        const response = await fetchImpl(`${outlookUrl}/api/machine`);
+        const data = await response.json();
+        const text = JSON.stringify(data, null, 2);
+        deps.writeStdout(text);
+        return text;
+    }
     // ── hook: handle Claude Code lifecycle hooks ──
     /* v8 ignore start -- hook handler: reads real stdin, sends to real daemon @preserve */
     if (command.kind === "hook") {

package/dist/heart/daemon/daemon.js

@@ -55,6 +55,10 @@ const pending_1 = require("../../mind/pending");
 const agent_service_1 = require("./agent-service");
 const channel_1 = require("../../mind/friends/channel");
 const mcp_manager_1 = require("../../repertoire/mcp-manager");
+const outlook_http_1 = require("./outlook-http");
+const outlook_types_1 = require("./outlook-types");
+const outlook_read_1 = require("./outlook-read");
+const outlook_view_1 = require("./outlook-view");
 const PIDFILE_PATH = path.join(os.homedir(), ".ouro-cli", "daemon.pids");
 /**
  * Kill all ouro processes from the previous daemon instance using the pidfile.
@@ -180,6 +184,7 @@ class OuroDaemon {
     bundlesRoot;
     mode;
     server = null;
+    outlookServer = null;
     constructor(options) {
         this.socketPath = options.socketPath;
         this.processManager = options.processManager;
@@ -190,6 +195,27 @@ class OuroDaemon {
         this.bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
         this.mode = options.mode ?? "production";
     }
+    buildStatusPayload() {
+        const snapshots = this.processManager.listAgentSnapshots();
+        const workers = buildWorkerRows(snapshots);
+        const senses = this.senseManager?.listSenseRows() ?? [];
+        const repoRoot = (0, identity_1.getRepoRoot)();
+        return {
+            overview: {
+                daemon: "running",
+                health: workers.every((worker) => worker.status === "running") ? "ok" : "warn",
+                socketPath: this.socketPath,
+                outlookUrl: `${this.outlookServer?.origin ?? "http://127.0.0.1:0"}/outlook`,
+                ...(0, runtime_metadata_1.getRuntimeMetadata)(),
+                workerCount: workers.length,
+                senseCount: senses.length,
+                entryPath: path.join(repoRoot, "dist", "heart", "daemon", "daemon-entry.js"),
+                mode: (0, runtime_mode_1.detectRuntimeMode)(repoRoot),
+            },
+            workers,
+            senses,
+        };
+    }
     async start() {
         if (this.server)
             return;
@@ -267,6 +293,39 @@ class OuroDaemon {
         await this.scheduler.reconcile?.();
         await this.drainPendingBundleMessages();
         await this.drainPendingSenseMessages();
+        /* v8 ignore start — Outlook server startup, tested via outlook-http.test.ts */
+        if (!this.outlookServer) {
+            this.outlookServer = await (0, outlook_http_1.startOutlookHttpServer)({
+                host: "127.0.0.1",
+                port: outlook_types_1.OUTLOOK_DEFAULT_PORT,
+                readMachineState: () => (0, outlook_read_1.readOutlookMachineState)({ bundlesRoot: this.bundlesRoot }),
+                readMachineView: ({ machine }) => {
+                    const overview = this.buildStatusPayload().overview;
+                    return (0, outlook_view_1.buildOutlookMachineView)({
+                        machine,
+                        daemon: {
+                            status: overview.daemon,
+                            health: overview.health,
+                            mode: overview.mode,
+                            socketPath: overview.socketPath,
+                            outlookUrl: overview.outlookUrl,
+                            entryPath: overview.entryPath,
+                            workerCount: overview.workerCount,
+                            senseCount: overview.senseCount,
+                        },
+                    });
+                },
+                readAgentState: (agentName) => (0, outlook_read_1.readOutlookAgentState)(agentName, { bundlesRoot: this.bundlesRoot }),
+                readAgentView: (agentName) => {
+                    const agent = (0, outlook_read_1.readOutlookAgentState)(agentName, { bundlesRoot: this.bundlesRoot });
+                    return (0, outlook_view_1.buildOutlookAgentView)({
+                        agent,
+                        viewer: { kind: "human" },
+                    });
+                },
+            });
+        }
+        /* v8 ignore stop */
         if (fs.existsSync(this.socketPath)) {
             fs.unlinkSync(this.socketPath);
         }
@@ -486,6 +545,10 @@ class OuroDaemon {
             });
             this.server = null;
         }
+        if (this.outlookServer) {
+            await this.outlookServer.stop();
+            this.outlookServer = null;
+        }
         if (fs.existsSync(this.socketPath)) {
             fs.unlinkSync(this.socketPath);
         }
@@ -539,24 +602,7 @@ class OuroDaemon {
                 await this.stop();
                 return { ok: true, message: "daemon stopped" };
             case "daemon.status": {
-                const snapshots = this.processManager.listAgentSnapshots();
-                const workers = buildWorkerRows(snapshots);
-                const senses = this.senseManager?.listSenseRows() ?? [];
-                const repoRoot = (0, identity_1.getRepoRoot)();
-                const data = {
-                    overview: {
-                        daemon: "running",
-                        health: workers.every((worker) => worker.status === "running") ? "ok" : "warn",
-                        socketPath: this.socketPath,
-                        ...(0, runtime_metadata_1.getRuntimeMetadata)(),
-                        workerCount: workers.length,
-                        senseCount: senses.length,
-                        entryPath: path.join(repoRoot, "dist", "heart", "daemon", "daemon-entry.js"),
-                        mode: (0, runtime_mode_1.detectRuntimeMode)(repoRoot),
-                    },
-                    workers,
-                    senses,
-                };
+                const data = this.buildStatusPayload();
                 return {
                     ok: true,
                     summary: formatStatusSummary(data),

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

@@ -0,0 +1,307 @@
+"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");
+const outlook_render_1 = require("./outlook-render");
+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`);
+}
+function writeHtml(response, html) {
+    response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    response.end(html);
+}
+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;
+    const renderApp = options.renderApp ?? outlook_render_1.renderOutlookApp;
+    /* 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)),
+        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) => {
+        const pathname = normalizePath(request.url);
+        const origin = `http://${host}:${server.address().port}`;
+        if (pathname === "/outlook/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 === "/outlook") {
+            const machine = readMachineState();
+            const machineView = readMachineView?.({ origin, machine });
+            writeHtml(response, renderApp({ origin, machine, machineView }));
+            return;
+        }
+        if (pathname === "/outlook/api/machine") {
+            const machine = readMachineState();
+            const machineView = readMachineView?.({ origin, machine });
+            writeJson(response, 200, machineView ?? machine);
+            return;
+        }
+        if (pathname === "/outlook/api/machine/health") {
+            const health = hooks.readDaemonHealth();
+            writeJson(response, 200, health ?? { status: "unavailable" });
+            return;
+        }
+        if (pathname === "/outlook/api/machine/logs") {
+            writeJson(response, 200, hooks.readLogs());
+            return;
+        }
+        // Agent-level endpoints: /outlook/api/agents/:agent[/:surface[/:params...]]
+        const agentMatch = /^\/outlook\/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;
+            }
+            /* v8 ignore start — desk prefs + needs-me use direct reads */
+            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;
+        }
+        writeJson(response, 404, { ok: false, error: `unknown outlook path: ${pathname}` });
+    });
+    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 },
+            });
+        },
+    };
+}