@useorgx/openclaw-plugin 0.4.8 → 0.7.0

package/dist/http/routes/entities.js

@@ -0,0 +1,440 @@
+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 {
+            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);
+            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);
+            }
+            // 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" &&
+                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, headerScope) {
+        const type = query.get("type");
+        if (!type) {
+            deps.sendJson(res, 400, {
+                error: "Query parameter 'type' is required for GET /entities.",
+            });
+            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 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;
+            }
+            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))
+                    .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,
+                    warning: deps.safeErrorMessage(err),
+                });
+                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, 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/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 {};