Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(cli): confirm project grant revocation

N0zoM1z07a4cfb4fbd96
diff --git a/docs/mcp-contracts.md b/docs/mcp-contracts.md
index 0199f1834..6f3e6d768 100644
--- a/docs/mcp-contracts.md
+++ b/docs/mcp-contracts.md
@@ -91,6 +91,8 @@ never enabled by default. Send `SIGHUP` to the REA MCP process after a trusted
local policy change; ceilings, administrator grants, and project grants reload
without restarting. Revocation affects future operations; an already-running
operation retains the decision made at its preflight boundary.
+`rea policy revoke <grant-id>` displays the exact grant and requires interactive
+confirmation; automation must pass `--yes` (or `-y`) explicitly.
Denials use the shared `permission_required` schema with requested scope, missing
scope, administrator ceiling, elicitation support, and exact restart status.
diff --git a/src/cliPolicyCommands.ts b/src/cliPolicyCommands.ts
index d28e2abe0..eebcb34a5 100644
--- a/src/cliPolicyCommands.ts
+++ b/src/cliPolicyCommands.ts
@@ -1,4 +1,5 @@
import { Cli, z } from "incur";
+import { createInterface } from "node:readline/promises";
import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
import {
@@ -30,6 +31,24 @@ const capabilitySchema = z.enum([
"reference_read",
]);
+type PolicyRevocationApproval =
+ | { readonly approved: true }
+ | { readonly approved: false; readonly reason: "cancelled" | "required" };
+
+/** Require an explicit decision before a project permission grant is removed. */
+export const approvePolicyRevocation = async (options: {
+ readonly approved: boolean;
+ readonly interactive: boolean;
+ readonly grantId: string;
+ readonly confirm: (grantId: string) => Promise<boolean>;
+}): Promise<PolicyRevocationApproval> => {
+ if (options.approved) return { approved: true };
+ if (!options.interactive) return { approved: false, reason: "required" };
+ return (await options.confirm(options.grantId))
+ ? { approved: true }
+ : { approved: false, reason: "cancelled" };
+};
+
/** Register inspectable, dry-run, and revocation policy UX for the CLI. */
export const registerPolicyCommands = (
cli: ReturnType<typeof Cli.create>,
@@ -49,9 +68,13 @@ export const registerPolicyCommands = (
network: z.enum(["none", "loopback", "external"]).default("none"),
mount: z.boolean().default(false),
write: z.boolean().default(false),
+ yes: z
+ .boolean()
+ .default(false)
+ .describe("Confirm project permission revocation without prompting"),
}),
- alias: { environmentNames: "environment-names" },
- run: ({ args, options }) =>
+ alias: { environmentNames: "environment-names", yes: "y" },
+ run: ({ agent, args, formatExplicit, options }) =>
logCliCommand(logger, "policy", async () => {
const config = parseConfig(process.env);
if (!config.ok) return failure(config.error);
@@ -76,6 +99,24 @@ export const registerPolicyCommands = (
permissionProjectStore === undefined
)
return { error: "Project policy is not configured" };
+ const approval = await approvePolicyRevocation({
+ approved: options.yes,
+ interactive:
+ !agent && !formatExplicit && process.stdin.isTTY === true,
+ grantId: args.value,
+ confirm: confirmPolicyRevocation,
+ });
+ if (!approval.approved)
+ return approval.reason === "required"
+ ? {
+ error:
+ "Policy revoke requires confirmation. Rerun interactively or with --yes.",
+ grant_id: args.value,
+ }
+ : {
+ error: "Policy revocation was cancelled",
+ grant_id: args.value,
+ };
const revoked = await revokeProjectPermissionGrant(
permissionProjectStore,
permissionProjectRoot,
@@ -100,6 +141,21 @@ export const registerPolicyCommands = (
});
};
+const confirmPolicyRevocation = async (grantId: string): Promise<boolean> => {
+ const prompt = createInterface({
+ input: process.stdin,
+ output: process.stdout,
+ });
+ try {
+ const answer = await prompt.question(
+ `Revoke project permission grant ${JSON.stringify(grantId)}? [y/N] `,
+ );
+ return ["y", "yes"].includes(answer.trim().toLowerCase());
+ } finally {
+ prompt.close();
+ }
+};
+
const explain = async (
config: AppConfig,
capability: PermissionCapability,
diff --git a/tests/cliPolicyCommands.test.ts b/tests/cliPolicyCommands.test.ts
new file mode 100644
index 000000000..2770066eb
--- /dev/null
+++ b/tests/cliPolicyCommands.test.ts
@@ -0,0 +1,53 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { approvePolicyRevocation } from "../src/cliPolicyCommands.js";
+
+describe("policy revocation approval", () => {
+ it("accepts --yes without invoking the interactive prompt", async () => {
+ const confirm = vi.fn<() => Promise<boolean>>();
+
+ await expect(
+ approvePolicyRevocation({
+ approved: true,
+ interactive: false,
+ grantId: "grant-1",
+ confirm,
+ }),
+ ).resolves.toEqual({ approved: true });
+ expect(confirm).not.toHaveBeenCalled();
+ });
+
+ it("fails closed for non-interactive revocation without --yes", async () => {
+ const confirm = vi.fn<() => Promise<boolean>>();
+
+ await expect(
+ approvePolicyRevocation({
+ approved: false,
+ interactive: false,
+ grantId: "grant-1",
+ confirm,
+ }),
+ ).resolves.toEqual({ approved: false, reason: "required" });
+ expect(confirm).not.toHaveBeenCalled();
+ });
+
+ it.each([
+ [true, { approved: true }],
+ [false, { approved: false, reason: "cancelled" }],
+ ] as const)(
+ "uses the interactive decision %s",
+ async (decision, expected) => {
+ const confirm = vi.fn(() => Promise.resolve(decision));
+
+ await expect(
+ approvePolicyRevocation({
+ approved: false,
+ interactive: true,
+ grantId: "grant-1",
+ confirm,
+ }),
+ ).resolves.toEqual(expected);
+ expect(confirm).toHaveBeenCalledWith("grant-1");
+ },
+ );
+});