@useorgx/openclaw-plugin 0.4.9 → 0.7.0

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

@@ -12,9 +12,16 @@ type EntityClientLike = {
     createEntity: (type: string, data: Record<string, unknown>) => Promise<Entity>;
     updateEntity: (type: string, id: string, updates: Record<string, unknown>) => Promise<Entity>;
     listEntities: (type: string, input: {
+        id?: string;
+        ids?: string[] | string;
+        search?: string;
         status?: string;
         initiative_id?: string;
+        project_id?: string;
+        workspace_id?: string;
+        command_center_id?: string;
         limit?: number;
+        offset?: number;
     }) => Promise<unknown>;
 };
 type RegisterEntitiesRoutesDeps<TReq, TRes> = {
@@ -40,6 +47,15 @@ type RegisterEntitiesRoutesDeps<TReq, TRes> = {
         progress?: number | null;
     }>;
     getSnapshot: () => OrgSnapshot | null;
+    scheduleWorkstreamReassignment?: (input: {
+        initiativeId: string;
+        workstreamId: string;
+        status: string | null;
+        event: string;
+    }) => Promise<{
+        requestId?: string | null;
+        dueAt?: string | null;
+    } | null>;
     sendJson: (res: TRes, status: number, payload: unknown) => void;
     safeErrorMessage: (err: unknown) => string;
 };

package/dist/http/routes/entities.js

