@useorgx/openclaw-plugin 0.4.9 → 0.7.2

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

@@ -1,270 +1,36 @@
-function toContextBundle(value) {
-    return {
-        agents: value.agents ?? {},
-        runs: value.runs ?? {},
-    };
-}
 export function registerLiveLegacyRoutes(router, deps) {
+    const sendDeprecated = (res, endpoint, replacement) => {
+        deps.sendJson(res, 410, {
+            error: `${endpoint} is deprecated`,
+            replacement,
+            required_scope: "workspace_id",
+        });
+    };
     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),
-                });
-            }
-        }
+        sendDeprecated(res, "/orgx/api/live/sessions", "/orgx/api/live/snapshot");
+        void query;
+        return;
     }
     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);
+        sendDeprecated(res, "/orgx/api/live/activity/page", "/orgx/api/live/snapshot-v2");
+        void query;
+        return;
     }
     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),
-                });
-            }
-        }
+        sendDeprecated(res, "/orgx/api/live/activity", "/orgx/api/live/snapshot");
+        void query;
+        return;
     }
     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 });
-        }
+        sendDeprecated(res, "/orgx/api/live/activity/detail", "/orgx/api/live/snapshot-v2");
+        void query;
+        return;
     }
     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)");
@@ -336,262 +102,10 @@ export function registerLiveLegacyRoutes(router, deps) {
         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),
-                });
-            }
-        }
+        sendDeprecated(res, "/orgx/api/live/stream", "/orgx/api/live/snapshot-v2");
+        void query;
+        void req;
+        return;
     }
     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

@@ -4,6 +4,11 @@ type JsonRecord = Record<string, unknown>;
 type LiveInitiativesResponse = {
     initiatives: unknown[];
     total?: number;
+    pagination?: {
+        limit?: number;
+        offset?: number;
+        has_more?: boolean;
+    };
 };
 type LiveDecisionsResponse = {
     decisions: Entity[];
@@ -27,17 +32,24 @@ type RegisterLiveMiscRoutesDeps<TReq, TRes> = {
     }>;
     getLiveAgents: (input: {
         initiative: string | null;
+        projectId: string | null;
         includeIdle: boolean | undefined;
     }) => Promise<unknown>;
     getLiveInitiatives: (input: {
         id: string | null;
+        projectId: string | null;
         limit: number | undefined;
+        offset: number | undefined;
     }) => Promise<LiveInitiativesResponse>;
     getLiveDecisions: (input: {
         status: string;
+        projectId: string | null;
         limit: number;
     }) => Promise<LiveDecisionsResponse>;
     getHandoffs: () => Promise<HandoffsResponse>;
+    listInitiativeIdsForProject: (input: {
+        projectId: string;
+    }) => Promise<string[]>;
     loadLocalOpenClawSnapshot: (limit: number) => Promise<LocalSnapshot>;
     toLocalLiveAgents: (snapshot: LocalSnapshot) => {
         agents: Array<{