@useorgx/openclaw-plugin 0.4.9 → 0.7.0

package/dist/http/routes/agent-suite.d.ts

@@ -2,8 +2,11 @@ import type { Router } from "../router.js";
 type JsonRecord = Record<string, unknown>;
 type ReadSkillPackStateFn = typeof import("../../skill-pack-state.js").readSkillPackState;
 type UpdateSkillPackPolicyFn = typeof import("../../skill-pack-state.js").updateSkillPackPolicy;
+type RollbackSkillPackPolicyFn = typeof import("../../skill-pack-state.js").rollbackSkillPackPolicy;
 type ComputeOrgxAgentSuitePlanFn = typeof import("../../agent-suite.js").computeOrgxAgentSuitePlan;
 type ApplyOrgxAgentSuitePlanFn = typeof import("../../agent-suite.js").applyOrgxAgentSuitePlan;
+type ClientRuntimeSettingsResponse = import("../../contracts/types.js").ClientRuntimeSettingsResponse;
+type ClientRuntimeSettingsUpdateRequest = import("../../contracts/types.js").ClientRuntimeSettingsUpdateRequest;
 type OrgxSkillPackOverrides = import("../../agent-suite.js").OrgxSkillPackOverrides;
 type RegisterAgentSuiteRoutesDeps<TReq, TRes> = {
     pluginVersion: string | null | undefined;
@@ -17,6 +20,12 @@ type RegisterAgentSuiteRoutesDeps<TReq, TRes> = {
     applyOrgxAgentSuitePlan: ApplyOrgxAgentSuitePlanFn;
     generateAgentSuiteOperationId: () => string;
     updateSkillPackPolicy: UpdateSkillPackPolicyFn;
+    rollbackSkillPackPolicy: RollbackSkillPackPolicyFn;
+    fetchAgentRuntimeSettings: (input?: {
+        workspaceId?: string | null;
+        projectId?: string | null;
+    }) => Promise<ClientRuntimeSettingsResponse>;
+    updateAgentRuntimeSettings: (payload: ClientRuntimeSettingsUpdateRequest) => Promise<ClientRuntimeSettingsResponse>;
     posthogCapture: (input: {
         event: string;
         distinctId: string;

package/dist/http/routes/agent-suite.js

@@ -21,6 +21,64 @@ function computeUpdateAvailable(state) {
         state.pack?.checksum &&
         state.remote.checksum !== state.pack.checksum);
 }
+function toOptionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function toOptionalUuid(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return UUID_RE.test(trimmed) ? trimmed : undefined;
+}
+function readOptionalBoolean(payload, ...keys) {
+    for (const key of keys) {
+        const value = payload[key];
+        if (typeof value === "boolean") {
+            return value;
+        }
+    }
+    return undefined;
+}
+function normalizeRuntimeSettingsPatch(payload) {
+    const runtime = toRecord(payload.runtime_settings ?? payload.runtimeSettings);
+    const patch = {};
+    const decisionV2Enabled = readOptionalBoolean(runtime, "decision_v2_enabled", "decisionV2Enabled");
+    if (typeof decisionV2Enabled === "boolean") {
+        patch.decision_v2_enabled = decisionV2Enabled;
+    }
+    const decisionDedupeEnabled = readOptionalBoolean(runtime, "decision_dedupe_enabled", "decisionDedupeEnabled");
+    if (typeof decisionDedupeEnabled === "boolean") {
+        patch.decision_dedupe_enabled = decisionDedupeEnabled;
+    }
+    const decisionEvidenceRequiredForBlocking = readOptionalBoolean(runtime, "decision_evidence_required_for_blocking", "decisionEvidenceRequiredForBlocking");
+    if (typeof decisionEvidenceRequiredForBlocking === "boolean") {
+        patch.decision_evidence_required_for_blocking =
+            decisionEvidenceRequiredForBlocking;
+    }
+    const decisionAutoResolveGuardedEnabled = readOptionalBoolean(runtime, "decision_auto_resolve_guarded_enabled", "decisionAutoResolveGuardedEnabled");
+    if (typeof decisionAutoResolveGuardedEnabled === "boolean") {
+        patch.decision_auto_resolve_guarded_enabled =
+            decisionAutoResolveGuardedEnabled;
+    }
+    const customRunInstructions = toOptionalString(runtime.custom_run_instructions ?? runtime.customRunInstructions);
+    if (typeof customRunInstructions === "string") {
+        patch.custom_run_instructions = customRunInstructions.slice(0, 4000);
+    }
+    return patch;
+}
+function buildRuntimeSettingsFallbackEnvelope(workspaceId) {
+    const normalizedWorkspaceId = typeof workspaceId === "string" && workspaceId.trim().length > 0
+        ? workspaceId.trim()
+        : null;
+    return {
+        ok: true,
+        workspace_id: normalizedWorkspaceId,
+        command_center_id: normalizedWorkspaceId,
+        project_id: normalizedWorkspaceId,
+        agents: [],
+    };
+}
 export function registerAgentSuiteRoutes(router, deps) {
     async function renderStatus(res) {
         try {
@@ -54,6 +112,102 @@ export function registerAgentSuiteRoutes(router, deps) {
     }
     router.add("GET", "agent-suite/status", async ({ res }) => renderStatus(res), "Agent suite installation status");
     router.add("HEAD", "agent-suite/status", async ({ res }) => renderStatus(res), "Agent suite installation status (HEAD)");
+    router.add("GET", "agent-suite/runtime-settings", async ({ req, res }) => {
+        const requestUrl = new URL(String(req.url ?? "/"), "http://localhost");
+        const workspaceId = toOptionalUuid(requestUrl.searchParams.get("workspace_id") ??
+            requestUrl.searchParams.get("workspaceId") ??
+            requestUrl.searchParams.get("command_center_id") ??
+            requestUrl.searchParams.get("commandCenterId") ??
+            requestUrl.searchParams.get("project_id"));
+        try {
+            const response = await deps.fetchAgentRuntimeSettings({
+                workspaceId: workspaceId ?? null,
+            });
+            if (!response?.ok) {
+                deps.sendJson(res, 200, {
+                    ok: true,
+                    data: {
+                        ...buildRuntimeSettingsFallbackEnvelope(workspaceId ?? null),
+                        warning: response?.error ?? "Failed to load agent runtime settings",
+                    },
+                });
+                return;
+            }
+            deps.sendJson(res, 200, {
+                ok: true,
+                data: response,
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 200, {
+                ok: true,
+                data: {
+                    ...buildRuntimeSettingsFallbackEnvelope(workspaceId ?? null),
+                    warning: deps.safeErrorMessage(err),
+                },
+            });
+        }
+    }, "List agent runtime settings");
+    router.add("PATCH", "agent-suite/runtime-settings", async ({ req, res }) => {
+        try {
+            const payload = toRecord(await deps.parseJsonRequest(req));
+            const agentId = toOptionalString(payload.agent_id ?? payload.agentId)?.trim();
+            if (!agentId) {
+                deps.sendJson(res, 400, {
+                    ok: false,
+                    error: "agent_id is required",
+                });
+                return;
+            }
+            const runtimeSettingsPatch = normalizeRuntimeSettingsPatch(payload);
+            if (Object.keys(runtimeSettingsPatch).length === 0) {
+                deps.sendJson(res, 400, {
+                    ok: false,
+                    error: "runtime_settings must include at least one mutable field",
+                });
+                return;
+            }
+            const workspaceId = toOptionalUuid(payload.workspace_id ??
+                payload.workspaceId ??
+                payload.command_center_id ??
+                payload.commandCenterId ??
+                payload.project_id ??
+                payload.projectId);
+            const response = await deps.updateAgentRuntimeSettings({
+                agent_id: agentId,
+                ...(workspaceId
+                    ? {
+                        workspace_id: workspaceId,
+                        command_center_id: workspaceId,
+                    }
+                    : {}),
+                runtime_settings: runtimeSettingsPatch,
+            });
+            if (!response?.ok) {
+                deps.sendJson(res, 502, {
+                    ok: false,
+                    error: response?.error ?? "Failed to update agent runtime settings",
+                });
+                return;
+            }
+            deps.sendJson(res, 200, {
+                ok: true,
+                data: response,
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, {
+                ok: false,
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }, "Update agent runtime settings");
+    router.add("*", "agent-suite/runtime-settings", ({ res }) => {
+        deps.sendJson(res, 405, {
+            ok: false,
+            error: "Use GET/PATCH /orgx/api/agent-suite/runtime-settings",
+        });
+    }, "Reject unsupported methods for agent-suite/runtime-settings");
     router.add("POST", "agent-suite/install", async ({ req, res }) => {
         try {
             const payload = toRecord(await deps.parseJsonRequest(req));
@@ -141,6 +295,7 @@ export function registerAgentSuiteRoutes(router, deps) {
             ok: true,
             data: {
                 policy: state.policy,
+                audit: state.audit,
                 pack: state.pack,
                 remote: state.remote,
                 updateAvailable: computeUpdateAvailable(state),
@@ -156,18 +311,56 @@ export function registerAgentSuiteRoutes(router, deps) {
             const frozen = typeof frozenRaw === "boolean" ? frozenRaw : undefined;
             const pinToCurrent = readBoolean(payload, "pinToCurrent", "pin_to_current");
             const clearPin = readBoolean(payload, "clearPin", "clear_pin");
-            const pinnedChecksumRaw = payload.pinnedChecksum;
+            const changedByRaw = payload.changedBy ?? payload.changed_by;
+            const changedBy = typeof changedByRaw === "string" ? changedByRaw : undefined;
+            const reasonRaw = payload.reason;
+            const reason = typeof reasonRaw === "string" ? reasonRaw : undefined;
+            const actionRaw = payload.action;
+            const action = typeof actionRaw === "string" ? actionRaw.trim().toLowerCase() : "";
+            const rollbackToAuditIdRaw = payload.rollbackToAuditId ?? payload.rollback_to_audit_id;
+            const rollbackToAuditId = toOptionalString(rollbackToAuditIdRaw)?.trim() || undefined;
+            const pinnedChecksumRaw = payload.pinnedChecksum ?? payload.pinned_checksum;
             const pinnedChecksum = typeof pinnedChecksumRaw === "string"
                 ? pinnedChecksumRaw
                 : pinnedChecksumRaw === null
                     ? null
                     : undefined;
-            const state = deps.updateSkillPackPolicy({
-                frozen,
-                pinToCurrent,
-                clearPin,
-                pinnedChecksum,
-            });
+            const hasFrozen = typeof frozen === "boolean";
+            const hasPinnedChecksum = typeof pinnedChecksum === "string" || pinnedChecksum === null;
+            const hasPinToCurrent = pinToCurrent === true;
+            const hasClearPin = clearPin === true;
+            const isRollback = action === "rollback" || typeof rollbackToAuditId === "string";
+            if (action.length > 0 && action !== "rollback") {
+                throw new Error("action must be 'rollback' when provided.");
+            }
+            if (hasPinToCurrent && hasClearPin) {
+                throw new Error("pinToCurrent and clearPin cannot both be true.");
+            }
+            if (typeof pinnedChecksum === "string" && !pinnedChecksum.trim()) {
+                throw new Error("pinnedChecksum must be a non-empty string when provided.");
+            }
+            if (isRollback) {
+                if (hasFrozen || hasPinnedChecksum || hasPinToCurrent || hasClearPin) {
+                    throw new Error("Rollback requests cannot include update fields (frozen, pinnedChecksum, pinToCurrent, clearPin).");
+                }
+            }
+            else if (!hasFrozen && !hasPinnedChecksum && !hasPinToCurrent && !hasClearPin) {
+                throw new Error("Include at least one mutable field: frozen, pinnedChecksum, pinToCurrent, or clearPin.");
+            }
+            const state = isRollback
+                ? deps.rollbackSkillPackPolicy({
+                    auditId: rollbackToAuditId,
+                    changedBy,
+                    reason,
+                })
+                : deps.updateSkillPackPolicy({
+                    frozen,
+                    pinToCurrent,
+                    clearPin,
+                    pinnedChecksum: typeof pinnedChecksum === "string" ? pinnedChecksum.trim() : pinnedChecksum,
+                    changedBy,
+                    reason,
+                });
             void deps
                 .posthogCapture({
                 event: "openclaw_skill_pack_policy_updated",
@@ -183,7 +376,13 @@ export function registerAgentSuiteRoutes(router, deps) {
                 .catch(() => {
                 // best effort
             });
-            deps.sendJson(res, 200, { ok: true, data: state.policy });
+            deps.sendJson(res, 200, {
+                ok: true,
+                data: {
+                    policy: state.policy,
+                    audit: state.audit,
+                },
+            });
         }
         catch (err) {
             deps.sendJson(res, 400, { ok: false, error: deps.safeErrorMessage(err) });

package/dist/http/routes/agents-catalog.js

@@ -1,13 +1,26 @@
 export function registerAgentsCatalogRoutes(router, deps) {
     async function handle(res) {
         try {
-            const [openclawAgents, localSnapshot] = await Promise.all([
-                deps.listAgents(),
-                deps.loadLocalSnapshot(),
-            ]);
+            let openclawAgents = [];
+            let openclawAgentsError = null;
+            try {
+                const fetched = await deps.listAgents();
+                openclawAgents = Array.isArray(fetched) ? fetched : [];
+            }
+            catch (err) {
+                openclawAgentsError = deps.safeErrorMessage(err);
+            }
+            const localSnapshot = await deps.loadLocalSnapshot().catch(() => null);
+            const localAgents = Array.isArray(localSnapshot?.agents)
+                ? localSnapshot.agents
+                : [];
+            const warnings = [];
+            if (openclawAgentsError) {
+                warnings.push(`openclaw agent discovery unavailable: ${openclawAgentsError}`);
+            }
             const localById = new Map();
-            if (localSnapshot) {
-                for (const agent of localSnapshot.agents) {
+            if (localAgents.length > 0) {
+                for (const agent of localAgents) {
                     localById.set(agent.id, {
                         status: agent.status,
                         currentTask: agent.currentTask,
@@ -17,9 +30,22 @@ export function registerAgentsCatalogRoutes(router, deps) {
                     });
                 }
             }
-            const contexts = deps.readAgentContexts().agents;
-            const runs = deps.readAgentRuns().runs;
+            let contexts = {};
+            try {
+                contexts = deps.readAgentContexts().agents ?? {};
+            }
+            catch (err) {
+                warnings.push(`agent context snapshot unavailable: ${deps.safeErrorMessage(err)}`);
+            }
+            let runs = {};
+            try {
+                runs = deps.readAgentRuns().runs ?? {};
+            }
+            catch (err) {
+                warnings.push(`agent run snapshot unavailable: ${deps.safeErrorMessage(err)}`);
+            }
             const latestRunByAgent = new Map();
+            const openclawById = new Map();
             for (const run of Object.values(runs)) {
                 if (!run || typeof run !== "object")
                     continue;
@@ -43,21 +69,39 @@ export function registerAgentsCatalogRoutes(router, deps) {
                     latestRunByAgent.set(agentId, run);
                 }
             }
-            const agents = openclawAgents.map((entry) => {
+            for (const entry of openclawAgents) {
                 const id = typeof entry.id === "string" ? entry.id.trim() : "";
-                const name = typeof entry.name === "string" && entry.name.trim().length > 0
+                if (!id)
+                    continue;
+                openclawById.set(id, entry);
+            }
+            const candidateAgentIds = new Set();
+            for (const id of openclawById.keys())
+                candidateAgentIds.add(id);
+            for (const id of localById.keys())
+                candidateAgentIds.add(id);
+            for (const id of Object.keys(contexts ?? {})) {
+                const normalized = id.trim();
+                if (normalized)
+                    candidateAgentIds.add(normalized);
+            }
+            for (const id of latestRunByAgent.keys())
+                candidateAgentIds.add(id);
+            const agents = [...candidateAgentIds].sort((a, b) => a.localeCompare(b)).map((agentId) => {
+                const entry = openclawById.get(agentId) ?? null;
+                const name = typeof entry?.name === "string" && entry.name.trim().length > 0
                     ? entry.name.trim()
-                    : id || "unknown";
-                const local = id ? localById.get(id) ?? null : null;
-                const context = id ? contexts[id] ?? null : null;
-                const runFromSession = id && local?.runId ? runs[local.runId] ?? null : null;
-                const run = runFromSession ?? (id ? latestRunByAgent.get(id) ?? null : null);
+                    : agentId || "unknown";
+                const local = localById.get(agentId) ?? null;
+                const context = contexts[agentId] ?? null;
+                const runFromSession = local?.runId ? runs[local.runId] ?? null : null;
+                const run = runFromSession ?? (latestRunByAgent.get(agentId) ?? null);
                 return {
-                    id,
+                    id: agentId,
                     name,
-                    workspace: typeof entry.workspace === "string" ? entry.workspace : null,
-                    model: typeof entry.model === "string" ? entry.model : null,
-                    isDefault: Boolean(entry.isDefault),
+                    workspace: typeof entry?.workspace === "string" ? entry.workspace : null,
+                    model: typeof entry?.model === "string" ? entry.model : null,
+                    isDefault: Boolean(entry?.isDefault),
                     status: local?.status ?? null,
                     currentTask: local?.currentTask ?? null,
                     runId: local?.runId ?? null,
@@ -70,6 +114,7 @@ export function registerAgentsCatalogRoutes(router, deps) {
             deps.sendJson(res, 200, {
                 generatedAt: new Date().toISOString(),
                 agents,
+                ...(warnings.length > 0 ? { warnings } : {}),
             });
         }
         catch (err) {

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

@@ -0,0 +1,19 @@
+import type { Router } from "../router.js";
+type JsonRecord = Record<string, unknown>;
+type RegisterChatRoutesDeps<TReq, TRes> = {
+    parseJsonRequest: (req: TReq) => Promise<JsonRecord>;
+    pickString: (input: Record<string, unknown>, keys: string[]) => string | null;
+    parsePositiveInt: (raw: string | null, fallback: number) => number;
+    emitActivitySafe?: (input: {
+        initiativeId: string | null;
+        sourceClient?: string;
+        message: string;
+        phase: "intent" | "execution" | "blocked" | "review" | "handoff" | "completed";
+        progressPct?: number;
+        metadata?: Record<string, unknown>;
+    }) => Promise<unknown>;
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+};
+export declare function registerChatRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterChatRoutesDeps<TReq, TRes>): void;
+export {};