@useorgx/openclaw-plugin 0.4.6 → 0.4.9

package/dist/http/routes/live-legacy.js

@@ -0,0 +1,598 @@
+function toContextBundle(value) {
+    return {
+        agents: value.agents ?? {},
+        runs: value.runs ?? {},
+    };
+}
+export function registerLiveLegacyRoutes(router, deps) {
+    async function renderLiveSessions(query, res) {
+        try {
+            const initiative = query.get("initiative");
+            const limit = query.get("limit") ? Number(query.get("limit")) : undefined;
+            let data = await deps.getLiveSessions({
+                initiative,
+                limit: Number.isFinite(limit) ? limit : undefined,
+            });
+            const runtimeInstances = initiative && initiative.trim().length > 0
+                ? deps
+                    .listRuntimeInstances({ limit: 320 })
+                    .filter((instance) => instance.initiativeId === initiative)
+                : deps.listRuntimeInstances({ limit: 320 });
+            data = deps.injectRuntimeInstancesAsSessions(data, runtimeInstances);
+            data = deps.enrichSessionsWithRuntime(data, runtimeInstances);
+            deps.sendJson(res, 200, data);
+        }
+        catch (err) {
+            try {
+                const initiative = query.get("initiative");
+                const limitRaw = query.get("limit") ? Number(query.get("limit")) : undefined;
+                const limit = Number.isFinite(limitRaw) ? Math.max(1, Number(limitRaw)) : 100;
+                let local = deps.toLocalSessionTree(await deps.loadLocalOpenClawSnapshot(Math.max(limit, 200)), limit);
+                local = deps.applyAgentContextsToSessionTree(local, toContextBundle(deps.readAgentContexts()));
+                if (initiative && initiative.trim().length > 0) {
+                    const filteredNodes = local.nodes.filter((node) => node.initiativeId === initiative || node.groupId === initiative);
+                    const filteredIds = new Set(filteredNodes.map((node) => node.id));
+                    const filteredGroupIds = new Set(filteredNodes.map((node) => node.groupId));
+                    local = {
+                        nodes: filteredNodes,
+                        edges: local.edges.filter((edge) => filteredIds.has(edge.parentId) && filteredIds.has(edge.childId)),
+                        groups: local.groups.filter((group) => filteredGroupIds.has(group.id)),
+                    };
+                }
+                deps.sendJson(res, 200, local);
+            }
+            catch (localErr) {
+                deps.sendJson(res, 500, {
+                    error: deps.safeErrorMessage(err),
+                    localFallbackError: deps.safeErrorMessage(localErr),
+                });
+            }
+        }
+    }
+    router.add("GET", "live/sessions", async ({ query, res }) => renderLiveSessions(query, res), "Legacy live sessions endpoint");
+    router.add("HEAD", "live/sessions", async ({ query, res }) => renderLiveSessions(query, res), "Legacy live sessions endpoint (HEAD)");
+    async function renderLiveActivityPage(query, res) {
+        const run = query.get("run");
+        const since = query.get("since");
+        const until = query.get("until");
+        const cursor = query.get("cursor");
+        const limitRaw = query.get("limit") ? Number(query.get("limit")) : undefined;
+        const limit = Number.isFinite(limitRaw)
+            ? Math.max(1, Math.floor(Number(limitRaw)))
+            : 200;
+        let page = deps.listActivityPage({
+            limit,
+            runId: run,
+            since,
+            until,
+            cursor,
+        });
+        {
+            const ctx = toContextBundle(deps.readAgentContexts());
+            page = {
+                ...page,
+                activities: deps.applyAgentContextsToActivity(page.activities, ctx),
+            };
+        }
+        const warmKey = `${run ?? ""}::${since ?? ""}::${until ?? ""}`;
+        const lastWarmAt = deps.activityWarmByKey.get(warmKey) ?? 0;
+        const shouldWarm = Date.now() - lastWarmAt > deps.activityWarmThrottleMs &&
+            (cursor === null || cursor === "" || page.activities.length < limit);
+        if (shouldWarm) {
+            deps.activityWarmByKey.set(warmKey, Date.now());
+            try {
+                const warmLimit = Math.max(800, Math.min(6_000, limit * 10));
+                const data = await deps.getLiveActivity({
+                    run,
+                    since,
+                    limit: warmLimit,
+                });
+                const remote = Array.isArray(data.activities) ? data.activities : [];
+                {
+                    const ctx = toContextBundle(deps.readAgentContexts());
+                    const withContexts = deps.applyAgentContextsToActivity(remote, ctx);
+                    deps.appendActivityItems(withContexts);
+                }
+                page = deps.listActivityPage({
+                    limit,
+                    runId: run,
+                    since,
+                    until,
+                    cursor,
+                });
+                {
+                    const ctx = toContextBundle(deps.readAgentContexts());
+                    page = {
+                        ...page,
+                        activities: deps.applyAgentContextsToActivity(page.activities, ctx),
+                    };
+                }
+            }
+            catch {
+                // best effort
+            }
+        }
+        deps.sendJson(res, 200, page);
+    }
+    router.add("GET", "live/activity/page", async ({ query, res }) => renderLiveActivityPage(query, res), "Paginated live activity");
+    router.add("HEAD", "live/activity/page", async ({ query, res }) => renderLiveActivityPage(query, res), "Paginated live activity (HEAD)");
+    async function renderLiveActivity(query, res) {
+        try {
+            const run = query.get("run");
+            const limit = query.get("limit") ? Number(query.get("limit")) : undefined;
+            const since = query.get("since");
+            const data = await deps.getLiveActivity({
+                run,
+                since,
+                limit: Number.isFinite(limit) ? limit : undefined,
+            });
+            let activities = Array.isArray(data.activities) ? data.activities : [];
+            let total = typeof data.total === "number" && Number.isFinite(data.total)
+                ? Number(data.total)
+                : activities.length;
+            try {
+                const buffered = await deps.outboxReadAllItems();
+                if (buffered.length > 0) {
+                    let merged = [...activities, ...buffered];
+                    if (run && run.trim().length > 0) {
+                        merged = merged.filter((item) => item.runId === run);
+                    }
+                    if (since && since.trim().length > 0) {
+                        const sinceEpoch = Date.parse(since);
+                        if (Number.isFinite(sinceEpoch)) {
+                            merged = merged.filter((item) => Date.parse(item.timestamp) >= sinceEpoch);
+                        }
+                    }
+                    merged.sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp));
+                    const deduped = [];
+                    const seen = new Set();
+                    for (const item of merged) {
+                        if (seen.has(item.id))
+                            continue;
+                        seen.add(item.id);
+                        deduped.push(item);
+                    }
+                    total = deduped.length;
+                    if (Number.isFinite(limit)) {
+                        const cap = Math.max(1, Math.floor(Number(limit)));
+                        activities = deduped.slice(0, cap);
+                    }
+                    else {
+                        activities = deduped;
+                    }
+                }
+            }
+            catch {
+                // best effort
+            }
+            try {
+                const ctx = toContextBundle(deps.readAgentContexts());
+                const withContexts = deps.applyAgentContextsToActivity(activities, ctx);
+                if (withContexts.length > 0)
+                    deps.appendActivityItems(withContexts);
+                deps.sendJson(res, 200, { ...data, activities: withContexts, total });
+            }
+            catch {
+                deps.sendJson(res, 200, { ...data, activities, total });
+            }
+        }
+        catch (err) {
+            try {
+                const run = query.get("run");
+                const limitRaw = query.get("limit") ? Number(query.get("limit")) : undefined;
+                const since = query.get("since");
+                const limit = Number.isFinite(limitRaw) ? Math.max(1, Number(limitRaw)) : 240;
+                const localSnapshot = await deps.loadLocalOpenClawSnapshot(Math.max(limit, 240));
+                let local = await deps.toLocalLiveActivity(localSnapshot, Math.max(limit, 240));
+                if (run && run.trim().length > 0) {
+                    local = {
+                        activities: local.activities.filter((item) => item.runId === run),
+                        total: local.activities.filter((item) => item.runId === run).length,
+                    };
+                }
+                if (since && since.trim().length > 0) {
+                    const sinceEpoch = Date.parse(since);
+                    if (Number.isFinite(sinceEpoch)) {
+                        const filtered = local.activities.filter((item) => Date.parse(item.timestamp) >= sinceEpoch);
+                        local = {
+                            activities: filtered,
+                            total: filtered.length,
+                        };
+                    }
+                }
+                const ctx = toContextBundle(deps.readAgentContexts());
+                const activitiesWithContexts = deps.applyAgentContextsToActivity(local.activities, ctx);
+                let merged = activitiesWithContexts;
+                try {
+                    const buffered = await deps.outboxReadAllItems();
+                    if (buffered.length > 0) {
+                        const byId = new Map();
+                        for (const item of [...merged, ...buffered]) {
+                            if (!item || typeof item.id !== "string")
+                                continue;
+                            byId.set(item.id, item);
+                        }
+                        merged = Array.from(byId.values()).sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp));
+                    }
+                }
+                catch {
+                    // best effort
+                }
+                try {
+                    deps.appendActivityItems(merged);
+                }
+                catch {
+                    // best effort
+                }
+                deps.sendJson(res, 200, {
+                    activities: merged.slice(0, limit),
+                    total: merged.length,
+                });
+            }
+            catch (localErr) {
+                deps.sendJson(res, 500, {
+                    error: deps.safeErrorMessage(err),
+                    localFallbackError: deps.safeErrorMessage(localErr),
+                });
+            }
+        }
+    }
+    router.add("GET", "live/activity", async ({ query, res }) => renderLiveActivity(query, res), "Legacy live activity endpoint");
+    router.add("HEAD", "live/activity", async ({ query, res }) => renderLiveActivity(query, res), "Legacy live activity endpoint (HEAD)");
+    async function renderLiveActivityDetail(query, res) {
+        const turnId = query.get("turnId") ?? query.get("turn_id");
+        const sessionKey = query.get("sessionKey") ?? query.get("session_key");
+        const run = query.get("run");
+        if (!turnId || turnId.trim().length === 0) {
+            deps.sendJson(res, 400, { error: "turnId is required" });
+            return;
+        }
+        try {
+            const detail = await deps.loadLocalTurnDetail({
+                turnId,
+                sessionKey,
+                runId: run,
+            });
+            if (!detail) {
+                deps.sendJson(res, 404, {
+                    error: "Turn detail unavailable",
+                    turnId,
+                });
+                return;
+            }
+            deps.sendJson(res, 200, { detail });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, { error: deps.safeErrorMessage(err), turnId });
+        }
+    }
+    router.add("GET", "live/activity/detail", async ({ query, res }) => renderLiveActivityDetail(query, res), "Detailed activity turn view");
+    router.add("HEAD", "live/activity/detail", async ({ query, res }) => renderLiveActivityDetail(query, res), "Detailed activity turn view (HEAD)");
+    router.add("GET", "live/filesystem/open", ({ query, res }) => {
+        const rawPath = query.get("path") ?? "";
+        if (!rawPath.trim()) {
+            deps.sendJson(res, 400, { error: "path is required" });
+            return;
+        }
+        const pathInput = rawPath.trim();
+        if (/^https?:\/\//i.test(pathInput)) {
+            res.writeHead(302, {
+                Location: pathInput,
+                ...deps.securityHeaders,
+                ...deps.corsHeaders,
+            });
+            res.end();
+            return;
+        }
+        const resolvedPath = deps.resolveFilesystemOpenPath(pathInput);
+        const escapedInput = deps.escapeHtml(pathInput);
+        const escapedResolved = deps.escapeHtml(resolvedPath);
+        const shellPath = resolvedPath.replaceAll("'", "'\\''");
+        if (!deps.existsSync(resolvedPath)) {
+            deps.sendHtml(res, 404, `<!doctype html><html><head><meta charset="utf-8"/><title>Path Not Found</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre-wrap;word-break:break-word}a{color:#BFFF00}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Path not found</h1><p style="margin:0 0 12px;color:#9ca3af;">The evidence path no longer exists.</p><pre>${escapedInput}</pre><p style="margin:12px 0 0;color:#9ca3af;">Resolved as:</p><pre>${escapedResolved}</pre></body></html>`);
+            return;
+        }
+        try {
+            const stats = deps.statSync(resolvedPath);
+            if (stats.isDirectory()) {
+                const entries = deps.readdirSync(resolvedPath);
+                const visibleEntries = entries.slice(0, deps.filePreviewMaxDirEntries);
+                const items = visibleEntries
+                    .map((name) => {
+                    const nextPath = deps.resolvePath(resolvedPath, name);
+                    const href = `/orgx/api/live/filesystem/open?path=${encodeURIComponent(nextPath)}`;
+                    return `<li style="margin:0 0 6px;"><a href="${href}" target="_blank" rel="noreferrer" style="color:#BFFF00;text-decoration:none;">${deps.escapeHtml(name)}</a></li>`;
+                })
+                    .join("");
+                const overflowNote = entries.length > visibleEntries.length
+                    ? `<p style="margin:12px 0 0;color:#9ca3af;">Showing ${visibleEntries.length} of ${entries.length} entries.</p>`
+                    : "";
+                deps.sendHtml(res, 200, `<!doctype html><html><head><meta charset="utf-8"/><title>Directory Preview</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre,ul{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px}ul{list-style:none;margin:0;max-height:70vh;overflow:auto}pre{white-space:pre-wrap;word-break:break-word}code{color:#7dd3c0}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Directory</h1><p style="margin:0 0 12px;color:#9ca3af;">${escapedResolved}</p><ul>${items || "<li style=\"color:#9ca3af;\">(empty)</li>"}</ul>${overflowNote}<p style="margin:12px 0 0;color:#9ca3af;">Tip: open in terminal with <code>ls -la '${deps.escapeHtml(shellPath)}'</code></p></body></html>`);
+                return;
+            }
+            if (!stats.isFile()) {
+                deps.sendHtml(res, 200, `<!doctype html><html><head><meta charset="utf-8"/><title>Unsupported Path</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre-wrap;word-break:break-word}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Unsupported path type</h1><p style="margin:0 0 12px;color:#9ca3af;">Only files and directories are previewable.</p><pre>${escapedResolved}</pre></body></html>`);
+                return;
+            }
+            const totalBytes = Number.isFinite(stats.size) ? Math.max(0, stats.size) : 0;
+            const { previewBuffer, truncated } = deps.readFilePreview(resolvedPath, totalBytes);
+            const isBinary = previewBuffer.includes(0);
+            const sizeLabel = `${totalBytes.toLocaleString()} bytes`;
+            if (isBinary) {
+                deps.sendHtml(res, 200, `<!doctype html><html><head><meta charset="utf-8"/><title>Binary File</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre-wrap;word-break:break-word}code{color:#7dd3c0}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Binary file</h1><p style="margin:0 0 12px;color:#9ca3af;">Cannot render binary content in browser preview.</p><pre>${escapedResolved}\n${deps.escapeHtml(sizeLabel)}</pre><p style="margin:12px 0 0;color:#9ca3af;">Inspect in terminal with <code>file '${deps.escapeHtml(shellPath)}'</code></p></body></html>`);
+                return;
+            }
+            const previewText = previewBuffer.toString("utf8");
+            const truncationNote = truncated
+                ? `<p style="margin:12px 0 0;color:#9ca3af;">Preview truncated to first ${deps.filePreviewMaxBytes.toLocaleString()} bytes.</p>`
+                : "";
+            deps.sendHtml(res, 200, `<!doctype html><html><head><meta charset="utf-8"/><title>File Preview</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre;overflow:auto;max-height:75vh}code{color:#7dd3c0}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">File preview</h1><p style="margin:0 0 12px;color:#9ca3af;">${escapedResolved}</p><p style="margin:0 0 12px;color:#9ca3af;">${deps.escapeHtml(sizeLabel)}</p><pre>${deps.escapeHtml(previewText)}</pre>${truncationNote}<p style="margin:12px 0 0;color:#9ca3af;">Open in terminal with <code>cat '${deps.escapeHtml(shellPath)}'</code></p></body></html>`);
+        }
+        catch (err) {
+            deps.sendHtml(res, 500, `<!doctype html><html><head><meta charset="utf-8"/><title>Preview Error</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre-wrap;word-break:break-word}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Unable to preview path</h1><p style="margin:0 0 12px;color:#9ca3af;">${deps.escapeHtml(deps.safeErrorMessage(err))}</p><pre>${escapedResolved}</pre></body></html>`);
+        }
+    }, "Open filesystem evidence path");
+    router.add("*", "live/filesystem/open", ({ res }) => {
+        deps.sendJson(res, 405, { error: "Use GET /orgx/api/live/filesystem/open?path=..." });
+    }, "Reject unsupported methods for live/filesystem/open");
+    async function renderLiveStream(query, req, res) {
+        const write = res.write?.bind(res);
+        if (!write) {
+            deps.sendJson(res, 501, { error: "Streaming not supported" });
+            return;
+        }
+        const queryString = query.toString();
+        const target = `${deps.config.baseUrl.replace(/\/+$/, "")}/api/client/live/stream${queryString ? `?${queryString}` : ""}`;
+        let upstreamAbortController = null;
+        let reader = null;
+        let closed = false;
+        let streamOpened = false;
+        let idleTimer = null;
+        let heartbeatTimer = null;
+        let heartbeatBackpressure = false;
+        const sseDecoder = new TextDecoder("utf-8");
+        let sseBuffer = "";
+        const consumeSseText = (chunk) => {
+            if (!chunk)
+                return;
+            sseBuffer += chunk.replace(/\r\n/g, "\n");
+            while (true) {
+                const boundary = sseBuffer.indexOf("\n\n");
+                if (boundary === -1)
+                    return;
+                const rawEvent = sseBuffer.slice(0, boundary);
+                sseBuffer = sseBuffer.slice(boundary + 2);
+                const lines = rawEvent.split("\n").map((l) => l.replace(/\r$/, ""));
+                let eventName = null;
+                const dataLines = [];
+                for (const line of lines) {
+                    if (!line)
+                        continue;
+                    if (line.startsWith(":"))
+                        continue;
+                    if (line.startsWith("event:")) {
+                        eventName = line.slice("event:".length).trim() || null;
+                        continue;
+                    }
+                    if (line.startsWith("data:")) {
+                        dataLines.push(line.slice("data:".length).trimStart());
+                        continue;
+                    }
+                }
+                if (!eventName || dataLines.length === 0)
+                    continue;
+                const dataText = dataLines.join("\n").trim();
+                if (!dataText)
+                    continue;
+                try {
+                    if (eventName === "activity.appended") {
+                        const parsed = JSON.parse(dataText);
+                        const list = Array.isArray(parsed) ? parsed : [];
+                        if (list.length > 0) {
+                            const ctx = toContextBundle(deps.readAgentContexts());
+                            deps.appendActivityItems(deps.applyAgentContextsToActivity(list, ctx));
+                        }
+                    }
+                    else if (eventName === "snapshot") {
+                        const parsed = JSON.parse(dataText);
+                        const list = Array.isArray(parsed?.activity) ? parsed.activity : [];
+                        if (list.length > 0) {
+                            const ctx = toContextBundle(deps.readAgentContexts());
+                            deps.appendActivityItems(deps.applyAgentContextsToActivity(list, ctx));
+                        }
+                    }
+                }
+                catch {
+                    // ignore malformed payloads
+                }
+            }
+        };
+        const clearIdleTimer = () => {
+            if (idleTimer) {
+                clearTimeout(idleTimer);
+                idleTimer = null;
+            }
+        };
+        const clearHeartbeatTimer = () => {
+            if (heartbeatTimer) {
+                clearInterval(heartbeatTimer);
+                heartbeatTimer = null;
+            }
+        };
+        const abortUpstream = () => {
+            try {
+                upstreamAbortController?.abort();
+            }
+            catch {
+                // best effort
+            }
+            upstreamAbortController = null;
+        };
+        const closeStream = () => {
+            if (closed)
+                return;
+            closed = true;
+            clearIdleTimer();
+            clearHeartbeatTimer();
+            abortUpstream();
+            if (reader) {
+                void reader.cancel().catch(() => undefined);
+            }
+            if (streamOpened && !res.writableEnded) {
+                res.end();
+            }
+        };
+        const resetIdleTimer = () => {
+            clearIdleTimer();
+            idleTimer = setTimeout(() => {
+                closeStream();
+            }, deps.streamIdleTimeoutMs);
+        };
+        try {
+            const includeUserHeader = Boolean(deps.config.userId && deps.config.userId.trim().length > 0) &&
+                !deps.isUserScopedApiKey(deps.config.apiKey);
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream; charset=utf-8",
+                "Cache-Control": "no-cache, no-transform",
+                Connection: "keep-alive",
+                ...deps.securityHeaders,
+                ...deps.corsHeaders,
+            });
+            streamOpened = true;
+            heartbeatTimer = setInterval(() => {
+                if (closed || heartbeatBackpressure)
+                    return;
+                try {
+                    const accepted = write(Buffer.from(`: ping ${Date.now()}\n`, "utf8"));
+                    resetIdleTimer();
+                    if (accepted === false) {
+                        heartbeatBackpressure = true;
+                        if (typeof res.once === "function") {
+                            res.once("drain", () => {
+                                heartbeatBackpressure = false;
+                                if (!closed)
+                                    resetIdleTimer();
+                            });
+                        }
+                    }
+                }
+                catch {
+                    closeStream();
+                }
+            }, 20_000);
+            heartbeatTimer.unref?.();
+            req.on?.("close", closeStream);
+            req.on?.("aborted", closeStream);
+            res.on?.("close", closeStream);
+            res.on?.("finish", closeStream);
+            const waitForDrain = async () => {
+                if (typeof res.once === "function") {
+                    await new Promise((resolve) => {
+                        res.once?.("drain", () => resolve());
+                    });
+                }
+            };
+            const sleep = async (ms) => {
+                await new Promise((resolve) => setTimeout(resolve, ms));
+            };
+            const connectAndPump = async () => {
+                let attempt = 0;
+                while (!closed) {
+                    abortUpstream();
+                    upstreamAbortController = new AbortController();
+                    let upstream = null;
+                    try {
+                        upstream = await fetch(target, {
+                            method: "GET",
+                            headers: {
+                                Authorization: `Bearer ${deps.config.apiKey}`,
+                                Accept: "text/event-stream",
+                                ...(includeUserHeader ? { "X-Orgx-User-Id": deps.config.userId } : {}),
+                            },
+                            signal: upstreamAbortController.signal,
+                        });
+                    }
+                    catch {
+                        upstream = null;
+                    }
+                    const contentType = upstream?.headers.get("content-type")?.toLowerCase() ?? "";
+                    if (!upstream ||
+                        !upstream.ok ||
+                        !contentType.includes("text/event-stream") ||
+                        !upstream.body) {
+                        const status = upstream?.status ?? null;
+                        const preview = upstream
+                            ? (await upstream.text().catch(() => ""))
+                                .replace(/\s+/g, " ")
+                                .slice(0, 200)
+                            : null;
+                        try {
+                            write(Buffer.from(`: upstream unavailable status=${status ?? "error"} ${preview ? `preview=${JSON.stringify(preview)}` : ""}\n`, "utf8"));
+                        }
+                        catch {
+                            closeStream();
+                            return;
+                        }
+                        resetIdleTimer();
+                        attempt += 1;
+                        const backoffMs = Math.min(15_000, 750 * Math.pow(1.6, Math.min(attempt, 10)));
+                        await sleep(backoffMs);
+                        continue;
+                    }
+                    attempt = 0;
+                    reader = upstream.body.getReader();
+                    const streamReader = reader;
+                    resetIdleTimer();
+                    try {
+                        while (!closed) {
+                            const { done, value } = await streamReader.read();
+                            if (done)
+                                break;
+                            if (!value || value.byteLength === 0)
+                                continue;
+                            resetIdleTimer();
+                            try {
+                                consumeSseText(sseDecoder.decode(value, { stream: true }));
+                            }
+                            catch {
+                                // best effort
+                            }
+                            const accepted = write(Buffer.from(value));
+                            if (accepted === false) {
+                                await waitForDrain();
+                            }
+                        }
+                    }
+                    catch {
+                        // swallow; we'll reconnect unless the client is gone
+                    }
+                    finally {
+                        try {
+                            await streamReader.cancel();
+                        }
+                        catch {
+                            // ignore
+                        }
+                        if (reader === streamReader) {
+                            reader = null;
+                        }
+                    }
+                    if (!closed) {
+                        await sleep(300);
+                    }
+                }
+            };
+            void connectAndPump();
+        }
+        catch (err) {
+            closeStream();
+            if (!streamOpened && !res.writableEnded) {
+                deps.sendJson(res, 500, {
+                    error: deps.safeErrorMessage(err),
+                });
+            }
+        }
+    }
+    router.add("GET", "live/stream", async ({ query, req, res }) => renderLiveStream(query, req, res), "Proxy live SSE stream");
+    router.add("HEAD", "live/stream", async ({ query, req, res }) => renderLiveStream(query, req, res), "Proxy live SSE stream (HEAD)");
+}

