feat(cli): resolve pending exec approvals

scoootscooob · scoootscooob · commit 714c19cc05fb · 2026-05-17T21:52:42.000-07:00
diff --git a/docs/cli/approvals.md b/docs/cli/approvals.md
@@ -63,6 +63,8 @@ or `openclaw approvals set --node <id|name|ip>`.
 openclaw approvals get
 openclaw approvals get --node <id|name|ip>
 openclaw approvals get --gateway
+openclaw approvals pending
+openclaw approvals resolve <approval-id> allow-once
 ```
 
 `openclaw approvals get` now shows the effective exec policy for local, gateway, and node targets:
@@ -78,6 +80,19 @@ Precedence is intentional:
 - `--node` combines the node host approvals file with gateway `tools.exec` policy, because both still apply at runtime
 - if gateway config is unavailable, the CLI falls back to the node approvals snapshot and notes that the final runtime policy could not be computed
 
+## Pending approval prompts
+
+When an agent asks for host exec approval and chat-native buttons are unavailable, the prompt includes a slash command such as `/approve <id> allow-once`. Operators can resolve the same pending request from the CLI:
+
+```bash
+openclaw approvals pending
+openclaw approvals resolve <approval-id> allow-once
+openclaw approvals resolve <approval-id> allow-always
+openclaw approvals resolve <approval-id> deny
+```
+
+`pending` and `resolve` talk to the running gateway runtime, not the local approvals JSON file. They require the same gateway connection options as other operator RPC commands. Use `pending --json` to script against the raw approval records.
+
 ## Replace approvals from a file
 
 ```bash
diff --git a/src/cli/exec-approvals-cli.test.ts b/src/cli/exec-approvals-cli.test.ts
@@ -222,6 +222,42 @@ describe("exec approvals CLI", () => {
     expect(runtimeErrors).toHaveLength(0);
   });
 
