@polderlabs/bizar-omp 0.6.5 → 0.6.7

package/dist/omp/daemon-service.js

@@ -4,13 +4,14 @@ import { deferred } from "./daemon.js";
 import { randomBytes } from "node:crypto";
 import { mkdirSync, statSync } from "node:fs";
 import { resolve } from "node:path";
-import { listOmbSessions, ombSessionDisplayName } from "./omb-sessions.js";
+import { listOmbSessions, ombSessionDisplayName, ombSessionJournalPath, readOmbSessionMessages } from "./omb-sessions.js";
 import { ombSessionName } from "./tmux.js";
 import { DAEMON_PROTOCOL_VERSION, DaemonError, daemonStateDir, writeSnapshot } from "./daemon.js";
 import { captureOmbSessionConsole, createOmbSession, deleteOmbSession, forgetOmbSession, openOmbSessionInTerminal, renameOmbSession, sendOmbSessionInput, setOmbSessionMouse, } from "./tmux.js";
 import { DASHBOARD_PATH, dashboardPageHtml } from "./dashboard-html.js";
 import { OMB_APPROVAL_MODES, OMB_THINKING_LEVELS, loadOmbSettings, saveOmbSettings } from "./omb-settings.js";
 import { startTray, stopTray } from "./tray.js";
+import { deleteCustomOmpProvider, listCustomOmpProviders, OMP_PROVIDER_APIS, saveCustomOmpProvider, } from "./omp-provider-config.js";
 const SCAN_INTERVAL_MS = 5_000;
 export const DASHBOARD_MAX_BODY_BYTES = 64 * 1024;
 export const DASHBOARD_BODY_TIMEOUT_MS = 10_000;
@@ -40,6 +41,224 @@ function isDirectory(path) {
         return false;
     }
 }
