@useorgx/openclaw-plugin 0.4.8 → 0.4.9

package/dist/http/routes/entities.js

@@ -0,0 +1,152 @@
+export function registerEntitiesRoutes(router, deps) {
+    router.add("POST", "entities", async ({ req, res }) => {
+        try {
+            const payload = await deps.parseJsonRequest(req);
+            const type = deps.pickString(payload, ["type"]);
+            const title = deps.pickString(payload, ["title", "name"]);
+            if (!type || !title) {
+                deps.sendJson(res, 400, {
+                    error: "Both 'type' and 'title' are required.",
+                });
+                return;
+            }
+            const data = deps.normalizeEntityMutationPayload({ ...payload, title });
+            delete data.type;
+            let entity = await deps.client.createEntity(type, data);
+            let autoAssignment = null;
+            if (type === "initiative" || type === "workstream") {
+                const entityRecord = entity;
+                autoAssignment = await deps.resolveAutoAssignments({
+                    entityId: String(entityRecord.id ?? ""),
+                    entityType: type,
+                    initiativeId: type === "initiative"
+                        ? String(entityRecord.id ?? "")
+                        : deps.pickString(data, ["initiative_id", "initiativeId"]),
+                    title: deps.pickString(entityRecord, ["title", "name"]) ?? title ?? "Untitled",
+                    summary: deps.pickString(entityRecord, ["summary", "description", "context"]) ?? null,
+                });
+                if (autoAssignment.updated_entity) {
+                    entity = autoAssignment.updated_entity;
+                }
+            }
+            deps.sendJson(res, 201, { ok: true, entity, auto_assignment: autoAssignment });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, {
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }, "Create entity");
+    router.add("PATCH", "entities", async ({ req, res }) => {
+        let payload = {};
+        let type = null;
+        let id = null;
+        let requestedStatus = null;
+        try {
+            payload = await deps.parseJsonRequest(req);
+            type = deps.pickString(payload, ["type"]);
+            id = deps.pickString(payload, ["id"]);
+            requestedStatus = deps.pickString(payload, ["status"]);
+            if (!type || !id) {
+                deps.sendJson(res, 400, {
+                    error: "Both 'type' and 'id' are required for PATCH.",
+                });
+                return;
+            }
+            const updates = { ...payload };
+            delete updates.type;
+            delete updates.id;
+            const normalizedType = type.trim().toLowerCase();
+            const normalizedUpdates = deps.normalizeEntityMutationPayload(updates);
+            const entity = await deps.client.updateEntity(type, id, normalizedUpdates);
+            if (normalizedType === "initiative") {
+                deps.clearLocalInitiativeStatusOverride(id);
+            }
+            deps.sendJson(res, 200, { ok: true, entity });
+        }
+        catch (err) {
+            if (type?.trim().toLowerCase() === "initiative" &&
+                id &&
+                requestedStatus &&
+                deps.isUnauthorizedOrgxError(err)) {
+                deps.setLocalInitiativeStatusOverride(id, requestedStatus);
+                deps.sendJson(res, 200, {
+                    ok: true,
+                    localFallback: true,
+                    warning: deps.safeErrorMessage(err),
+                    entity: {
+                        id,
+                        type,
+                        status: requestedStatus,
+                    },
+                });
+                return;
+            }
+            deps.sendJson(res, 500, {
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }, "Update entity");
+    async function renderEntityList(query, res) {
+        const type = query.get("type");
+        if (!type) {
+            deps.sendJson(res, 400, {
+                error: "Query parameter 'type' is required for GET /entities.",
+            });
+            return;
+        }
+        const status = query.get("status") ?? undefined;
+        const initiativeId = query.get("initiative_id") ?? undefined;
+        const limit = query.get("limit") ? Number(query.get("limit")) : undefined;
+        try {
+            const data = await deps.client.listEntities(type, {
+                status,
+                initiative_id: initiativeId,
+                limit: Number.isFinite(limit) ? limit : undefined,
+            });
+            if (type.trim().toLowerCase() === "initiative") {
+                const payload = data;
+                const rows = Array.isArray(payload.data)
+                    ? payload.data.filter((row) => Boolean(row && typeof row === "object"))
+                    : [];
+                deps.sendJson(res, 200, {
+                    ...payload,
+                    data: deps.applyLocalInitiativeOverrides(rows),
+                });
+                return;
+            }
+            deps.sendJson(res, 200, data);
+        }
+        catch (err) {
+            if (type.trim().toLowerCase() === "initiative" && deps.isUnauthorizedOrgxError(err)) {
+                const snapshotInitiatives = deps
+                    .formatInitiatives(deps.getSnapshot())
+                    .map((item) => ({
+                    id: item.id,
+                    title: item.title,
+                    name: item.title,
+                    summary: null,
+                    status: item.status,
+                    progress_pct: item.progress ?? null,
+                    created_at: null,
+                    updated_at: null,
+                }))
+                    .filter((item) => (initiativeId ? item.id === initiativeId : true));
+                deps.sendJson(res, 200, {
+                    data: deps.applyLocalInitiativeOverrides(snapshotInitiatives),
+                    localFallback: true,
+                    warning: deps.safeErrorMessage(err),
+                });
+                return;
+            }
+            deps.sendJson(res, 500, {
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }
+    router.add("GET", "entities", async ({ query, res }) => renderEntityList(query, res), "List entities");
+    router.add("HEAD", "entities", async ({ query, res }) => renderEntityList(query, res), "List entities (HEAD)");
+    router.add("*", "entities", ({ res }) => {
+        deps.sendJson(res, 405, { error: "Method not allowed" });
+    }, "Reject unsupported methods for entities");
+}

package/dist/http/routes/entity-dynamic.d.ts

@@ -0,0 +1,25 @@
+import type { Router } from "../router.js";
+type JsonRecord = Record<string, unknown>;
+type RegisterEntityDynamicRoutesDeps<TReq, TRes> = {
+    parseJsonRequest: (req: TReq) => Promise<JsonRecord>;
+    pickString: (input: Record<string, unknown>, keys: string[]) => string | null;
+    rawRequest: (method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE", path: string, body?: unknown) => Promise<unknown>;
+    listEntityComments: (entityType: string, entityId: string) => unknown[];
+    mergeEntityComments: (remote: unknown, local: unknown[]) => unknown[];
+    appendEntityComment: (input: {
+        entityType: string;
+        entityId: string;
+        body: string;
+        commentType: string;
+        severity: string;
+        tags: unknown;
+    }) => unknown;
+    updateEntity: (type: string, id: string, updates: Record<string, unknown>) => Promise<unknown>;
+    setLocalInitiativeStatusOverride: (initiativeId: string, status: string) => void;
+    clearLocalInitiativeStatusOverride: (initiativeId: string) => void;
+    isUnauthorizedOrgxError: (err: unknown) => boolean;
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+};
+export declare function registerEntityDynamicRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterEntityDynamicRoutesDeps<TReq, TRes>): void;
+export {};

package/dist/http/routes/entity-dynamic.js

@@ -0,0 +1,191 @@
+export function registerEntityDynamicRoutes(router, deps) {
+    router.add("*", "entities/*", async ({ req, res, path }) => {
+        const method = (req.method ?? "GET").toUpperCase();
+        const entityCommentsMatch = path.match(/^entities\/([^/]+)\/([^/]+)\/comments$/);
+        if (entityCommentsMatch) {
+            if (method !== "GET" && method !== "POST") {
+                deps.sendJson(res, 405, { error: "Method not allowed" });
+                return;
+            }
+            try {
+                const entityType = decodeURIComponent(entityCommentsMatch[1]);
+                const entityId = decodeURIComponent(entityCommentsMatch[2]);
+                if (!entityType || !entityId) {
+                    deps.sendJson(res, 400, {
+                        ok: false,
+                        error: "entity type and id are required",
+                    });
+                    return;
+                }
+                const commentsPath = `/api/entities/${encodeURIComponent(entityType)}/${encodeURIComponent(entityId)}/comments`;
+                if (method === "GET") {
+                    const local = deps.listEntityComments(entityType, entityId);
+                    try {
+                        const data = (await deps.rawRequest("GET", commentsPath));
+                        const comments = deps.mergeEntityComments(data?.comments, local);
+                        if (data && typeof data === "object") {
+                            deps.sendJson(res, 200, { ...data, comments });
+                        }
+                        else {
+                            deps.sendJson(res, 200, { status: "success", comments, nextCursor: null });
+                        }
+                    }
+                    catch (err) {
+                        deps.sendJson(res, 200, {
+                            status: "success",
+                            comments: local,
+                            nextCursor: null,
+                            localFallback: true,
+                            warning: deps.safeErrorMessage(err),
+                        });
+                    }
+                    return;
+                }
+                const payload = await deps.parseJsonRequest(req);
+                const body = deps.pickString(payload, ["body", "comment", "text", "message"]) ?? "";
+                if (!body.trim()) {
+                    deps.sendJson(res, 400, { ok: false, error: "comment body is required" });
+                    return;
+                }
+                const commentType = deps.pickString(payload, ["comment_type", "commentType", "type"]) ?? "note";
+                const severity = deps.pickString(payload, ["severity", "level"]) ?? "info";
+                const tags = payload.tags;
+                const normalizedPayload = {
+                    body,
+                    comment_type: commentType,
+                    severity,
+                    tags,
+                    parent_comment_id: null,
+                };
+                try {
+                    const data = await deps.rawRequest("POST", commentsPath, normalizedPayload);
+                    deps.sendJson(res, 200, data);
+                }
+                catch (err) {
+                    const warning = deps.safeErrorMessage(err);
+                    try {
+                        const comment = deps.appendEntityComment({
+                            entityType,
+                            entityId,
+                            body,
+                            commentType,
+                            severity,
+                            tags,
+                        });
+                        deps.sendJson(res, 200, {
+                            status: "success",
+                            comment,
+                            localFallback: true,
+                            warning,
+                        });
+                    }
+                    catch (localErr) {
+                        deps.sendJson(res, 500, {
+                            ok: false,
+                            error: warning || "Unable to save comment",
+                            localError: deps.safeErrorMessage(localErr),
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                deps.sendJson(res, 500, { ok: false, error: deps.safeErrorMessage(err) });
+            }
+            return;
+        }
+        const entityActionMatch = path.match(/^entities\/([^/]+)\/([^/]+)\/([^/]+)$/);
+        if (entityActionMatch) {
+            if (method !== "POST") {
+                deps.sendJson(res, 405, { error: "Method not allowed" });
+                return;
+            }
+            try {
+                const entityType = decodeURIComponent(entityActionMatch[1]);
+                const entityId = decodeURIComponent(entityActionMatch[2]);
+                const entityAction = decodeURIComponent(entityActionMatch[3]);
+                const payload = await deps.parseJsonRequest(req);
+                const normalizedEntityType = entityType.trim().toLowerCase();
+                if (entityAction === "delete") {
+                    const deleteStatus = normalizedEntityType === "initiative" ? "archived" : "deleted";
+                    try {
+                        const entity = await deps.updateEntity(entityType, entityId, {
+                            status: deleteStatus,
+                        });
+                        if (normalizedEntityType === "initiative") {
+                            deps.clearLocalInitiativeStatusOverride(entityId);
+                        }
+                        deps.sendJson(res, 200, { ok: true, entity, deletedAsStatus: deleteStatus });
+                    }
+                    catch (err) {
+                        if (normalizedEntityType === "initiative" &&
+                            deps.isUnauthorizedOrgxError(err)) {
+                            deps.setLocalInitiativeStatusOverride(entityId, deleteStatus);
+                            deps.sendJson(res, 200, {
+                                ok: true,
+                                localFallback: true,
+                                warning: deps.safeErrorMessage(err),
+                                entity: {
+                                    id: entityId,
+                                    type: entityType,
+                                    status: deleteStatus,
+                                },
+                                deletedAsStatus: deleteStatus,
+                            });
+                            return;
+                        }
+                        throw err;
+                    }
+                    return;
+                }
+                const statusMap = {
+                    start: "in_progress",
+                    complete: "done",
+                    block: "blocked",
+                    unblock: "in_progress",
+                    pause: "paused",
+                    resume: "active",
+                };
+                const newStatus = statusMap[entityAction];
+                if (!newStatus) {
+                    deps.sendJson(res, 400, {
+                        error: `Unknown entity action: ${entityAction}`,
+                    });
+                    return;
+                }
+                try {
+                    const entity = await deps.updateEntity(entityType, entityId, {
+                        status: newStatus,
+                        ...(payload.force ? { force: true } : {}),
+                    });
+                    if (normalizedEntityType === "initiative") {
+                        deps.clearLocalInitiativeStatusOverride(entityId);
+                    }
+                    deps.sendJson(res, 200, { ok: true, entity });
+                }
+                catch (err) {
+                    if (normalizedEntityType === "initiative" &&
+                        deps.isUnauthorizedOrgxError(err)) {
+                        deps.setLocalInitiativeStatusOverride(entityId, newStatus);
+                        deps.sendJson(res, 200, {
+                            ok: true,
+                            localFallback: true,
+                            warning: deps.safeErrorMessage(err),
+                            entity: {
+                                id: entityId,
+                                type: entityType,
+                                status: newStatus,
+                            },
+                        });
+                        return;
+                    }
+                    throw err;
+                }
+            }
+            catch (err) {
+                deps.sendJson(res, 500, { error: deps.safeErrorMessage(err) });
+            }
+            return;
+        }
+        deps.sendJson(res, 404, { error: "Unknown API endpoint" });
+    }, "Dynamic entity comments/actions");
+}

package/dist/http/routes/health.d.ts

@@ -0,0 +1,22 @@
+import type { Router } from "../router.js";
+type HealthDiagnostics = {
+    getHealth?: (input: {
+        probeRemote: boolean;
+    }) => Promise<unknown>;
+};
+type HealthRouteDeps<TRes> = {
+    diagnostics?: HealthDiagnostics;
+    readOutboxSummary: () => Promise<{
+        pendingTotal: number;
+        pendingByQueue: Record<string, number>;
+        oldestEventAt: string | null;
+        newestEventAt: string | null;
+    }>;
+    parseBooleanQuery: (value: string | null) => boolean;
+    baseUrl: string;
+    hasApiKey: boolean;
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+};
+export declare function registerHealthRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: HealthRouteDeps<TRes>): void;
+export {};

package/dist/http/routes/health.js

@@ -0,0 +1,49 @@
+export function registerHealthRoutes(router, deps) {
+    async function handleHealth(query, res) {
+        const probeRemote = deps.parseBooleanQuery(query.get("probe") ?? query.get("probe_remote"));
+        try {
+            if (deps.diagnostics?.getHealth) {
+                const health = await deps.diagnostics.getHealth({ probeRemote });
+                deps.sendJson(res, 200, health);
+                return;
+            }
+            const outbox = await deps.readOutboxSummary();
+            deps.sendJson(res, 200, {
+                ok: true,
+                status: "ok",
+                generatedAt: new Date().toISOString(),
+                checks: [],
+                plugin: {
+                    baseUrl: deps.baseUrl,
+                },
+                auth: {
+                    hasApiKey: deps.hasApiKey,
+                },
+                outbox: {
+                    pendingTotal: outbox.pendingTotal,
+                    pendingByQueue: outbox.pendingByQueue,
+                    oldestEventAt: outbox.oldestEventAt,
+                    newestEventAt: outbox.newestEventAt,
+                    replayStatus: "idle",
+                    lastReplayAttemptAt: null,
+                    lastReplaySuccessAt: null,
+                    lastReplayFailureAt: null,
+                    lastReplayError: null,
+                },
+                remote: {
+                    enabled: false,
+                    reachable: null,
+                    latencyMs: null,
+                    error: null,
+                },
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, {
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }
+    router.add("GET", "health", async ({ query, res }) => handleHealth(query, res), "Health summary");
+    router.add("HEAD", "health", async ({ query, res }) => handleHealth(query, res), "Health summary (HEAD)");
+}

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

@@ -0,0 +1,110 @@
+import type { LiveActivityItem, SessionTreeResponse } from "../../types.js";
+import type { RuntimeInstanceRecord } from "../../runtime-instance-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 AgentContextBundle = {
+    agents: Record<string, AgentLaunchContext>;
+    runs?: Record<string, RunLaunchContext>;
+};
+type LocalLiveActivity = {
+    activities: LiveActivityItem[];
+    total: number;
+};
+type LiveActivityPage = {
+    activities: LiveActivityItem[];
+    cursor?: string | null;
+    nextCursor?: string | null;
+    prevCursor?: string | null;
+    hasMore?: boolean;
+};
+type LiveSessionsResponse = SessionTreeResponse;
+type LiveActivityResponse = {
+    activities: LiveActivityItem[];
+    total?: number;
+} & Record<string, unknown>;
+type RouteReqLike = {
+    on?: (event: string, listener: () => void) => void;
+};
+type RouteResLike = {
+    write?: (chunk: string | Buffer) => boolean | void;
+    writeHead: (statusCode: number, headers?: Record<string, string>) => unknown;
+    end: (chunk?: string | Buffer) => void;
+    writableEnded?: boolean;
+    on?: (event: string, listener: () => void) => void;
+    once?: (event: string, listener: () => void) => void;
+};
+type RegisterLiveLegacyRoutesDeps<TRes extends RouteResLike> = {
+    getLiveSessions: (input: {
+        initiative: string | null;
+        limit: number | undefined;
+    }) => Promise<LiveSessionsResponse>;
+    getLiveActivity: (input: {
+        run: string | null;
+        since: string | null;
+        limit: number | undefined;
+    }) => Promise<LiveActivityResponse>;
+    listRuntimeInstances: (input: {
+        limit: number;
+    }) => RuntimeInstanceRecord[];
+    injectRuntimeInstancesAsSessions: (input: SessionTreeResponse, instances: RuntimeInstanceRecord[]) => SessionTreeResponse;
+    enrichSessionsWithRuntime: (input: SessionTreeResponse, instances: RuntimeInstanceRecord[]) => SessionTreeResponse;
+    loadLocalOpenClawSnapshot: (limit: number) => Promise<LocalSnapshot>;
+    toLocalSessionTree: (snapshot: LocalSnapshot, limit?: number) => SessionTreeResponse;
+    readAgentContexts: () => AgentContextBundle;
+    applyAgentContextsToSessionTree: (input: SessionTreeResponse, contexts: {
+        agents: Record<string, AgentLaunchContext>;
+        runs: Record<string, RunLaunchContext>;
+    }) => SessionTreeResponse;
+    listActivityPage: (input: {
+        limit: number;
+        runId: string | null;
+        since: string | null;
+        until: string | null;
+        cursor: string | null;
+    }) => LiveActivityPage;
+    applyAgentContextsToActivity: (input: LiveActivityItem[], contexts: {
+        agents: Record<string, AgentLaunchContext>;
+        runs: Record<string, RunLaunchContext>;
+    }) => LiveActivityItem[];
+    appendActivityItems: (items: LiveActivityItem[]) => void;
+    activityWarmByKey: Map<string, number>;
+    activityWarmThrottleMs: number;
+    outboxReadAllItems: () => Promise<LiveActivityItem[]>;
+    toLocalLiveActivity: (snapshot: LocalSnapshot, limit?: number) => Promise<LocalLiveActivity>;
+    loadLocalTurnDetail: (input: {
+        turnId: string;
+        sessionKey: string | null;
+        runId: string | null;
+    }) => Promise<Record<string, unknown> | null>;
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+    sendHtml: (res: TRes, status: number, html: string) => void;
+    resolveFilesystemOpenPath: (rawPath: string) => string;
+    escapeHtml: (value: string) => string;
+    statSync: (path: string) => {
+        isDirectory: () => boolean;
+        isFile: () => boolean;
+        size: number;
+    };
+    readdirSync: (path: string) => string[];
+    existsSync: (path: string) => boolean;
+    resolvePath: (...segments: string[]) => string;
+    readFilePreview: (path: string, totalBytes: number) => {
+        previewBuffer: Buffer;
+        truncated: boolean;
+    };
+    filePreviewMaxBytes: number;
+    filePreviewMaxDirEntries: number;
+    securityHeaders: Record<string, string>;
+    corsHeaders: Record<string, string>;
+    config: {
+        baseUrl: string;
+        apiKey: string;
+        userId: string;
+    };
+    isUserScopedApiKey: (apiKey: string) => boolean;
+    streamIdleTimeoutMs: number;
+};
+export declare function registerLiveLegacyRoutes<TReq extends RouteReqLike, TRes extends RouteResLike>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterLiveLegacyRoutesDeps<TRes>): void;
+export {};