+  it("lists pending runtime approvals through the gateway", async () => {
+    callGatewayFromCli.mockResolvedValueOnce([
+      {
+        id: "approval-1",
+        request: {
+          command: "echo ok",
+          host: "gateway",
+          agentId: "main",
+        },
+        expiresAtMs: Date.UTC(2026, 4, 18, 12, 0, 0),
+      },
+    ]);
+
+    await runApprovalsCommand(["approvals", "pending"]);
+
+    expectGatewayCall(0, "exec.approval.list", {});
+    const output = defaultRuntime.log.mock.calls.map((call) => String(call[0])).join("\n");
+    expect(output).toContain("Pending Exec Approvals");
+    expect(output).toContain("approval-1");
+    expect(output).toContain("echo ok");
+    expect(runtimeErrors).toHaveLength(0);
+  });
+
+  it("resolves pending runtime approvals through the gateway", async () => {
+    await runApprovalsCommand(["approvals", "resolve", "approval-1", "always"]);
+
+    expectGatewayCall(0, "exec.approval.resolve", {
+      id: "approval-1",
+      decision: "allow-always",
+    });
+    expect(defaultRuntime.log).toHaveBeenCalledWith(
+      "Approval allow-always submitted for approval-1.",
+    );
+    expect(runtimeErrors).toHaveLength(0);
+  });
+
   it("adds effective policy to json output", async () => {
     localSnapshot.file = {
       version: 1,
diff --git a/src/cli/exec-approvals-cli.ts b/src/cli/exec-approvals-cli.ts
@@ -44,7 +44,15 @@ type EffectivePolicyReport = {
   scopes: ExecPolicyScopeSnapshot[];
   note?: string;
 };
+type PendingExecApprovalRow = {
+  ID: string;
+  Command: string;
+  Host: string;
+  Agent: string;
+  Expires: string;
+};
 const APPROVALS_GET_DEFAULT_TIMEOUT_MS = 60_000;
+const APPROVALS_PENDING_DEFAULT_TIMEOUT_MS = 60_000;
 
 type ExecApprovalsCliOpts = NodesRpcOpts & {
   node?: string;
@@ -171,6 +179,95 @@ function formatCliError(err: unknown): string {
   return safe.length > 300 ? `${safe.slice(0, 300)}...` : safe;
 }
 
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function readPendingApprovals(payload: unknown): unknown[] {
+  if (Array.isArray(payload)) {
+    return payload;
+  }
+  if (isObjectRecord(payload) && Array.isArray(payload.approvals)) {
+    return payload.approvals;
+  }
+  return [];
+}
+
+function readPendingApprovalCommand(request: Record<string, unknown>): string {
+  const systemRunPlan = isObjectRecord(request.systemRunPlan) ? request.systemRunPlan : null;
+  const command =
+    normalizeOptionalString(request.command) ??
+    normalizeOptionalString(request.commandPreview) ??
+    normalizeOptionalString(systemRunPlan?.commandPreview) ??
+    normalizeOptionalString(systemRunPlan?.commandText);
+  return command ?? "(unknown command)";
+}
+
+function formatTimestamp(value: unknown): string {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return "unknown";
+  }
+  return new Date(value).toISOString();
+}
+
+function buildPendingApprovalRows(payload: unknown): PendingExecApprovalRow[] {
+  return readPendingApprovals(payload)
+    .map((approval): PendingExecApprovalRow | null => {
+      if (!isObjectRecord(approval)) {
+        return null;
+      }
+      const id = normalizeOptionalString(approval.id);
+      const request = isObjectRecord(approval.request) ? approval.request : {};
+      if (!id) {
+        return null;
+      }
+      return {
+        ID: id,
+        Command: readPendingApprovalCommand(request),
+        Host: normalizeOptionalString(request.host) ?? "gateway",
+        Agent: normalizeOptionalString(request.agentId) ?? "unknown",
+        Expires: formatTimestamp(approval.expiresAtMs),
+      };
+    })
+    .filter((row): row is PendingExecApprovalRow => row !== null);
+}
+
+function renderPendingApprovals(payload: unknown) {
+  const rows = buildPendingApprovalRows(payload);
+  const rich = isRich();
+  const heading = (text: string) => (rich ? theme.heading(text) : text);
+  const muted = (text: string) => (rich ? theme.muted(text) : text);
+  defaultRuntime.log(heading("Pending Exec Approvals"));
+  if (rows.length === 0) {
+    defaultRuntime.log(muted("No pending approvals."));
+    return;
+  }
+  defaultRuntime.log(
+    renderTable({
+      width: getTerminalTableWidth(),
+      columns: [
+        { key: "ID", header: "ID", minWidth: 12 },
+        { key: "Command", header: "Command", minWidth: 24, flex: true },
+        { key: "Host", header: "Host", minWidth: 8 },
+        { key: "Agent", header: "Agent", minWidth: 10 },
+        { key: "Expires", header: "Expires", minWidth: 20 },
+      ],
+      rows,
+    }).trimEnd(),
+  );
+}
+
+function normalizeApprovalDecisionInput(decision: string): string {
+  const normalized = decision.trim().toLowerCase();
+  if (normalized === "always") {
+    return "allow-always";
+  }
+  if (normalized === "allow-once" || normalized === "allow-always" || normalized === "deny") {
+    return normalized;
+  }
+  exitWithError("Decision must be allow-once, allow-always, always, or deny.");
+}
+
 async function loadConfigForApprovalsTarget(params: {
   opts: ExecApprovalsCliOpts;
   source: ApprovalsTargetSource;
@@ -553,6 +650,63 @@ export function registerExecApprovalsCli(program: Command) {
     });
   nodesCallOpts(setCmd);
 
+  const pendingCmd = approvals
+    .command("pending")
+    .alias("list")
+    .description("List pending exec approval requests")
+    .action(async (opts: ExecApprovalsCliOpts) => {
+      try {
+        const pending = await callGatewayFromCli("exec.approval.list", opts, {});
+        if (opts.json) {
+          defaultRuntime.writeJson({ approvals: readPendingApprovals(pending) }, 0);
+          return;
+        }
+        renderPendingApprovals(pending);
+      } catch (err) {
+        defaultRuntime.error(formatCliError(err));
+        defaultRuntime.exit(1);
+      }
+    });
+  nodesCallOpts(pendingCmd, { timeoutMs: APPROVALS_PENDING_DEFAULT_TIMEOUT_MS });
+
+  const resolveCmd = approvals
+    .command("resolve <id> <decision>")
+    .alias("respond")
+    .description("Resolve a pending exec approval request")
+    .addHelpText(
+      "after",
+      () =>
+        `\n${theme.heading("Examples:")}\n${formatExample(
+          "openclaw approvals pending",
+          "Show pending approval IDs.",
+        )}\n${formatExample(
+          "openclaw approvals resolve <id> allow-once",
+          "Approve one pending command.",
+        )}\n${formatExample(
+          "openclaw approvals resolve <id> deny",
+          "Deny one pending command.",
+        )}\n\n${theme.muted("Docs:")} ${formatDocsLink("/cli/approvals", "docs.openclaw.ai/cli/approvals")}\n`,
+    )
+    .action(async (id: string, decision: string, opts: ExecApprovalsCliOpts) => {
+      try {
+        const trimmedId = requireTrimmedNonEmpty(id, "Approval id required.");
+        const normalizedDecision = normalizeApprovalDecisionInput(decision);
+        const result = await callGatewayFromCli("exec.approval.resolve", opts, {
+          id: trimmedId,
+          decision: normalizedDecision,
+        });
+        if (opts.json) {
+          defaultRuntime.writeJson(result, 0);
+          return;
+        }
+        defaultRuntime.log(`Approval ${normalizedDecision} submitted for ${trimmedId}.`);
+      } catch (err) {
+        defaultRuntime.error(formatCliError(err));
+        defaultRuntime.exit(1);
+      }
+    });
+  nodesCallOpts(resolveCmd, { timeoutMs: APPROVALS_PENDING_DEFAULT_TIMEOUT_MS });
+
   const allowlist = approvals
     .command("allowlist")
     .description("Edit the per-agent allowlist")
