@useorgx/openclaw-plugin 0.4.8 → 0.7.0

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

@@ -0,0 +1,426 @@
+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);
+            const text = deps.pickString(payload, ["text", "summary", "detail", "content"]);
+            if (!text) {
+                deps.sendJson(res, 400, { error: "text is required" });
+                return;
+            }
+            const title = deps.pickString(payload, ["title", "name"]);
+            const type = deps.pickString(payload, ["type", "kind"]);
+            const result = await deps.summarizeActivityHeadline({
+                text,
+                title,
+                type,
+            });
+            deps.sendJson(res, 200, {
+                headline: result.headline,
+                source: result.source,
+                model: result.model,
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, {
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }, "Summarize an activity headline");
+    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, 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({
+                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,
+            });
+        }
+        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);
+                const local = deps.toLocalLiveAgents(localSnapshot);
+                let agents = local.agents;
+                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");
+                }
+                const summary = agents.reduce((acc, agent) => {
+                    acc[agent.status] = (acc[agent.status] ?? 0) + 1;
+                    return acc;
+                }, {});
+                deps.sendJson(res, 200, { agents, summary });
+            }
+            catch (localErr) {
+                deps.sendJson(res, 500, {
+                    error: deps.safeErrorMessage(err),
+                    localFallbackError: deps.safeErrorMessage(localErr),
+                });
+            }
+        }
+    }
+    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 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,
+                projectId: workspaceId,
+                limit: requestedLimit ?? undefined,
+                offset: requestedOffset,
+            });
+            const payload = data;
+            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 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)
+                        return item;
+                    return {
+                        ...item,
+                        status: override.status,
+                        updatedAt: item.updatedAt ?? override.updatedAt,
+                    };
+                });
+                const requestedId = id?.trim() ?? "";
+                if (requestedId.length > 0) {
+                    const override = deps.localInitiativeStatusOverrides.get(requestedId) ?? null;
+                    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)}`,
+                            status: override.status,
+                            updatedAt: override.updatedAt,
+                            sessionCount: 0,
+                            activeAgents: 0,
+                        });
+                    }
+                }
+                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({
+                            id: initiativeId,
+                            title: `Initiative ${initiativeId.slice(0, 8)}`,
+                            status: override.status,
+                            updatedAt: override.updatedAt,
+                            sessionCount: 0,
+                            activeAgents: 0,
+                        });
+                    }
+                }
+                const total = initiatives.length;
+                const page = initiatives.slice(offset, offset + limit);
+                deps.sendJson(res, 200, {
+                    initiatives: page,
+                    total,
+                    pagination: {
+                        limit,
+                        offset,
+                        has_more: offset + page.length < total,
+                    },
+                    localFallback: true,
+                    warning: deps.safeErrorMessage(err),
+                });
+            }
+            catch (localErr) {
+                deps.sendJson(res, 500, {
+                    error: deps.safeErrorMessage(err),
+                    localFallbackError: deps.safeErrorMessage(localErr),
+                });
+            }
+        }
+    }
+    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: decisions.length,
+            });
+        }
+        catch {
+            deps.sendJson(res, 200, {
+                decisions: [],
+                total: 0,
+            });
+        }
+    }
+    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();
+            deps.sendJson(res, 200, data);
+        }
+        catch {
+            deps.sendJson(res, 200, { handoffs: [] });
+        }
+    }
+    router.add("GET", "handoffs", async ({ res }) => renderHandoffs(res), "Get handoffs");
+    router.add("HEAD", "handoffs", async ({ res }) => renderHandoffs(res), "Get handoffs (HEAD)");
+}

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

@@ -0,0 +1,136 @@
+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>>;
+type AgentContextState = {
+    agents: Record<string, AgentLaunchContext>;
+    runs?: Record<string, RunLaunchContext>;
+};
+type SnapshotPersistState = {
+    lastFingerprint: string;
+    lastPersistAt: number;
+};
+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;
+    safeErrorMessage: (err: unknown) => string;
+    readAgentContexts: () => AgentContextState;
+    getScopedAgentIds: (contexts: Record<string, AgentLaunchContext>) => Set<string>;
+    readDiagnosticsOutboxStatus: () => Promise<Record<string, unknown> | null>;
+    readOutboxSummary: () => Promise<OutboxSummary>;
+    readOutboxItems: () => Promise<LiveActivityItem[]>;
+    loadLocalOpenClawSnapshot: (limit: number) => Promise<LocalSnapshot>;
+    toLocalSessionTree: (snapshot: LocalSnapshot, limit?: number) => SessionTreeResponse;
+    toLocalLiveActivity: (snapshot: LocalSnapshot, limit?: number) => Promise<{
+        activities: LiveActivityItem[];
+        total: number;
+    }>;
+    toLocalLiveAgents: (snapshot: LocalSnapshot) => {
+        agents: Array<{
+            initiativeId: string | null;
+            status: string;
+        } & Record<string, unknown>>;
+    };
+    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[];
+    }>;
+    getHandoffs: () => Promise<{
+        handoffs: HandoffSummary[];
+    }>;
+    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;
+    };
+    applyAgentContextsToSessionTree: (input: SessionTreeResponse, contexts: {
+        agents: Record<string, AgentLaunchContext>;
+        runs: Record<string, RunLaunchContext>;
+    }) => SessionTreeResponse;
+    applyAgentContextsToActivity: (input: LiveActivityItem[], contexts: {
+        agents: Record<string, AgentLaunchContext>;
+        runs: Record<string, RunLaunchContext>;
+    }) => LiveActivityItem[];
+    mergeSessionTrees: (base: SessionTreeResponse, extra: SessionTreeResponse) => SessionTreeResponse;
+    mergeActivities: (base: LiveActivityItem[], extra: LiveActivityItem[], limit: number) => LiveActivityItem[];
+    listRuntimeInstances: (input: {
+        limit: number;
+    }) => RuntimeInstanceRecord[];
+    injectRuntimeInstancesAsSessions: (input: SessionTreeResponse, instances: RuntimeInstanceRecord[]) => SessionTreeResponse;
+    enrichSessionsWithRuntime: (input: SessionTreeResponse, instances: RuntimeInstanceRecord[]) => SessionTreeResponse;
+    enrichActivityWithRuntime: (input: LiveActivityItem[], instances: RuntimeInstanceRecord[]) => LiveActivityItem[];
+    snapshotActivityFingerprint: (items: LiveActivityItem[]) => string;
+    appendActivityItems: (items: LiveActivityItem[]) => void;
+    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<TReq, TRes>): void;
+export {};