vultr/openclaw
1
0
Fork 0
mirror of https://github.com/openclaw/openclaw.git synced 2026-06-05 20:32:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: share exec approvals node invoke

Browse Source
This commit is contained in:
Vincent Koc
2026-05-31 23:42:57 +02:00
parent b73e135f97
commit c6232347dc
1 changed files with 53 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
src/gateway/server-methods/exec-approvals.ts
View File

@@ -21,8 +21,8 @@ import {
respondUnavailableOnThrow,
safeParseJson,
} from "./nodes.helpers.js";
import type { GatewayRequestHandlers, RespondFn } from "./types.js";
import { assertValidParams } from "./validation.js";
import type { GatewayRequestContext, GatewayRequestHandlers, RespondFn } from "./types.js";
import { assertValidParams, type Validator } from "./validation.js";
function requireApprovalsBaseHash(
params: unknown,
@@ -90,13 +90,37 @@ function toExecApprovalsPayload(snapshot: ExecApprovalsSnapshot) {
};
}
function resolveNodeIdOrRespond(nodeId: string, respond: RespondFn): string | null {
const id = nodeId.trim();
if (!id) {
respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "nodeId required"));
return null;
async function respondWithExecApprovalsNodePayload<TParams extends { nodeId: string }>(params: {
method: string;
rawParams: unknown;
validate: Validator<TParams>;
context: GatewayRequestContext;
respond: RespondFn;
command: "system.execApprovals.get" | "system.execApprovals.set";
commandParams: (parsedParams: TParams) => Record<string, unknown>;
readPayload: (response: { payload?: unknown; payloadJSON?: string | null }) => unknown;
}): Promise<void> {
const rawParams = params.rawParams;
if (!assertValidParams(rawParams, params.validate, params.method, params.respond)) {
return;
}
return id;
const parsedParams = rawParams;
const nodeId = parsedParams.nodeId.trim();
if (!nodeId) {
params.respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "nodeId required"));
return;
}
await respondUnavailableOnThrow(params.respond, async () => {
const res = await params.context.nodeRegistry.invoke({
nodeId,
command: params.command,
params: params.commandParams(parsedParams),
});
if (!respondUnavailableOnNodeInvokeError(params.respond, res)) {
return;
}
params.respond(true, params.readPayload(res), undefined);
});
}
export const execApprovalsHandlers: GatewayRequestHandlers = {
@@ -133,69 +157,34 @@ export const execApprovalsHandlers: GatewayRequestHandlers = {
respond(true, toExecApprovalsPayload(nextSnapshot), undefined);
},
"exec.approvals.node.get": async ({ params, respond, context }) => {
if (
!assertValidParams(
params,
validateExecApprovalsNodeGetParams,
"exec.approvals.node.get",
respond,
)
) {
return;
}
const { nodeId } = params as { nodeId: string };
const id = resolveNodeIdOrRespond(nodeId, respond);
if (!id) {
return;
}
await respondUnavailableOnThrow(respond, async () => {
const res = await context.nodeRegistry.invoke({
nodeId: id,
command: "system.execApprovals.get",
params: {},
});
if (!respondUnavailableOnNodeInvokeError(respond, res)) {
return;
}
await respondWithExecApprovalsNodePayload({
method: "exec.approvals.node.get",
rawParams: params,
validate: validateExecApprovalsNodeGetParams,
context,
respond,
command: "system.execApprovals.get",
commandParams: () => ({}),
// Node invocations can return structured payloads or JSON strings
// depending on the transport; normalize before echoing the RPC response.
const payload = res.payloadJSON ? safeParseJson(res.payloadJSON) : res.payload;
respond(true, payload, undefined);
readPayload: (res) => (res.payloadJSON ? safeParseJson(res.payloadJSON) : res.payload),
});
},
"exec.approvals.node.set": async ({ params, respond, context }) => {
if (
!assertValidParams(
params,
validateExecApprovalsNodeSetParams,
"exec.approvals.node.set",
respond,
)
) {
return;
}
const { nodeId, file, baseHash } = params as {
nodeId: string;
file: ExecApprovalsFile;
baseHash?: string;
};
const id = resolveNodeIdOrRespond(nodeId, respond);
if (!id) {
return;
}
await respondUnavailableOnThrow(respond, async () => {
const res = await context.nodeRegistry.invoke({
nodeId: id,
command: "system.execApprovals.set",
params: { file, baseHash },
});
if (!respondUnavailableOnNodeInvokeError(respond, res)) {
return;
}
await respondWithExecApprovalsNodePayload({
method: "exec.approvals.node.set",
rawParams: params,
validate: validateExecApprovalsNodeSetParams,
context,
respond,
command: "system.execApprovals.set",
commandParams: (parsedParams) => ({
file: parsedParams.file,
baseHash: parsedParams.baseHash,
}),
// node.set returns JSON on the command channel; keep the gateway response
// shape aligned with local exec.approvals.set.
const payload = safeParseJson(res.payloadJSON ?? null);
respond(true, payload, undefined);
readPayload: (res) => safeParseJson(res.payloadJSON ?? null),
});
},
};