支持权限与人工审批的工具执行器

/*
 * 题目：支持权限与人工审批的工具执行器
 * 要求：工具按权限和风险等级执行。高风险调用先产生审批单；批准后仅允许原参数、未过期、
 * 具备权限的一次执行。
 * 示例：批准了参数 A 后改成参数 B，恢复执行必须拒绝。
 */
const stable = (value) =>
  value && typeof value === "object"
    ? Array.isArray(value)
      ? `[${value.map(stable)}]`
      : `{${Object.keys(value)
          .sort()
          .map((k) => `${JSON.stringify(k)}:${stable(value[k])}`)
          .join(",")}}`
    : JSON.stringify(value);
class ApprovalStore {
  constructor() {}
  create(call, expiresAt) {}
  decide(id, approved) {}
  consume(id, call, now) {}
}
class ApprovedToolExecutor {
  constructor(registry, approvals, now = Date.now) {}
  async execute(call, context) {}
}

(async () => {
  let effects = 0;
  const registry = new Map([
    [
      "pay",
      { risk: "high", requiredPermissions: ["pay"], execute: () => ++effects },
    ],
  ]);
  const store = new ApprovalStore();
  const executor = new ApprovedToolExecutor(registry, store, () => 100);
  const call = { id: "t1", name: "pay", arguments: { amount: 10 } };
  const pending = await executor.execute(call, { permissions: ["pay"] });
  console.log(pending.status); // 预期："waiting_approval"
  store.decide(pending.approvalId, true);
  console.log((
      await executor.execute(call, {
        permissions: ["pay"],
        approvalId: pending.approvalId,
      })
    ).output); // 预期：1
  console.log(await Promise.resolve(executor.execute(call, {
      permissions: ["pay"],
      approvalId: pending.approvalId,
    })).then(() => false, () => true)); // 预期：true（拒绝）
})().catch(console.error);

const stable = (value) =>
  value && typeof value === "object"
    ? Array.isArray(value)
      ? `[${value.map(stable)}]`
      : `{${Object.keys(value)
          .sort()
          .map((k) => `${JSON.stringify(k)}:${stable(value[k])}`)
          .join(",")}}`
    : JSON.stringify(value);
// 关键机制：审批绑定完整调用摘要；consume 原子标记防重复，并在恢复时重新校验权限。
class ApprovalStore {
  constructor() {
    this.items = new Map();
    this.sequence = 0;
  }
  create(call, expiresAt) {
    const item = {
      id: `a${++this.sequence}`,
      digest: stable(call),
      status: "pending",
      expiresAt,
    };
    this.items.set(item.id, item);
    return { ...item };
  }
  decide(id, approved) {
    const item = this.items.get(id);
    if (!item || item.status !== "pending")
      throw new Error("approval unavailable");
    item.status = approved ? "approved" : "rejected";
  }
  consume(id, call, now) {
    const item = this.items.get(id);
    if (!item || item.status !== "approved")
      throw new Error("approval not granted");
    if (item.expiresAt <= now) {
      item.status = "expired";
      throw new Error("approval expired");
    }
    if (item.digest !== stable(call))
      throw new Error("approved call was changed");
    item.status = "executed";
  }
}
class ApprovedToolExecutor {
  constructor(registry, approvals, now = Date.now) {
    this.registry = registry;
    this.approvals = approvals;
    this.now = now;
  }
  async execute(call, context) {
    const tool = this.registry.get(call.name);
    if (!tool) return { status: "error", code: "TOOL_NOT_FOUND" };
    const permissions = new Set(context.permissions || []);
    if ((tool.requiredPermissions || []).some((p) => !permissions.has(p)))
      return { status: "error", code: "FORBIDDEN" };
    if (tool.risk === "high" && !context.approvalId) {
      const approval = this.approvals.create(
        call,
        this.now() + (context.approvalTtl || 300000),
      );
      return { status: "waiting_approval", approvalId: approval.id };
    }
    if (tool.risk === "high")
      this.approvals.consume(context.approvalId, call, this.now());
    return {
      status: "completed",
      output: await tool.execute(call.arguments, context),
    };
  }
}

// 三组以上可直接运行的验证；异步题使用独立执行块。
(async () => {
  let effects = 0;
  const registry = new Map([
    [
      "pay",
      { risk: "high", requiredPermissions: ["pay"], execute: () => ++effects },
    ],
  ]);
  const store = new ApprovalStore();
  const executor = new ApprovedToolExecutor(registry, store, () => 100);
  const call = { id: "t1", name: "pay", arguments: { amount: 10 } };
  const pending = await executor.execute(call, { permissions: ["pay"] });
  console.log(pending.status); // 预期："waiting_approval"
  store.decide(pending.approvalId, true);
  console.log((
      await executor.execute(call, {
        permissions: ["pay"],
        approvalId: pending.approvalId,
      })
    ).output); // 预期：1
  console.log(await Promise.resolve(executor.execute(call, {
      permissions: ["pay"],
      approvalId: pending.approvalId,
    })).then(() => false, () => true)); // 预期：true（拒绝）
  console.log(effects); // 预期：1


})().catch(console.error);