@useorgx/openclaw-plugin 0.4.8 → 0.7.0

package/dist/http/routes/decision-actions.js

@@ -0,0 +1,103 @@
+function extractIdsFromPayload(payload) {
+    const raw = payload.ids;
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .filter((id) => typeof id === "string")
+        .map((id) => id.trim())
+        .filter(Boolean);
+}
+async function handleApproveRequest(req, res, deps, routeIds) {
+    const payload = await deps.parseJsonRequest(req);
+    const action = payload.action === "reject" ? "reject" : "approve";
+    const note = typeof payload.note === "string" && payload.note.trim().length > 0
+        ? payload.note.trim()
+        : undefined;
+    const optionIdRaw = typeof payload.option_id === "string"
+        ? payload.option_id
+        : typeof payload.optionId === "string"
+            ? payload.optionId
+            : null;
+    const optionId = typeof optionIdRaw === "string" && optionIdRaw.trim().length > 0
+        ? optionIdRaw.trim()
+        : undefined;
+    const ids = routeIds ?? extractIdsFromPayload(payload);
+    if (ids.length === 0) {
+        deps.sendJson(res, 400, {
+            error: "Decision IDs are required.",
+            expected: {
+                route: "/orgx/api/live/decisions/approve",
+                body: { ids: ["decision-id"], action: "approve|reject", option_id: "optional-option-id" },
+            },
+        });
+        return;
+    }
+    const results = await deps.bulkDecideDecisions(ids, action, {
+        note,
+        optionId,
+    });
+    const resolvedIds = results
+        .map((result, index) => (result.ok === true ? ids[index] ?? null : null))
+        .filter((id) => typeof id === "string" && id.length > 0);
+    const updated = results.filter((result) => result.ok === true).length;
+    const failed = results.length - updated;
+    if (resolvedIds.length > 0 && typeof deps.emitDecisionResolvedActivity === "function") {
+        try {
+            await deps.emitDecisionResolvedActivity(resolvedIds, action, {
+                note,
+                optionId,
+            });
+        }
+        catch {
+            // best effort; decision mutation succeeded so do not fail the response
+        }
+    }
+    deps.sendJson(res, failed > 0 ? 207 : 200, {
+        action,
+        requested: ids.length,
+        updated,
+        failed,
+        results,
+    });
+}
+function decodeDecisionId(encodedDecisionId) {
+    try {
+        const decoded = decodeURIComponent(encodedDecisionId).trim();
+        return decoded.length > 0 ? decoded : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function registerDecisionActionsRoutes(router, deps) {
+    router.add("POST", "live/decisions/approve", async ({ req, res }) => {
+        try {
+            await handleApproveRequest(req, res, deps, null);
+        }
+        catch (err) {
+            deps.sendJson(res, 500, {
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }, "Bulk decision approve/reject");
+    router.add("POST", "live/decisions/*", async ({ req, res, path }) => {
+        const decisionApproveMatch = path.match(/^live\/decisions\/([^/]+)\/approve$/);
+        if (!decisionApproveMatch) {
+            deps.sendJson(res, 404, { error: "Unknown API endpoint" });
+            return;
+        }
+        const decisionId = decodeDecisionId(decisionApproveMatch[1]);
+        if (!decisionId) {
+            deps.sendJson(res, 400, { error: "Invalid decision ID." });
+            return;
+        }
+        try {
+            await handleApproveRequest(req, res, deps, [decisionId]);
+        }
+        catch (err) {
+            deps.sendJson(res, 500, {
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }, "Single decision approve/reject");
+}

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

@@ -0,0 +1,19 @@
+import type { Router } from "../router.js";
+type JsonRecord = Record<string, unknown>;
+type DelegationClientLike = {
+    delegationPreflight: (input: {
+        intent: string;
+        acceptanceCriteria?: string[];
+        constraints?: string[];
+        domains?: string[];
+    }) => Promise<unknown>;
+};
+type RegisterDelegationRoutesDeps<TReq, TRes> = {
+    client: DelegationClientLike;
+    parseJsonRequest: (req: TReq) => Promise<JsonRecord>;
+    pickString: (input: JsonRecord, keys: string[]) => string | null;
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+};
+export declare function registerDelegationRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterDelegationRoutesDeps<TReq, TRes>): void;
+export {};

package/dist/http/routes/delegation.js

@@ -0,0 +1,32 @@
+function toStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string")
+        : undefined;
+}
+export function registerDelegationRoutes(router, deps) {
+    router.add("POST", "delegation/preflight", async ({ req, res }) => {
+        try {
+            const payload = await deps.parseJsonRequest(req);
+            const intent = deps.pickString(payload, ["intent"]);
+            if (!intent) {
+                deps.sendJson(res, 400, { error: "intent is required" });
+                return;
+            }
+            const data = await deps.client.delegationPreflight({
+                intent,
+                acceptanceCriteria: toStringArray(payload.acceptanceCriteria),
+                constraints: toStringArray(payload.constraints),
+                domains: toStringArray(payload.domains),
+            });
+            deps.sendJson(res, 200, data);
+        }
+        catch (err) {
+            deps.sendJson(res, 500, {
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }, "Delegation preflight");
+    router.add("*", "delegation/preflight", ({ res }) => {
+        deps.sendJson(res, 405, { error: "Use POST /orgx/api/delegation/preflight" });
+    }, "Reject unsupported methods for delegation/preflight");
+}

package/dist/http/routes/dispatch-gateway-envelope.d.ts

@@ -0,0 +1,25 @@
+export type DispatchGatewayEnvelopeInput = {
+    dispatchId?: string;
+    dispatchMode: string;
+    route: "mission-control.next-up.play" | "mission-control.auto-continue.start";
+    source: "manual_play" | "auto_continue_start";
+    initiativeId: string;
+    workstreamId?: string | null;
+    workstreamIds?: string[] | null;
+    taskIds?: string[] | null;
+};
+export declare function buildDispatchGatewayEnvelope(input: DispatchGatewayEnvelopeInput): {
+    readonly dispatchId: string;
+    readonly dispatchMode: string;
+    readonly executionPath: "orgx_orchestrator_gateway";
+    readonly dispatchGateway: "orchestrator-agent";
+    readonly dispatchLineage: {
+        readonly route: "mission-control.next-up.play" | "mission-control.auto-continue.start";
+        readonly source: "manual_play" | "auto_continue_start";
+        readonly dispatchedAt: string;
+        readonly initiativeId: string;
+        readonly workstreamId: string | null;
+        readonly workstreamIds: string[];
+        readonly taskIds: string[];
+    };
+};

package/dist/http/routes/dispatch-gateway-envelope.js

@@ -0,0 +1,26 @@
+import { randomUUID } from "node:crypto";
+function uniqueStringIds(values) {
+    return Array.from(new Set(values
+        .map((value) => (typeof value === "string" ? value.trim() : ""))
+        .filter((value) => value.length > 0)));
+}
+export function buildDispatchGatewayEnvelope(input) {
+    return {
+        dispatchId: input.dispatchId ?? randomUUID(),
+        dispatchMode: input.dispatchMode,
+        executionPath: "orgx_orchestrator_gateway",
+        dispatchGateway: "orchestrator-agent",
+        dispatchLineage: {
+            route: input.route,
+            source: input.source,
+            dispatchedAt: new Date().toISOString(),
+            initiativeId: input.initiativeId,
+            workstreamId: input.workstreamId ?? null,
+            workstreamIds: uniqueStringIds([
+                input.workstreamId,
+                ...(input.workstreamIds ?? []),
+            ]),
+            taskIds: uniqueStringIds(input.taskIds ?? []),
+        },
+    };
+}

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

@@ -0,0 +1,63 @@
+import type { Entity, OrgSnapshot } from "../../types.js";
+import type { Router } from "../router.js";
+type JsonRecord = Record<string, unknown>;
+type AutoAssignmentResult = {
+    ok: boolean;
+    assignment_source: "orchestrator" | "fallback" | "manual";
+    assigned_agents: unknown[];
+    warnings: string[];
+    updated_entity?: Entity;
+};
+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> = {
+    client: EntityClientLike;
+    parseJsonRequest: (req: TReq) => Promise<JsonRecord>;
+    pickString: (input: Record<string, unknown>, keys: string[]) => string | null;
+    normalizeEntityMutationPayload: (input: Record<string, unknown>) => Record<string, unknown>;
+    resolveAutoAssignments: (input: {
+        entityId: string;
+        entityType: string;
+        initiativeId: string | null;
+        title: string;
+        summary: string | null;
+    }) => Promise<AutoAssignmentResult>;
+    setLocalInitiativeStatusOverride: (initiativeId: string, status: string) => void;
+    clearLocalInitiativeStatusOverride: (initiativeId: string) => void;
+    isUnauthorizedOrgxError: (err: unknown) => boolean;
+    applyLocalInitiativeOverrides: (rows: Array<Record<string, unknown>>) => Array<Record<string, unknown>>;
+    formatInitiatives: (snapshot: OrgSnapshot | null) => Array<{
+        id: string;
+        title: string;
+        status: string;
+        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;
+};
+export declare function registerEntitiesRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterEntitiesRoutesDeps<TReq, TRes>): void;
+export {};