@useorgx/openclaw-plugin 0.4.9 → 0.7.0

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

@@ -1,4 +1,37 @@
+import { resolveWorkspaceScope, workspaceScopeFromHeaders, } from "../helpers/workspace-scope.js";
+function asRecord(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return null;
+    return input;
+}
+function pickStringFromRecord(input, keys) {
+    if (!input)
+        return null;
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value !== "string")
+            continue;
+        const normalized = value.trim();
+        if (normalized.length > 0)
+            return normalized;
+    }
+    return null;
+}
+function resolveInitiativeIdFromRecord(input) {
+    const direct = pickStringFromRecord(input, ["initiativeId", "initiative_id", "initiative"]);
+    if (direct)
+        return direct;
+    const metadata = asRecord(input.metadata);
+    return pickStringFromRecord(metadata, ["initiativeId", "initiative_id", "initiative"]);
+}
 export function registerLiveMiscRoutes(router, deps) {
+    async function resolveProjectInitiativeSet(projectIdRaw) {
+        const projectId = projectIdRaw?.trim() ?? "";
+        if (!projectId)
+            return null;
+        const ids = await deps.listInitiativeIdsForProject({ projectId });
+        return new Set(ids);
+    }
     router.add("POST", "live/activity/headline", async ({ req, res }) => {
         try {
             const payload = await deps.parseJsonRequest(req);
@@ -29,20 +62,59 @@ export function registerLiveMiscRoutes(router, deps) {
     router.add("*", "live/activity/headline", ({ res }) => {
         deps.sendJson(res, 405, { error: "Use POST /orgx/api/live/activity/headline" });
     }, "Reject unsupported methods for live/activity/headline");
-    async function renderLiveAgents(query, res) {
+    async function renderLiveAgents(query, res, headerScope) {
+        const scope = resolveWorkspaceScope(query, headerScope, {
+            allowProjectScope: false,
+        });
+        if (scope.error) {
+            deps.sendJson(res, 400, { error: scope.error });
+            return;
+        }
+        const workspaceId = scope.workspaceId;
         try {
             const initiative = query.get("initiative");
+            const projectInitiatives = await resolveProjectInitiativeSet(workspaceId);
             const includeIdleRaw = query.get("include_idle");
             const includeIdle = includeIdleRaw === null ? undefined : includeIdleRaw !== "false";
-            const data = await deps.getLiveAgents({
+            const data = (await deps.getLiveAgents({
                 initiative,
+                projectId: workspaceId,
                 includeIdle,
+            }));
+            const agents = Array.isArray(data.agents) ? data.agents : [];
+            const scopedAgents = agents.filter((entry) => {
+                const row = asRecord(entry);
+                if (!row)
+                    return false;
+                const initiativeId = resolveInitiativeIdFromRecord(row);
+                if (initiative && initiative.trim().length > 0 && initiativeId !== initiative)
+                    return false;
+                if (projectInitiatives && (!initiativeId || !projectInitiatives.has(initiativeId))) {
+                    return false;
+                }
+                if (includeIdle === false) {
+                    const status = pickStringFromRecord(row, ["status"]);
+                    if (status === "idle")
+                        return false;
+                }
+                return true;
+            });
+            const summary = scopedAgents.reduce((acc, entry) => {
+                const row = asRecord(entry);
+                const status = pickStringFromRecord(row, ["status"]) ?? "unknown";
+                acc[status] = (acc[status] ?? 0) + 1;
+                return acc;
+            }, {});
+            deps.sendJson(res, 200, {
+                ...data,
+                agents: scopedAgents,
+                summary,
             });
-            deps.sendJson(res, 200, data);
         }
         catch (err) {
             try {
                 const initiative = query.get("initiative");
+                const projectInitiatives = await resolveProjectInitiativeSet(workspaceId);
                 const includeIdleRaw = query.get("include_idle");
                 const includeIdle = includeIdleRaw === null ? undefined : includeIdleRaw !== "false";
                 const localSnapshot = await deps.loadLocalOpenClawSnapshot(240);
@@ -51,6 +123,12 @@ export function registerLiveMiscRoutes(router, deps) {
                 if (initiative && initiative.trim().length > 0) {
                     agents = agents.filter((agent) => agent.initiativeId === initiative);
                 }
+                if (projectInitiatives) {
+                    agents = agents.filter((agent) => {
+                        const initiativeId = typeof agent.initiativeId === "string" ? agent.initiativeId : "";
+                        return initiativeId.length > 0 && projectInitiatives.has(initiativeId);
+                    });
+                }
                 if (includeIdle === false) {
                     agents = agents.filter((agent) => agent.status !== "idle");
                 }
@@ -68,50 +146,161 @@ export function registerLiveMiscRoutes(router, deps) {
             }
         }
     }
-    router.add("GET", "live/agents", async ({ query, res }) => renderLiveAgents(query, res), "Get live agents");
-    router.add("HEAD", "live/agents", async ({ query, res }) => renderLiveAgents(query, res), "Get live agents (HEAD)");
-    async function renderLiveInitiatives(query, res) {
+    router.add("GET", "live/agents", async ({ query, res, req }) => renderLiveAgents(query, res, workspaceScopeFromHeaders(req?.headers)), "Get live agents");
+    router.add("HEAD", "live/agents", async ({ query, res, req }) => renderLiveAgents(query, res, workspaceScopeFromHeaders(req?.headers)), "Get live agents (HEAD)");
+    async function renderLiveInitiatives(query, res, headerScope) {
+        const scope = resolveWorkspaceScope(query, headerScope, {
+            allowProjectScope: false,
+        });
+        if (scope.error) {
+            deps.sendJson(res, 400, { error: scope.error });
+            return;
+        }
+        const workspaceId = scope.workspaceId;
         try {
             const id = query.get("id");
-            const limit = query.get("limit") ? Number(query.get("limit")) : undefined;
+            const projectInitiatives = await resolveProjectInitiativeSet(workspaceId);
+            const limitRaw = query.get("limit") ? Number(query.get("limit")) : undefined;
+            const offsetRaw = query.get("offset") ? Number(query.get("offset")) : undefined;
+            const requestedLimit = Number.isFinite(limitRaw)
+                ? Math.max(1, Math.floor(Number(limitRaw)))
+                : null;
+            const requestedOffset = Number.isFinite(offsetRaw)
+                ? Math.max(0, Math.floor(Number(offsetRaw)))
+                : 0;
             const data = await deps.getLiveInitiatives({
                 id,
-                limit: Number.isFinite(limit) ? limit : undefined,
+                projectId: workspaceId,
+                limit: requestedLimit ?? undefined,
+                offset: requestedOffset,
             });
             const payload = data;
-            const initiatives = Array.isArray(payload.initiatives)
-                ? payload.initiatives.map((entry) => {
-                    if (!entry || typeof entry !== "object")
-                        return entry;
-                    const row = entry;
+            const rawInitiatives = Array.isArray(payload.initiatives) ? payload.initiatives : [];
+            const applyLocalOverrides = (rows) => rows.map((entry) => {
+                if (!entry || typeof entry !== "object")
+                    return entry;
+                const row = entry;
+                const initiativeId = deps.pickString(row, ["id"]);
+                if (!initiativeId)
+                    return entry;
+                const override = deps.localInitiativeStatusOverrides.get(initiativeId) ?? null;
+                if (!override)
+                    return entry;
+                return {
+                    ...row,
+                    status: override.status,
+                    updatedAt: deps.pickString(row, ["updatedAt", "updated_at"]) ?? override.updatedAt,
+                };
+            });
+            let initiatives = Array.isArray(payload.initiatives)
+                ? payload.initiatives
+                    .filter((entry) => {
+                    const row = asRecord(entry);
+                    if (!row)
+                        return false;
                     const initiativeId = deps.pickString(row, ["id"]);
                     if (!initiativeId)
-                        return entry;
-                    const override = deps.localInitiativeStatusOverrides.get(initiativeId) ?? null;
-                    if (!override)
-                        return entry;
-                    return {
-                        ...row,
-                        status: override.status,
-                        updatedAt: deps.pickString(row, ["updatedAt", "updated_at"]) ?? override.updatedAt,
-                    };
+                        return false;
+                    if (id && id.trim().length > 0 && initiativeId !== id)
+                        return false;
+                    if (projectInitiatives && !projectInitiatives.has(initiativeId))
+                        return false;
+                    return true;
                 })
+                    .map((entry) => entry)
                 : payload.initiatives;
+            initiatives = Array.isArray(initiatives) ? applyLocalOverrides(initiatives) : initiatives;
+            let fallbackHydratedFromScope = false;
+            if (Array.isArray(initiatives) &&
+                initiatives.length === 0 &&
+                !id &&
+                projectInitiatives &&
+                projectInitiatives.size > 0) {
+                const scopedIds = Array.from(projectInitiatives.values()).slice(requestedOffset, requestedOffset + (requestedLimit ?? 50));
+                const hydrated = [];
+                for (const initiativeId of scopedIds) {
+                    try {
+                        const single = await deps.getLiveInitiatives({
+                            id: initiativeId,
+                            projectId: null,
+                            limit: 1,
+                            offset: 0,
+                        });
+                        const singleRows = Array.isArray(single?.initiatives)
+                            ? single.initiatives
+                            : [];
+                        const match = singleRows.find((entry) => {
+                            const row = asRecord(entry);
+                            const rowId = deps.pickString(row ?? {}, ["id"]);
+                            return rowId === initiativeId;
+                        });
+                        if (match)
+                            hydrated.push(match);
+                    }
+                    catch {
+                        // Ignore per-initiative hydration failures and continue with remaining IDs.
+                    }
+                }
+                if (hydrated.length > 0) {
+                    initiatives = applyLocalOverrides(hydrated);
+                    fallbackHydratedFromScope = true;
+                }
+            }
+            const remotePagination = asRecord(payload.pagination);
+            const remoteHasMoreComputed = typeof remotePagination?.has_more === "boolean"
+                ? remotePagination.has_more
+                : typeof payload.total === "number"
+                    ? requestedOffset + rawInitiatives.length < payload.total
+                    : requestedLimit !== null
+                        ? rawInitiatives.length >= requestedLimit
+                        : false;
+            const scopedTotal = fallbackHydratedFromScope && projectInitiatives
+                ? projectInitiatives.size
+                : Array.isArray(initiatives)
+                    ? initiatives.length
+                    : 0;
+            const scopedHasMore = fallbackHydratedFromScope && projectInitiatives
+                ? requestedOffset + (Array.isArray(initiatives) ? initiatives.length : 0) <
+                    projectInitiatives.size
+                : remoteHasMoreComputed;
             deps.sendJson(res, 200, {
                 ...payload,
                 initiatives,
+                total: scopedTotal,
+                pagination: {
+                    ...(remotePagination ?? {}),
+                    limit: typeof remotePagination?.limit === "number"
+                        ? remotePagination.limit
+                        : (requestedLimit ?? rawInitiatives.length),
+                    offset: typeof remotePagination?.offset === "number"
+                        ? remotePagination.offset
+                        : requestedOffset,
+                    has_more: scopedHasMore,
+                },
+                ...(fallbackHydratedFromScope
+                    ? {
+                        scopedFallback: true,
+                        scopedFallbackReason: "upstream live initiatives page did not contain requested workspace rows",
+                    }
+                    : {}),
             });
         }
         catch (err) {
             try {
                 const id = query.get("id");
+                const projectInitiatives = await resolveProjectInitiativeSet(workspaceId);
                 const limitRaw = query.get("limit") ? Number(query.get("limit")) : undefined;
+                const offsetRaw = query.get("offset") ? Number(query.get("offset")) : undefined;
                 const limit = Number.isFinite(limitRaw) ? Math.max(1, Number(limitRaw)) : 100;
+                const offset = Number.isFinite(offsetRaw) ? Math.max(0, Number(offsetRaw)) : 0;
                 const local = deps.toLocalLiveInitiatives(await deps.loadLocalOpenClawSnapshot(240));
                 let initiatives = local.initiatives;
                 if (id && id.trim().length > 0) {
                     initiatives = initiatives.filter((item) => item.id === id);
                 }
+                if (projectInitiatives) {
+                    initiatives = initiatives.filter((item) => projectInitiatives.has(item.id));
+                }
                 initiatives = initiatives.map((item) => {
                     const override = deps.localInitiativeStatusOverrides.get(item.id) ?? null;
                     if (!override)
@@ -125,7 +314,10 @@ export function registerLiveMiscRoutes(router, deps) {
                 const requestedId = id?.trim() ?? "";
                 if (requestedId.length > 0) {
                     const override = deps.localInitiativeStatusOverrides.get(requestedId) ?? null;
-                    if (override && !initiatives.some((item) => item.id === requestedId)) {
+                    const allowedByProject = !projectInitiatives || projectInitiatives.has(requestedId);
+                    if (override &&
+                        allowedByProject &&
+                        !initiatives.some((item) => item.id === requestedId)) {
                         initiatives.push({
                             id: requestedId,
                             title: `Initiative ${requestedId.slice(0, 8)}`,
@@ -138,6 +330,8 @@ export function registerLiveMiscRoutes(router, deps) {
                 }
                 else {
                     for (const [initiativeId, override] of deps.localInitiativeStatusOverrides.entries()) {
+                        if (projectInitiatives && !projectInitiatives.has(initiativeId))
+                            continue;
                         if (initiatives.some((item) => item.id === initiativeId))
                             continue;
                         initiatives.push({
@@ -150,9 +344,16 @@ export function registerLiveMiscRoutes(router, deps) {
                         });
                     }
                 }
+                const total = initiatives.length;
+                const page = initiatives.slice(offset, offset + limit);
                 deps.sendJson(res, 200, {
-                    initiatives: initiatives.slice(0, limit),
-                    total: initiatives.length,
+                    initiatives: page,
+                    total,
+                    pagination: {
+                        limit,
+                        offset,
+                        has_more: offset + page.length < total,
+                    },
                     localFallback: true,
                     warning: deps.safeErrorMessage(err),
                 });
@@ -165,22 +366,41 @@ export function registerLiveMiscRoutes(router, deps) {
             }
         }
     }
-    router.add("GET", "live/initiatives", async ({ query, res }) => renderLiveInitiatives(query, res), "Get live initiatives");
-    router.add("HEAD", "live/initiatives", async ({ query, res }) => renderLiveInitiatives(query, res), "Get live initiatives (HEAD)");
-    async function renderLiveDecisions(query, res) {
+    router.add("GET", "live/initiatives", async ({ query, res, req }) => renderLiveInitiatives(query, res, workspaceScopeFromHeaders(req?.headers)), "Get live initiatives");
+    router.add("HEAD", "live/initiatives", async ({ query, res, req }) => renderLiveInitiatives(query, res, workspaceScopeFromHeaders(req?.headers)), "Get live initiatives (HEAD)");
+    async function renderLiveDecisions(query, res, headerScope) {
+        const scope = resolveWorkspaceScope(query, headerScope, {
+            allowProjectScope: false,
+        });
+        if (scope.error) {
+            deps.sendJson(res, 400, { error: scope.error });
+            return;
+        }
+        const workspaceId = scope.workspaceId;
         try {
             const status = query.get("status") ?? "pending";
+            const projectInitiatives = await resolveProjectInitiativeSet(workspaceId);
             const limit = query.get("limit") ? Number(query.get("limit")) : 100;
             const data = await deps.getLiveDecisions({
                 status,
+                projectId: workspaceId,
                 limit: Number.isFinite(limit) ? limit : 100,
             });
             const decisions = data.decisions
                 .map(deps.mapDecisionEntity)
+                .filter((entry) => {
+                if (!projectInitiatives)
+                    return true;
+                const row = asRecord(entry);
+                if (!row)
+                    return false;
+                const initiativeId = resolveInitiativeIdFromRecord(row);
+                return Boolean(initiativeId && projectInitiatives.has(initiativeId));
+            })
                 .sort((a, b) => b.waitingMinutes - a.waitingMinutes);
             deps.sendJson(res, 200, {
                 decisions,
-                total: data.total,
+                total: decisions.length,
             });
         }
         catch {
@@ -190,8 +410,8 @@ export function registerLiveMiscRoutes(router, deps) {
             });
         }
     }
-    router.add("GET", "live/decisions", async ({ query, res }) => renderLiveDecisions(query, res), "Get live decisions");
-    router.add("HEAD", "live/decisions", async ({ query, res }) => renderLiveDecisions(query, res), "Get live decisions (HEAD)");
+    router.add("GET", "live/decisions", async ({ query, res, req }) => renderLiveDecisions(query, res, workspaceScopeFromHeaders(req?.headers)), "Get live decisions");
+    router.add("HEAD", "live/decisions", async ({ query, res, req }) => renderLiveDecisions(query, res, workspaceScopeFromHeaders(req?.headers)), "Get live decisions (HEAD)");
     async function renderHandoffs(res) {
         try {
             const data = await deps.getHandoffs();

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

@@ -1,6 +1,7 @@
 import type { HandoffSummary, LiveActivityItem, SessionTreeResponse } from "../../types.js";
 import type { RuntimeInstanceRecord } from "../../runtime-instance-store.js";
 import type { OutboxSummary } from "../../outbox.js";
+import type { ChatThreadSummary } from "../../chat-store.js";
 import type { AgentLaunchContext, RunLaunchContext } from "../../agent-context-store.js";
 import type { Router } from "../router.js";
 type LocalSnapshot = Awaited<ReturnType<typeof import("../../local-openclaw.js").loadLocalOpenClawSnapshot>>;
@@ -12,7 +13,7 @@ type SnapshotPersistState = {
     lastFingerprint: string;
     lastPersistAt: number;
 };
-type LiveSnapshotRoutesDeps<TRes> = {
+type LiveSnapshotRoutesDeps<TReq, TRes> = {
     parsePositiveInt: (raw: string | null, fallback: number) => number;
     readSnapshotResponseCache: (key: string) => Record<string, unknown> | null;
     writeSnapshotResponseCache: (key: string, payload: Record<string, unknown>) => void;
@@ -36,11 +37,13 @@ type LiveSnapshotRoutesDeps<TRes> = {
     };
     getLiveSessions: (input: {
         initiative: string | null;
+        projectId: string | null;
         limit: number;
     }) => Promise<SessionTreeResponse>;
     getLiveActivity: (input: {
         run: string | null;
         since: string | null;
+        projectId: string | null;
         limit: number;
     }) => Promise<{
         activities: LiveActivityItem[];
@@ -50,16 +53,21 @@ type LiveSnapshotRoutesDeps<TRes> = {
     }>;
     getLiveDecisions: (input: {
         status: string;
+        projectId: string | null;
         limit: number;
     }) => Promise<{
         decisions: unknown[];
     }>;
     getLiveAgents: (input: {
         initiative: string | null;
+        projectId: string | null;
         includeIdle: boolean | undefined;
     }) => Promise<{
         agents?: unknown[];
     }>;
+    listInitiativeIdsForProject: (input: {
+        projectId: string;
+    }) => Promise<string[]>;
     mapDecisionEntity: (entry: unknown) => Record<string, unknown> & {
         waitingMinutes: number;
     };
@@ -84,7 +92,45 @@ type LiveSnapshotRoutesDeps<TRes> = {
     snapshotActivityPersistMinIntervalMs: number;
     readSnapshotPersistState: () => SnapshotPersistState;
     writeSnapshotPersistState: (state: SnapshotPersistState) => void;
+    parseJsonRequest?: (req: TReq) => Promise<Record<string, unknown>>;
+    buildNextUpQueue?: (input: {
+        initiativeId?: string | null;
+        projectId?: string | null;
+    }) => Promise<{
+        items: Array<Record<string, unknown>>;
+        degraded: string[];
+    }>;
+    bulkDecideDecisions?: (ids: string[], action: "approve" | "reject", input?: {
+        note?: string;
+        optionId?: string;
+    }) => Promise<Array<{
+        id?: string;
+        ok?: boolean;
+        error?: string;
+    }>>;
+    emitDecisionResolvedActivity?: (input: {
+        ids: string[];
+        action: "approve" | "reject";
+        note?: string | null;
+        optionId?: string | null;
+        sliceRunId?: string | null;
+        initiativeId?: string | null;
+    }) => Promise<void>;
+    runAction?: (runId: string, action: "pause" | "resume" | "cancel" | "rollback", input?: {
+        checkpointId?: string;
+        reason?: string;
+    }) => Promise<unknown>;
+    listChatThreads?: (input: {
+        commandCenterId?: string | null;
+        initiativeId?: string | null;
+        limit?: number;
+        offset?: number;
+    }) => {
+        threads: ChatThreadSummary[];
+        total: number;
+        updatedAt: string;
+    };
     sendJson: (res: TRes, status: number, payload: unknown) => void;
 };
-export declare function registerLiveSnapshotRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: LiveSnapshotRoutesDeps<TRes>): void;
+export declare function registerLiveSnapshotRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: LiveSnapshotRoutesDeps<TReq, TRes>): void;
 export {};