@@ -1,3 +1,44 @@
+import { resolveWorkspaceScope, workspaceScopeFromHeaders, } from "../helpers/workspace-scope.js";
+import { cascadeProgressFromChildren, deriveLifecycleState, } from "../../reporting/rollups.js";
+const WORKSTREAM_REASSIGNMENT_FIELDS = [
+    "domain",
+    "role",
+    "assigned_agents",
+    "assignedAgents",
+    "assigned_agent_ids",
+    "assignedAgentIds",
+    "assigned_agent_names",
+    "assignedAgentNames",
+];
+function hasOwn(input, key) {
+    return Object.prototype.hasOwnProperty.call(input, key);
+}
+function hasMeaningfulReassignmentValue(value) {
+    if (typeof value === "string")
+        return value.trim().length > 0;
+    if (Array.isArray(value))
+        return value.length > 0;
+    return value !== null && value !== undefined;
+}
+function includesWorkstreamReassignmentMutation(payload) {
+    return WORKSTREAM_REASSIGNMENT_FIELDS.some((field) => hasOwn(payload, field) && hasMeaningfulReassignmentValue(payload[field]));
+}
+function isActiveOrReadyStatus(status) {
+    const normalized = (status ?? "").trim().toLowerCase();
+    if (!normalized)
+        return false;
+    return (normalized === "active" ||
+        normalized === "ready" ||
+        normalized === "in_progress" ||
+        normalized === "running" ||
+        normalized === "queued" ||
+        normalized === "pending");
+}
+function toObjectArray(input) {
+    if (!Array.isArray(input))
+        return [];
+    return input.filter((item) => Boolean(item) && typeof item === "object");
+}
 export function registerEntitiesRoutes(router, deps) {
     router.add("POST", "entities", async ({ req, res }) => {
         try {
@@ -59,10 +100,164 @@ export function registerEntitiesRoutes(router, deps) {
             const normalizedType = type.trim().toLowerCase();
             const normalizedUpdates = deps.normalizeEntityMutationPayload(updates);
             const entity = await deps.client.updateEntity(type, id, normalizedUpdates);
+            let reassignment = null;
+            let initiativeReassignment = null;
+            if (normalizedType === "workstream" &&
+                deps.scheduleWorkstreamReassignment &&
+                includesWorkstreamReassignmentMutation(normalizedUpdates)) {
+                const entityRecord = entity && typeof entity === "object"
+                    ? entity
+                    : {};
+                const initiativeId = deps.pickString(entityRecord, ["initiative_id", "initiativeId"]) ??
+                    deps.pickString(normalizedUpdates, ["initiative_id", "initiativeId"]) ??
+                    null;
+                const workstreamStatus = deps.pickString(entityRecord, ["status"]) ??
+                    deps.pickString(normalizedUpdates, ["status"]) ??
+                    null;
+                if (!initiativeId) {
+                    reassignment = { scheduled: false, reason: "missing_initiative" };
+                }
+                else if (!isActiveOrReadyStatus(workstreamStatus)) {
+                    reassignment = { scheduled: false, reason: "workstream_not_active_or_ready" };
+                }
+                else {
+                    try {
+                        const scheduled = await deps.scheduleWorkstreamReassignment({
+                            initiativeId,
+                            workstreamId: id,
+                            status: workstreamStatus,
+                            event: "workstream_reassigned",
+                        });
+                        reassignment = {
+                            scheduled: true,
+                            requestId: scheduled && typeof scheduled === "object"
+                                ? (deps.pickString(scheduled, ["requestId"]) ?? null)
+                                : null,
+                            dueAt: scheduled && typeof scheduled === "object"
+                                ? (deps.pickString(scheduled, ["dueAt"]) ?? null)
+                                : null,
+                        };
+                    }
+                    catch (reassignmentErr) {
+                        reassignment = {
+                            scheduled: false,
+                            reason: `schedule_failed:${deps.safeErrorMessage(reassignmentErr)}`,
+                        };
+                    }
+                }
+            }
+            if (normalizedType === "initiative" &&
+                deps.scheduleWorkstreamReassignment &&
+                includesWorkstreamReassignmentMutation(normalizedUpdates)) {
+                const workstreams = await deps.client.listEntities("workstream", {
+                    initiative_id: id,
+                    limit: 200,
+                });
+                const workstreamRows = toObjectArray(workstreams && typeof workstreams === "object"
+                    ? workstreams.data
+                    : []);
+                const failures = [];
+                let requested = 0;
+                let scheduled = 0;
+                let skipped = 0;
+                for (const row of workstreamRows) {
+                    const workstreamId = deps.pickString(row, ["id"]);
+                    if (!workstreamId) {
+                        skipped += 1;
+                        continue;
+                    }
+                    const workstreamStatus = deps.pickString(row, ["status"]);
+                    requested += 1;
+                    if (!isActiveOrReadyStatus(workstreamStatus)) {
+                        skipped += 1;
+                        continue;
+                    }
+                    try {
+                        await deps.scheduleWorkstreamReassignment({
+                            initiativeId: id,
+                            workstreamId,
+                            status: workstreamStatus,
+                            event: "initiative_reassigned",
+                        });
+                        scheduled += 1;
+                    }
+                    catch (reassignmentErr) {
+                        failures.push(`${workstreamId}:${deps.safeErrorMessage(reassignmentErr)}`);
+                    }
+                }
+                initiativeReassignment = {
+                    triggered: true,
+                    requested,
+                    scheduled,
+                    skipped,
+                    failures,
+                };
+            }
             if (normalizedType === "initiative") {
                 deps.clearLocalInitiativeStatusOverride(id);
             }
-            deps.sendJson(res, 200, { ok: true, entity });
+            // Post-status-transition hook: when a task status changes to
+            // completed/done, recompute cascaded progress for parent entities.
+            let cascadedProgress = null;
+            if (normalizedType === "task" && requestedStatus) {
+                const normalizedRequestedStatus = requestedStatus.trim().toLowerCase();
+                const isTerminal = normalizedRequestedStatus === "done" ||
+                    normalizedRequestedStatus === "completed" ||
+                    normalizedRequestedStatus === "cancelled" ||
+                    normalizedRequestedStatus === "archived";
+                if (isTerminal) {
+                    // Look up sibling tasks for the parent workstream/milestone/initiative
+                    const entityRecord = entity && typeof entity === "object"
+                        ? entity
+                        : {};
+                    const parentWorkstreamId = deps.pickString(entityRecord, ["workstream_id", "workstreamId"]) ??
+                        deps.pickString(normalizedUpdates, ["workstream_id", "workstreamId"]);
+                    const parentInitiativeId = deps.pickString(entityRecord, ["initiative_id", "initiativeId"]) ??
+                        deps.pickString(normalizedUpdates, ["initiative_id", "initiativeId"]);
+                    // Fetch sibling tasks to compute cascaded progress
+                    const parentScope = parentWorkstreamId
+                        ? { initiative_id: parentInitiativeId ?? undefined }
+                        : parentInitiativeId
+                            ? { initiative_id: parentInitiativeId }
+                            : null;
+                    if (parentScope) {
+                        try {
+                            const siblingResult = await deps.client.listEntities("task", {
+                                ...parentScope,
+                                limit: 500,
+                            });
+                            const siblingRows = toObjectArray(siblingResult && typeof siblingResult === "object"
+                                ? siblingResult.data
+                                : []);
+                            const siblingStatuses = siblingRows
+                                .filter((row) => {
+                                if (!parentWorkstreamId)
+                                    return true;
+                                const rowWsId = deps.pickString(row, ["workstream_id", "workstreamId"]);
+                                return rowWsId === parentWorkstreamId;
+                            })
+                                .map((row) => deps.pickString(row, ["status"]) ?? "unknown");
+                            const parentProgress = cascadeProgressFromChildren(siblingStatuses);
+                            const parentLifecycleState = deriveLifecycleState(parentWorkstreamId ? "active" : (parentInitiativeId ? "active" : "active"), siblingStatuses);
+                            cascadedProgress = {
+                                parentProgress,
+                                parentLifecycleState,
+                                taskStatuses: siblingStatuses,
+                            };
+                        }
+                        catch {
+                            // Non-critical: cascade progress is best-effort
+                        }
+                    }
+                }
+            }
+            deps.sendJson(res, 200, {
+                ok: true,
+                entity,
+                reassignment,
+                initiative_reassignment: initiativeReassignment,
+                ...(cascadedProgress ? { cascaded_progress: cascadedProgress } : {}),
+            });
         }
         catch (err) {
             if (type?.trim().toLowerCase() === "initiative" &&
@@ -87,7 +282,7 @@ export function registerEntitiesRoutes(router, deps) {
             });
         }
     }, "Update entity");
-    async function renderEntityList(query, res) {
+    async function renderEntityList(query, res, headerScope) {
         const type = query.get("type");
         if (!type) {
             deps.sendJson(res, 400, {
@@ -95,23 +290,92 @@ export function registerEntitiesRoutes(router, deps) {
             });
             return;
         }
+        const workspaceScope = resolveWorkspaceScope(query, headerScope, {
+            allowProjectScope: false,
+        });
+        if (workspaceScope.error) {
+            deps.sendJson(res, 400, { error: workspaceScope.error });
+            return;
+        }
         const status = query.get("status") ?? undefined;
+        const id = query.get("id") ?? undefined;
+        const ids = query
+            .get("ids")
+            ?.split(",")
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0);
+        const search = query.get("search")?.trim() || undefined;
         const initiativeId = query.get("initiative_id") ?? undefined;
+        const workspaceId = workspaceScope.workspaceId ?? undefined;
         const limit = query.get("limit") ? Number(query.get("limit")) : undefined;
+        const offset = query.get("offset") ? Number(query.get("offset")) : undefined;
         try {
             const data = await deps.client.listEntities(type, {
+                id,
+                ids,
+                search,
                 status,
                 initiative_id: initiativeId,
+                workspace_id: workspaceId,
+                command_center_id: workspaceId,
                 limit: Number.isFinite(limit) ? limit : undefined,
+                offset: Number.isFinite(offset) ? offset : undefined,
             });
             if (type.trim().toLowerCase() === "initiative") {
                 const payload = data;
-                const rows = Array.isArray(payload.data)
+                const rawRows = Array.isArray(payload.data)
                     ? payload.data.filter((row) => Boolean(row && typeof row === "object"))
                     : [];
+                const filteredById = rawRows.filter((row) => {
+                    const rowId = deps.pickString(row, ["id"])?.trim();
+                    if (!rowId)
+                        return false;
+                    if (id && rowId !== id.trim())
+                        return false;
+                    if (ids && ids.length > 0 && !ids.includes(rowId))
+                        return false;
+                    return true;
+                });
+                const searchTokens = typeof search === "string" && search.length > 0
+                    ? Array.from(new Set(search
+                        .toLowerCase()
+                        .split(/\s+/)
+                        .map((token) => token.trim())
+                        .filter((token) => token.length > 0)))
+                    : [];
+                const searchedRows = searchTokens.length > 0
+                    ? filteredById.filter((row) => {
+                        const haystack = [
+                            deps.pickString(row, ["title", "name"]) ?? "",
+                            deps.pickString(row, ["summary", "description"]) ?? "",
+                            deps.pickString(row, ["status"]) ?? "",
+                        ]
+                            .join(" ")
+                            .toLowerCase();
+                        return searchTokens.every((token) => haystack.includes(token));
+                    })
+                    : filteredById;
+                const workspaceScopeId = (workspaceId ?? "").trim();
+                const rows = workspaceScopeId.length > 0
+                    ? searchedRows.filter((row) => {
+                        const rowScope = deps.pickString(row, [
+                            "workspace_id",
+                            "workspaceId",
+                            "command_center_id",
+                            "commandCenterId",
+                        ]) ?? "";
+                        return rowScope.trim() === workspaceScopeId;
+                    })
+                    : searchedRows;
                 deps.sendJson(res, 200, {
                     ...payload,
                     data: deps.applyLocalInitiativeOverrides(rows),
+                    pagination: payload.pagination && typeof payload.pagination === "object"
+                        ? {
+                            ...payload.pagination,
+                            total: rows.length,
+                        }
+                        : payload.pagination,
                 });
                 return;
             }
@@ -131,7 +395,22 @@ export function registerEntitiesRoutes(router, deps) {
                     created_at: null,
                     updated_at: null,
                 }))
-                    .filter((item) => (initiativeId ? item.id === initiativeId : true));
+                    .filter((item) => (initiativeId ? item.id === initiativeId : true))
+                    .filter((item) => (id ? item.id === id : true))
+                    .filter((item) => ids && ids.length > 0 ? ids.includes(item.id) : true)
+                    .filter((item) => {
+                    if (!search)
+                        return true;
+                    const searchTokens = search
+                        .toLowerCase()
+                        .split(/\s+/)
+                        .map((token) => token.trim())
+                        .filter((token) => token.length > 0);
+                    if (searchTokens.length === 0)
+                        return true;
+                    const haystack = `${item.title} ${item.summary ?? ""} ${item.status ?? ""}`.toLowerCase();
+                    return searchTokens.every((token) => haystack.includes(token));
+                });
                 deps.sendJson(res, 200, {
                     data: deps.applyLocalInitiativeOverrides(snapshotInitiatives),
                     localFallback: true,
@@ -139,13 +418,22 @@ export function registerEntitiesRoutes(router, deps) {
                 });
                 return;
             }
+            if (type.trim().toLowerCase() === "command_center") {
+                deps.sendJson(res, 200, {
+                    data: [],
+                    pagination: { total: 0, has_more: false },
+                    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("GET", "entities", async ({ query, res, req }) => renderEntityList(query, res, workspaceScopeFromHeaders(req?.headers)), "List entities");
+    router.add("HEAD", "entities", async ({ query, res, req }) => renderEntityList(query, res, workspaceScopeFromHeaders(req?.headers)), "List entities (HEAD)");
     router.add("*", "entities", ({ res }) => {
         deps.sendJson(res, 405, { error: "Method not allowed" });
     }, "Reject unsupported methods for entities");

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

@@ -37,13 +37,18 @@ type RouteResLike = {
 type RegisterLiveLegacyRoutesDeps<TRes extends RouteResLike> = {
     getLiveSessions: (input: {
         initiative: string | null;
+        projectId: string | null;
         limit: number | undefined;
     }) => Promise<LiveSessionsResponse>;
     getLiveActivity: (input: {
         run: string | null;
         since: string | null;
+        projectId: string | null;
         limit: number | undefined;
     }) => Promise<LiveActivityResponse>;
+    listInitiativeIdsForProject: (input: {
+        projectId: string;
+    }) => Promise<string[]>;
     listRuntimeInstances: (input: {
         limit: number;
     }) => RuntimeInstanceRecord[];