@ouro.bot/cli 0.1.0-alpha.17 → 0.1.0-alpha.170

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

@@ -0,0 +1,399 @@
+"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)),
+        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;
+        }
+        /* 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;
+        }
+        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 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 */
+        const spaDir = resolveSpaDistDir();
+        if (spaDir) {
+            if (serveStaticFile(response, path.join(spaDir, "index.html")))
+                return;
+        }
+        /* v8 ignore stop */
+        writeJson(response, 404, { ok: false, error: `not found: ${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 },
+            });
+        },
+    };
+}