package/dist/http/routes/live-misc.d.ts

@@ -0,0 +1,69 @@
+import type { Router } from "../router.js";
+import type { Entity } from "../../types.js";
+type JsonRecord = Record<string, unknown>;
+type LiveInitiativesResponse = {
+    initiatives: unknown[];
+    total?: number;
+};
+type LiveDecisionsResponse = {
+    decisions: Entity[];
+    total: number;
+};
+type HandoffsResponse = {
+    handoffs: unknown[];
+};
+type LocalSnapshot = Awaited<ReturnType<typeof import("../../local-openclaw.js").loadLocalOpenClawSnapshot>>;
+type RegisterLiveMiscRoutesDeps<TReq, TRes> = {
+    parseJsonRequest: (req: TReq) => Promise<JsonRecord>;
+    pickString: (input: Record<string, unknown>, keys: string[]) => string | null;
+    summarizeActivityHeadline: (input: {
+        text: string;
+        title: string | null;
+        type: string | null;
+    }) => Promise<{
+        headline: string;
+        source: string;
+        model: string | null;
+    }>;
+    getLiveAgents: (input: {
+        initiative: string | null;
+        includeIdle: boolean | undefined;
+    }) => Promise<unknown>;
+    getLiveInitiatives: (input: {
+        id: string | null;
+        limit: number | undefined;
+    }) => Promise<LiveInitiativesResponse>;
+    getLiveDecisions: (input: {
+        status: string;
+        limit: number;
+    }) => Promise<LiveDecisionsResponse>;
+    getHandoffs: () => Promise<HandoffsResponse>;
+    loadLocalOpenClawSnapshot: (limit: number) => Promise<LocalSnapshot>;
+    toLocalLiveAgents: (snapshot: LocalSnapshot) => {
+        agents: Array<{
+            initiativeId: string | null;
+            status: string;
+        }>;
+    };
+    toLocalLiveInitiatives: (snapshot: LocalSnapshot) => {
+        initiatives: Array<{
+            id: string;
+            title: string;
+            status: string;
+            updatedAt: string | null;
+            sessionCount: number;
+            activeAgents: number;
+        }>;
+    };
+    localInitiativeStatusOverrides: Map<string, {
+        status: string;
+        updatedAt: string;
+    }>;
+    mapDecisionEntity: (entry: Entity) => {
+        waitingMinutes: number;
+    };
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+};
+export declare function registerLiveMiscRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterLiveMiscRoutesDeps<TReq, TRes>): void;
+export {};