+const OMP_OUTPUT_LIMIT = 256 * 1024;
+const OMP_TIMEOUT_MS = 12_000;
+const OMP_PROVIDER_KEYS = new Set(["enabledProviders", "disabledProviders", "modelProviderOrder"]);
+const OMP_AUTH_ACTIONS = new Set(["status", "list"]);
+/** Invoke only fixed OMP subcommands. Output is capped and never sent verbatim. */
+async function runDashboardOmp(env, args) {
+    const child = spawn(env.BIZAR_OMP_BIN || "omp", args, { env, stdio: ["ignore", "pipe", "pipe"] });
+    let output = "";
+    const collect = (chunk) => { if (output.length < OMP_OUTPUT_LIMIT)
+        output += String(chunk).slice(0, OMP_OUTPUT_LIMIT - output.length); };
+    child.stdout?.on("data", collect);
+    // Stderr can contain provider diagnostics and credentials. Drain it so the
+    // child cannot block, but do not retain it or expose it to the browser.
+    child.stderr?.resume();
+    const code = await new Promise((resolveResult, reject) => {
+        const timer = setTimeout(() => { child.kill(); reject(new Error("OMP command timed out")); }, OMP_TIMEOUT_MS);
+        child.once("error", error => { clearTimeout(timer); reject(error); });
+        child.once("close", value => { clearTimeout(timer); resolveResult(value ?? 1); });
+    });
+    if (code !== 0)
+        throw new Error("OMP command failed");
+    return output;
+}
+const STREAM_POLL_MS = 1_000;
+const STREAM_KEEPALIVE_MS = 15_000;
+// Per-stream cleanup callbacks. service.close() iterates this to clear
+// poll/keepalive timers immediately, so a streaming client cannot keep the
+// daemon alive past shutdown.
+const STREAM_CLEANUPS = new Map();
+async function streamSessionMessages(res, session, env, log) {
+    let active = true;
+    let lastStamp = "";
+    let lastSnapshot = "";
+    let journalPath;
+    try {
+        journalPath = await ombSessionJournalPath(session, env) ?? undefined;
+    }
+    catch {
+        journalPath = undefined;
+    }
+    res.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache, no-transform",
+        "x-bizar-daemon-stream": "messages",
+        "x-accel-buffering": "no",
+    });
+    const pollTimer = setInterval(async () => {
+        if (!active)
+            return;
+        let next;
+        try {
+            if (!journalPath) {
+                journalPath = await ombSessionJournalPath(session, env) ?? undefined;
+            }
+            if (journalPath) {
+                try {
+                    next = JSON.stringify({ mtimeMs: statSync(journalPath).mtimeMs, size: statSync(journalPath).size });
+                }
+                catch {
+                    journalPath = undefined;
+                }
+            }
+            if (next && next !== lastStamp) {
+                lastStamp = next;
+                const messages = journalPath ? await readOmbSessionMessages(session, env) : [];
+                const snapshot = JSON.stringify({ kind: "snapshot", capturedAt: Date.now(), messages });
+                if (snapshot !== lastSnapshot) {
+                    lastSnapshot = snapshot;
+                    send("snapshot", { capturedAt: Date.now(), messages });
+                }
+            }
+            else if (!next) {
+                send("idle", { capturedAt: Date.now() });
+            }
+        }
+        catch (error) {
+            log(`stream error for ${session.name}: ${error instanceof Error ? error.message : String(error)}`);
+            send("error", { capturedAt: Date.now(), error: error instanceof Error ? error.message : String(error) });
+        }
+    }, STREAM_POLL_MS);
+    const keepaliveTimer = setInterval(() => {
+        if (!active)
+            return;
+        res.write(`: keepalive ${Date.now()}\n\n`);
+    }, STREAM_KEEPALIVE_MS);
+    pollTimer.unref?.();
+    keepaliveTimer.unref?.();
+    const send = (event, payload) => {
+        if (!active)
+            return;
+        res.write(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`);
+    };
+    const cleanup = () => {
+        if (!active)
+            return;
+        active = false;
+        STREAM_CLEANUPS.delete(res);
+        clearInterval(pollTimer);
+        clearInterval(keepaliveTimer);
+        res.end();
+    };
+    STREAM_CLEANUPS.set(res, cleanup);
+    res.on("close", cleanup);
+    res.on("error", cleanup);
+}
+function configEntries(value) {
+    const raw = Array.isArray(value) ? value : value && typeof value === "object"
+        ? (Array.isArray(value.settings)
+            ? value.settings
+            : Object.entries(value).map(([key, entry]) => entry && typeof entry === "object" ? { key, ...entry } : { key, value: entry }))
+        : [];
+    return raw.flatMap(entry => {
+        if (!entry || typeof entry !== "object")
+            return [];
+        const item = entry;
+        const key = typeof item.key === "string" ? item.key : typeof item.name === "string" ? item.name : "";
+        const type = typeof item.type === "string" ? item.type : "string";
+        const description = typeof item.description === "string" ? item.description : undefined;
+        const sensitive = /(?:token|secret|password|credential|api[-_]?key|bearer|private key)/i;
+        const containsSensitiveValue = (candidate, depth = 0) => depth > 4 || Boolean(candidate && typeof candidate === "object" && Object.entries(candidate).some(([nestedKey, nestedValue]) => sensitive.test(nestedKey) || containsSensitiveValue(nestedValue, depth + 1)));
+        if (!key || sensitive.test(key) || (description ? sensitive.test(description) : false) || item.redacted === true || containsSensitiveValue(item.value)) {
+            return key ? [{ key, type, description: typeof item.description === "string" ? item.description : undefined, redacted: true, writable: false }] : [];
+        }
+        const options = Array.isArray(item.options) ? item.options.filter(option => typeof option === "string") : undefined;
+        return [{ key, type, description: typeof item.description === "string" ? item.description : undefined, options, value: item.value, writable: ["boolean", "number", "string", "enum", "array", "record"].includes(type) }];
+    }).sort((left, right) => left.key.localeCompare(right.key));
+}
+async function dashboardConfig(env) {
+    return configEntries(JSON.parse(await runDashboardOmp(env, ["config", "list", "--json"])));
+}
+function providerValues(settings, key) {
+    const value = settings.find(setting => setting.key === key)?.value;
+    return Array.isArray(value) ? value.filter(item => typeof item === "string") : [];
+}
+async function dashboardProviders(env) {
+    const [models, settings] = await Promise.all([dashboardModels(env), dashboardConfig(env)]);
+    const customProviders = listCustomOmpProviders(env);
+    const enabledProviders = providerValues(settings, "enabledProviders");
+    const disabledProviders = providerValues(settings, "disabledProviders");
+    const modelProviderOrder = providerValues(settings, "modelProviderOrder");
+    const ids = [...new Set([...models.map(model => model.provider), ...customProviders.map(provider => provider.id)])].sort();
+    const providers = ids.map(id => ({
+        id,
+        models: models.filter(model => model.provider === id).length,
+        enabled: !disabledProviders.includes(id) && (enabledProviders.length === 0 || enabledProviders.includes(id)),
+        custom: customProviders.find(provider => provider.id === id),
+    }));
+    return { providers, enabledProviders, disabledProviders, modelProviderOrder, providerApis: OMP_PROVIDER_APIS };
+}
+/** Retain only small, non-secret status facts from the auth broker's JSON. */
+function safeAuthStatus(value) {
+    if (value === null || typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : undefined;
+    if (typeof value === "string")
+        return /(?:token|secret|password|credential|api[-_]?key|bearer)/i.test(value) ? undefined : value.slice(0, 256);
+    if (Array.isArray(value))
+        return value.map(safeAuthStatus).filter(item => item !== undefined).slice(0, 32);
+    if (!value || typeof value !== "object")
+        return undefined;
+    return Object.fromEntries(Object.entries(value).flatMap(([key, item]) => /(?:token|secret|password|credential|api[-_]?key|bearer)/i.test(key)
+        ? [] : [[key.slice(0, 96), safeAuthStatus(item)]]).filter(([, item]) => item !== undefined));
+}
+function collabHost(value) {
+    const record = (value && typeof value === "object") ? value : {};
+    const model = (record.model && typeof record.model === "object") ? record.model : {};
+    return {
+        instanceId: typeof record.instanceId === "string" ? record.instanceId : null,
+        pid: typeof record.pid === "number" ? record.pid : null,
+        sessionId: typeof record.sessionId === "string" ? record.sessionId : null,
+        sessionName: typeof record.sessionName === "string" ? record.sessionName : null,
+        cwd: typeof record.cwd === "string" ? record.cwd : null,
+        model: {
+            provider: typeof model.provider === "string" ? model.provider : null,
+            id: typeof model.id === "string" ? model.id : null,
+        },
+        startedAt: typeof record.startedAt === "number" && Number.isFinite(record.startedAt) ? record.startedAt : null,
+        participants: typeof record.participants === "number" && Number.isFinite(record.participants) ? record.participants : 0,
+        relayConnected: typeof record.relayConnected === "boolean" ? record.relayConnected : false,
+        access: typeof record.access === "string" ? record.access : null,
+    };
+}
+function configValue(setting, value) {
+    if (!setting.writable)
+        return undefined;
+    if (setting.type === "boolean")
+        return typeof value === "boolean" ? String(value) : undefined;
+    if (setting.type === "number")
+        return typeof value === "number" && Number.isFinite(value) ? String(value) : undefined;
+    if (setting.type === "string")
+        return typeof value === "string" && value.length <= 16_384 ? value : undefined;
+    if (setting.type === "enum")
+        return typeof value === "string" && (!setting.options || setting.options.includes(value)) ? value : undefined;
+    if (setting.type === "array")
+        return Array.isArray(value) && value.every(item => typeof item === "string") ? JSON.stringify(value) : undefined;
+    if (setting.type === "record")
+        return value && typeof value === "object" && !Array.isArray(value) ? JSON.stringify(value) : undefined;
+    return undefined;
+}
+function customProviderInput(body) {
+    const id = typeof body.id === "string" ? body.id.trim() : "";
+    const baseUrl = typeof body.baseUrl === "string" ? body.baseUrl.trim() : "";
+    const api = typeof body.api === "string" ? body.api : undefined;
+    const auth = typeof body.auth === "string" ? body.auth : undefined;
+    const models = Array.isArray(body.models) ? body.models.filter(model => typeof model === "string") : undefined;
+    if (!id || !baseUrl || !api || !auth || !models)
+        return undefined;
+    return {
+        id,
+        baseUrl,
+        api,
+        auth,
+        models,
+        apiKey: typeof body.apiKey === "string" ? body.apiKey : undefined,
+        clearApiKey: body.clearApiKey === true,
+    };
+}
 async function dashboardModels(env) {
     const child = spawn(env.BIZAR_OMP_BIN || "omp", ["models", "--json"], { env, stdio: ["ignore", "pipe", "ignore"] });
     let output = "";
@@ -231,6 +450,11 @@ export function startDaemonService(options = {}) {
             res.end('{"ok":true}\n');
             return;
         }
+        if (path === "/capabilities" && (req.method === "GET" || req.method === "HEAD")) {
+            res.writeHead(200, { "content-type": "application/json", "x-bizar-daemon-protocol": String(DAEMON_PROTOCOL_VERSION) });
+            res.end(`${JSON.stringify({ protocolVersion: DAEMON_PROTOCOL_VERSION, capabilities: ["ping", "overview", "messages", "messages-stream", "omp-collab", "settings-watch", "snapshots", "providers", "auth-status"] })}\n`);
+            return;
+        }
         if (!authorized(req)) {
             res.writeHead(401, { "content-type": "application/json" });
             res.end('{"error":"unauthorized"}\n');
@@ -258,6 +482,190 @@ export function startDaemonService(options = {}) {
             }
             return;
         }
+        if (path === "/overview" && req.method === "GET") {
+            const projected = sessions.map(dashboardSession);
+            const states = projected.reduce((counts, session) => { counts[session.state] = (counts[session.state] ?? 0) + 1; return counts; }, {});
+            const workspaces = new Set(projected.map(session => session.cwd ?? session.project).filter(Boolean));
+            let models = [];
+            let ompAvailable = true;
+            try {
+                models = await dashboardModels(env);
+            }
+            catch {
+                ompAvailable = false;
+            }
+            json(res, 200, {
+                collectedAt: lastScanAt ?? 0,
+                stale: !lastScanAt || Date.now() - lastScanAt > Math.max(intervalMs * 2, SCAN_INTERVAL_MS * 2),
+                scanError: lastScanError ?? undefined,
+                daemon: { healthy: !lastScanError, ompAvailable },
+                sessions: { total: projected.length, states, workspaces: workspaces.size, attention: projected.filter(session => ["waiting", "disconnected", "stopped"].includes(session.state)).slice(0, 12) },
+                models: { total: models.length, providers: new Set(models.map(model => model.provider)).size },
+            });
+            return;
+        }
+        if (path === "/omp/config" && req.method === "GET") {
+            try {
+                json(res, 200, { settings: await dashboardConfig(env) });
+            }
+            catch {
+                json(res, 503, { error: "OMP configuration is unavailable" });
+            }
+            return;
+        }
+        if (path === "/omp/config" && req.method === "PATCH") {
+            const body = await readBody(req);
+            const key = typeof body.key === "string" ? body.key : "";
+            try {
+                const settings = await dashboardConfig(env);
+                const setting = settings.find(candidate => candidate.key === key);
+                const native = setting ? configValue(setting, body.value) : undefined;
+                if (native === undefined || !setting) {
+                    json(res, 400, { error: "unsupported OMP configuration value" });
+                    return;
+                }
+                await runDashboardOmp(env, ["config", "set", setting.key, native]);
+                const effective = (await dashboardConfig(env)).find(candidate => candidate.key === setting.key);
+                json(res, 200, { setting: effective });
+            }
+            catch {
+                json(res, 503, { error: "OMP configuration update failed" });
+            }
+            return;
+        }
+        if (path === "/omp/config/reset" && req.method === "POST") {
+            const body = await readBody(req);
+            const key = typeof body.key === "string" ? body.key : "";
+            try {
+                const setting = (await dashboardConfig(env)).find(candidate => candidate.key === key && candidate.writable);
+                if (!setting) {
+                    json(res, 400, { error: "unsupported OMP configuration key" });
+                    return;
+                }
+                await runDashboardOmp(env, ["config", "reset", setting.key]);
+                json(res, 200, { setting: (await dashboardConfig(env)).find(candidate => candidate.key === setting.key) });
+            }
+            catch {
+                json(res, 503, { error: "OMP configuration reset failed" });
+            }
+            return;
+        }
+        if (path === "/omp/providers" && req.method === "GET") {
+            try {
+                json(res, 200, await dashboardProviders(env));
+            }
+            catch {
+                json(res, 503, { error: "OMP providers are unavailable" });
+            }
+            return;
+        }
+        if (path === "/omp/providers" && req.method === "PATCH") {
+            const body = await readBody(req);
+            const operation = typeof body.operation === "string" ? body.operation : "";
+            const provider = typeof body.provider === "string" && /^[a-zA-Z0-9._-]{1,128}$/.test(body.provider) ? body.provider : "";
+            try {
+                const settings = await dashboardConfig(env);
+                const values = (key) => providerValues(settings, key);
+                if (operation === "order" && Array.isArray(body.order) && body.order.every(value => typeof value === "string" && /^[a-zA-Z0-9._-]{1,128}$/.test(value))) {
+                    await runDashboardOmp(env, ["config", "set", "modelProviderOrder", JSON.stringify(body.order)]);
+                    json(res, 200, await dashboardProviders(env));
+                    return;
+                }
+                if (!provider || !["enable", "disable"].includes(operation)) {
+                    json(res, 400, { error: "unsupported provider operation" });
+                    return;
+                }
+                const enabled = values("enabledProviders");
+                const disabled = values("disabledProviders");
+                const nextDisabled = operation === "enable" ? disabled.filter(value => value !== provider) : [...new Set([...disabled, provider])];
+                const nextEnabled = operation === "enable"
+                    ? (enabled.length ? [...new Set([...enabled, provider])] : enabled)
+                    : enabled.filter(value => value !== provider);
+                for (const [key, next] of [["disabledProviders", nextDisabled], ["enabledProviders", nextEnabled]]) {
+                    if (!OMP_PROVIDER_KEYS.has(key) || !settings.find(setting => setting.key === key)?.writable) {
+                        json(res, 400, { error: "provider controls are unavailable" });
+                        return;
+                    }
+                    await runDashboardOmp(env, ["config", "set", key, JSON.stringify(next)]);
+                }
+                json(res, 200, await dashboardProviders(env));
+            }
+            catch {
+                json(res, 503, { error: "provider update failed" });
+            }
+            return;
+        }
+        const customProviderMatch = path.match(/^\/omp\/providers\/([^/]+)$/);
+        if (customProviderMatch && req.method === "PUT") {
+            const id = decodeURIComponent(customProviderMatch[1]);
+            const body = await readBody(req);
+            const input = customProviderInput({ ...body, id });
+            if (!input) {
+                json(res, 400, { error: "provider id, endpoint, API, auth mode, and model ids are required" });
+                return;
+            }
+            try {
+                const provider = saveCustomOmpProvider(input, env);
+                await dashboardModels(env);
+                json(res, 200, { provider });
+            }
+            catch (error) {
+                json(res, 400, { error: error instanceof Error ? error.message : "provider update failed" });
+            }
+            return;
+        }
+        if (customProviderMatch && req.method === "DELETE") {
+            const id = decodeURIComponent(customProviderMatch[1]);
+            try {
+                if (!deleteCustomOmpProvider(id, env)) {
+                    json(res, 404, { error: "custom provider was not found" });
+                    return;
+                }
+                json(res, 200, { ok: true });
+            }
+            catch (error) {
+                json(res, 400, { error: error instanceof Error ? error.message : "provider removal failed" });
+            }
+            return;
+        }
+        if (path === "/omp/provider-action" && req.method === "POST") {
+            const body = await readBody(req);
+            const action = typeof body.action === "string" ? body.action : "";
+            if (!OMP_AUTH_ACTIONS.has(action)) {
+                json(res, 400, { error: "unsupported auth action" });
+                return;
+            }
+            try {
+                const output = await runDashboardOmp(env, ["auth-broker", action, "--json"]);
+                let result;
+                try {
+                    result = output.trim() ? safeAuthStatus(JSON.parse(output)) : undefined;
+                }
+                catch {
+                    result = undefined;
+                }
+                json(res, 200, { status: "completed", result });
+            }
+            catch {
+                json(res, 503, { error: "auth action failed" });
+            }
+            return;
+        }
+        if (path === "/omp/collab" && req.method === "GET") {
+            try {
+                const raw = await runDashboardOmp(env, ["collab", "list", "--json"]);
+                const parsed = JSON.parse(raw);
+                if (parsed && Array.isArray(parsed.hosts)) {
+                    json(res, 200, { hosts: parsed.hosts.map(collabHost) });
+                    return;
+                }
+                json(res, 200, { hosts: [] });
+            }
+            catch {
+                json(res, 503, { error: "could not list collab hosts" });
+            }
+            return;
+        }
         if (path === "/settings" && req.method === "PATCH") {
             const body = await readBody(req);
             const previous = loadOmbSettings(env);
@@ -353,6 +761,33 @@ export function startDaemonService(options = {}) {
             return;
         }
         const consoleMatch = path.match(/^\/sessions\/([^/]+)\/console$/);
+        const messagesMatch = path.match(/^\/sessions\/([^/]+)\/messages$/);
+        const streamMatch = path.match(/^\/sessions\/([^/]+)\/messages\/stream$/);
+        if (messagesMatch && req.method === "GET") {
+            const name = decodeURIComponent(messagesMatch[1]);
+            const current = sessions.find(candidate => candidate.name === name);
+            if (!current) {
+                json(res, 404, { error: "unknown session" });
+                return;
+            }
+            try {
+                json(res, 200, { messages: await readOmbSessionMessages(current, env), capturedAt: Date.now() });
+            }
+            catch {
+                json(res, 503, { error: "session messages are not available" });
+            }
+            return;
+        }
+        if (streamMatch && req.method === "GET") {
+            const name = decodeURIComponent(streamMatch[1]);
+            const current = sessions.find(candidate => candidate.name === name);
+            if (!current) {
+                json(res, 404, { error: "unknown session" });
+                return;
+            }
+            streamSessionMessages(res, current, env, log);
+            return;
+        }
         if (consoleMatch && req.method === "GET") {
             const name = decodeURIComponent(consoleMatch[1]);
             const current = sessions.find(candidate => candidate.name === name);
@@ -465,7 +900,23 @@ export function startDaemonService(options = {}) {
         close: async () => {
             if (scanTimer)
                 clearInterval(scanTimer);
-            await new Promise(resolve => server.close(() => resolve()));
+            // Run every SSE cleanup so poll/keepalive timers drop the response
+            // reference immediately — otherwise the timers themselves keep the
+            // socket (and therefore server.close()) alive past shutdown.
+            for (const cleanup of [...STREAM_CLEANUPS.values()]) {
+                try {
+                    cleanup();
+                }
+                catch { /* already gone */ }
+            }
+            STREAM_CLEANUPS.clear();
+            await new Promise(resolve => {
+                server.close(() => resolve());
+                // server.close() alone would wait on HTTP/1.1 keep-alive and undici's
+                // pooled fetch connections. closeAllConnections() tears them down at
+                // once so a streaming client cannot hold shutdown open.
+                server.closeAllConnections?.();
+            });
         },
     };
     server.listen(options.port ?? 0, "127.0.0.1", () => {