@botconnector/bccli 0.5.0-rc.4 → 0.5.1

package/dist/chunk-OK2USAXX.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+// src/tokenBudget.ts
+var IMAGE_TOKEN_COST = 1e3;
+var estimateTokens = (text) => Math.ceil(text.length / 4);
+function isImageAttachmentMessage(m) {
+  if (m.role !== "user" || !Array.isArray(m.content)) return false;
+  const hasImage = m.content.some((p) => p.type === "image_url");
+  const firstText = m.content.find((p) => p.type === "text");
+  return hasImage && !!firstText && firstText.type === "text" && firstText.text.startsWith("Image read from ");
+}
+function isUserTurnBoundary(m) {
+  return m.role === "user" && !isImageAttachmentMessage(m);
+}
+function estimateMessages(messages) {
+  let total = 0;
+  for (const m of messages) {
+    if (m.role === "user" && Array.isArray(m.content)) {
+      for (const part of m.content) {
+        if (part.type === "image_url") total += IMAGE_TOKEN_COST;
+        else total += estimateTokens(part.text);
+      }
+      total += 8;
+    } else {
+      total += estimateTokens(JSON.stringify(m));
+    }
+  }
+  return total;
+}
+function trimToFit(messages, maxTokens) {
+  let out = messages;
+  while (estimateMessages(out) > maxTokens) {
+    const boundary = out.findIndex((m, i) => i > 0 && isUserTurnBoundary(m));
+    if (boundary === -1) return out;
+    out = out.slice(boundary);
+  }
+  return out;
+}
+function splitKeepRecent(messages, keepTokens) {
+  if (messages.length === 0) return [[], []];
+  let start = messages.length;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (i > 0 && !isUserTurnBoundary(messages[i])) continue;
+    if (estimateMessages(messages.slice(i)) <= keepTokens) start = i;
+    else break;
+  }
+  if (start === messages.length) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (isUserTurnBoundary(messages[i])) {
+        start = i;
+        break;
+      }
+    }
+  }
+  return [messages.slice(0, start), messages.slice(start)];
+}
+var TOOL_STUB = "[Old tool result content cleared]";
+var TOOL_PRUNE_KEEP_TOKENS = 4e4;
+var TOOL_PRUNE_MIN_TOKENS = 2e4;
+var isToolStub = (content) => content.startsWith(TOOL_STUB);
+function pruneOldToolOutputs(messages) {
+  let kept = 0;
+  let oldTokens = 0;
+  const old = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role !== "tool" || isToolStub(m.content)) continue;
+    kept += estimateTokens(m.content);
+    if (kept > TOOL_PRUNE_KEEP_TOKENS) {
+      old.push(i);
+      oldTokens += estimateTokens(m.content);
+    }
+  }
+  if (oldTokens <= TOOL_PRUNE_MIN_TOKENS) return false;
+  for (const i of old) {
+    const m = messages[i];
+    messages[i] = { ...m, content: TOOL_STUB };
+  }
+  return true;
+}
+
+export {
+  estimateTokens,
+  estimateMessages,
+  trimToFit,
+  splitKeepRecent,
+  pruneOldToolOutputs
+};

package/dist/chunk-PSO7R5AD.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+// src/tools/types.ts
+function defineTool(tool) {
+  return tool;
+}
+
+export {
+  defineTool
+};

package/dist/chunk-RLSQAZBT.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import {
+  listAllModels
+} from "./chunk-2IP5F3EK.js";
+import {
+  hasKey,
+  providerName,
+  removeGlobalProvider,
+  writeGlobalConfig
+} from "./chunk-FY543EQW.js";
+import {
+  PRESETS,
+  loadConfig,
+  saveCredential
+} from "./chunk-ZXWRLN7E.js";
+import {
+  t
+} from "./chunk-IDZLHEVL.js";
+
+// src/providerCli.ts
+async function addProviderKey(providerId, key, deps) {
+  const config = loadConfig(deps.cwd, deps.env);
+  const [group] = await listAllModels(config, deps.env, { only: providerId, fetch: deps.fetch, keyOverride: key || void 0 });
+  if (!group || group.error) return { ok: false, error: t("The API key was rejected or {provider} could not be reached.", { provider: providerName(config, providerId) }) };
+  if (key) saveCredential(providerId, key, deps.env);
+  return { ok: true, models: group.models.length };
+}
+async function runProviderCommand(args, deps) {
+  const [action = "list", id] = args.subArgs;
+  const config = loadConfig(deps.cwd, deps.env);
+  if (action === "list") {
+    for (const pid of Object.keys(config.providers)) {
+      const mark = hasKey(config, pid, deps.env) ? "\u2713" : "\u25CB";
+      deps.out(`${mark} ${pid.padEnd(14)} ${providerName(config, pid).padEnd(20)} ${config.providers[pid].baseURL}`);
+    }
+    return 0;
+  }
+  if (!id) {
+    deps.err(t("Usage: bccli provider {action} <id>", { action }));
+    return 1;
+  }
+  if (action === "remove") {
+    removeGlobalProvider(id, deps.env);
+    deps.out(t("{id} removed.", { id }));
+    return 0;
+  }
+  if (action !== "add") {
+    deps.err(t("Unknown action: {action}. Use list, add, or remove.", { action }));
+    return 1;
+  }
+  const preset = PRESETS.find((p) => p.id === id);
+  const createdEntry = !preset && !config.providers[id];
+  if (createdEntry) {
+    if (!args.url) {
+      deps.err(t("{id} is not a preset. For a custom provider add --url <OpenAI-compatible base URL>.", { id }));
+      return 1;
+    }
+    writeGlobalConfig(
+      { providers: { [id]: { baseURL: args.url, ...args.name ? { name: args.name } : {}, ...args.keyEnv ? { apiKeyEnv: args.keyEnv } : {} } } },
+      deps.env
+    );
+  }
+  const needsKey = !!loadConfig(deps.cwd, deps.env).providers[id].apiKeyEnv || !preset;
+  const key = needsKey ? await deps.readSecret(t("API key for {id} (leave empty if not needed): ", { id })) : "";
+  const result = await addProviderKey(id, key, deps);
+  if (!result.ok) {
+    if (createdEntry) removeGlobalProvider(id, deps.env);
+    deps.err(result.error);
+    return 1;
+  }
+  deps.out(t("{id} is ready. {n} models available.", { id, n: result.models }));
+  return 0;
+}
+
+export {
+  addProviderKey,
+  runProviderCommand
+};

package/dist/chunk-VPFCIUC6.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import {
+  ConfigError,
+  writeFileAtomic
+} from "./chunk-ZXWRLN7E.js";
+import {
+  t
+} from "./chunk-IDZLHEVL.js";
+
+// src/mcp/config.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+var ENV_REF = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
+function expandEnvVars(config, env) {
+  const expand = (value) => value.replace(ENV_REF, (match, name, fallback) => {
+    const resolved = env[name];
+    if (resolved !== void 0) return resolved;
+    return fallback !== void 0 ? fallback : match;
+  });
+  const expandMap = (map) => Object.fromEntries(Object.entries(map).map(([k, v]) => [k, expand(v)]));
+  if (config.type === "http") {
+    return { ...config, url: expand(config.url), ...config.headers ? { headers: expandMap(config.headers) } : {} };
+  }
+  return {
+    ...config,
+    command: expand(config.command),
+    ...config.args ? { args: config.args.map(expand) } : {},
+    ...config.env ? { env: expandMap(config.env) } : {}
+  };
+}
+var globalMcpPath = (home) => join(home, "mcp.json");
+var projectMcpPath = (cwd) => join(cwd, ".bccli", "mcp.json");
+var trustPath = (home) => join(home, "trusted-mcp.json");
+function readJson(path, fallback) {
+  if (!existsSync(path)) return fallback;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new ConfigError(t("Invalid MCP file: {path} ({error})", { path, error: error.message }));
+  }
+}
+function writePrivate(path, data) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileAtomic(path, `${JSON.stringify(data, null, 2)}
+`, 384);
+}
+function readMcpFile(path) {
+  return readJson(path, {}).mcpServers ?? {};
+}
+function addGlobalServer(home, name, config) {
+  writePrivate(globalMcpPath(home), { mcpServers: { ...readMcpFile(globalMcpPath(home)), [name]: config } });
+}
+function removeGlobalServer(home, name) {
+  const { [name]: _removed, ...rest } = readMcpFile(globalMcpPath(home));
+  writePrivate(globalMcpPath(home), { mcpServers: rest });
+}
+var configHash = (config) => createHash("sha256").update(JSON.stringify(config)).digest("hex");
+function projectTrust(home, cwd, name, config) {
+  const decision = readJson(trustPath(home), {})[resolve(cwd)]?.[name];
+  return decision?.hash === configHash(config) ? decision.allowed : void 0;
+}
+function setProjectTrust(home, cwd, name, allowed, config) {
+  const all = readJson(trustPath(home), {});
+  const key = resolve(cwd);
+  writePrivate(trustPath(home), { ...all, [key]: { ...all[key], [name]: { allowed, hash: configHash(config) } } });
+}
+function serversToStart(home, cwd) {
+  const global = readMcpFile(globalMcpPath(home));
+  const start = Object.entries(global).map(([name, config]) => ({ name, config, source: "global" }));
+  const needTrust = [];
+  for (const [name, config] of Object.entries(readMcpFile(projectMcpPath(cwd)))) {
+    if (global[name]) continue;
+    const trust = projectTrust(home, cwd, name, config);
+    if (trust === true) start.push({ name, config, source: "project" });
+    else if (trust === void 0) needTrust.push({ name, config, source: "project" });
+  }
+  return { start, needTrust };
+}
+
+export {
+  expandEnvVars,
+  globalMcpPath,
+  projectMcpPath,
+  readMcpFile,
+  addGlobalServer,
+  removeGlobalServer,
+  projectTrust,
+  setProjectTrust,
+  serversToStart
+};

package/dist/chunk-YGBTNDPK.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+import {
+  quarantineCorruptFile,
+  writeFileAtomic
+} from "./chunk-ZXWRLN7E.js";
+
+// src/mcp/oauth.ts
+import { spawn } from "child_process";
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { createServer } from "http";
+import { dirname, join } from "path";
+import { auth } from "@modelcontextprotocol/sdk/client/auth.js";
+var oauthStorePath = (home) => join(home, "mcp-oauth.json");
+function readStore(home) {
+  const path = oauthStorePath(home);
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    quarantineCorruptFile(path, error);
+    return {};
+  }
+}
+function writeStore(home, store) {
+  const path = oauthStorePath(home);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileAtomic(path, `${JSON.stringify(store, null, 2)}
+`, 384);
+}
+function hasStoredTokens(home, serverUrl) {
+  return Boolean(readStore(home)[serverUrl]?.tokens);
+}
+function clearTokens(home, serverUrl) {
+  const store = readStore(home);
+  const entry = store[serverUrl];
+  if (!entry?.tokens && !entry?.client && !entry?.codeVerifier && !entry?.discovery) return false;
+  delete store[serverUrl];
+  writeStore(home, store);
+  return true;
+}
+function openCommand(url, platform) {
+  if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+  if (platform === "win32") return { command: "rundll32.exe", args: ["url.dll,FileProtocolHandler", url.href] };
+  return { command: platform === "darwin" ? "open" : "xdg-open", args: [url.href] };
+}
+function defaultOpen(url, deps = {}) {
+  const plan = openCommand(url, deps.platform ?? process.platform);
+  if (!plan) return;
+  const child = (deps.spawn ?? spawn)(plan.command, plan.args, { detached: true, stdio: "ignore" });
+  child.unref();
+  child.on("error", () => {
+  });
+}
+var FileOAuthProvider = class {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+   * Always defined: MCP SDK treats a missing redirectUrl as a non-interactive
+   * (client_credentials) flow and would try a token exchange without a code.
+   */
+  get redirectUrl() {
+    return this.opts.redirectUrl ?? "http://127.0.0.1:1/callback";
+  }
+  get clientMetadata() {
+    return {
+      client_name: "BCCLI",
+      redirect_uris: [String(this.redirectUrl)],
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none"
+    };
+  }
+  entry() {
+    return readStore(this.opts.home)[this.opts.serverUrl] ?? {};
+  }
+  patch(patch) {
+    const store = readStore(this.opts.home);
+    const next = { ...store[this.opts.serverUrl], ...patch };
+    for (const key of Object.keys(next)) {
+      if (next[key] === void 0) delete next[key];
+    }
+    store[this.opts.serverUrl] = next;
+    if (Object.keys(next).length === 0) delete store[this.opts.serverUrl];
+    writeStore(this.opts.home, store);
+  }
+  clientInformation() {
+    return this.entry().client;
+  }
+  saveClientInformation(clientInformation) {
+    this.patch({ client: clientInformation });
+  }
+  tokens() {
+    return this.entry().tokens;
+  }
+  saveTokens(tokens) {
+    this.patch({ tokens });
+  }
+  saveCodeVerifier(codeVerifier) {
+    this.patch({ codeVerifier });
+  }
+  codeVerifier() {
+    return this.entry().codeVerifier ?? "";
+  }
+  redirectToAuthorization(authorizationUrl) {
+    return (this.opts.open ?? defaultOpen)(authorizationUrl);
+  }
+  saveDiscoveryState(state) {
+    this.patch({ discovery: state });
+  }
+  discoveryState() {
+    return this.entry().discovery;
+  }
+  invalidateCredentials(scope) {
+    if (scope === "all") {
+      this.patch({ client: void 0, tokens: void 0, codeVerifier: void 0, discovery: void 0 });
+      return;
+    }
+    if (scope === "client") this.patch({ client: void 0 });
+    if (scope === "tokens") this.patch({ tokens: void 0 });
+    if (scope === "verifier") this.patch({ codeVerifier: void 0 });
+    if (scope === "discovery") this.patch({ discovery: void 0 });
+  }
+};
+function parseCallback(input) {
+  const url = typeof input === "string" ? new URL(input) : input;
+  const error = url.searchParams.get("error");
+  if (error) {
+    const description = url.searchParams.get("error_description");
+    throw new Error(description ? `OAuth ${error}: ${description}` : `OAuth ${error}`);
+  }
+  const code = url.searchParams.get("code");
+  if (!code) throw new Error("OAuth callback is missing the code parameter.");
+  const state = url.searchParams.get("state") ?? void 0;
+  return { code, state };
+}
+var CALLBACK_TIMEOUT_MS = 18e4;
+async function authorizeMcpServer(spec, deps) {
+  let settle;
+  const codeReceived = new Promise((resolve, reject) => {
+    settle = { resolve, reject };
+  });
+  codeReceived.catch(() => {
+  });
+  const server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== "/callback") {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+    try {
+      const { code } = parseCallback(url);
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      res.end("<html><body><p>BCCLI is connected. You can close this tab.</p></body></html>");
+      settle.resolve(code);
+    } catch (error) {
+      const escaped = error.message.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+      res.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+      res.end(`<html><body><p>${escaped}</p></body></html>`);
+      settle.reject(error);
+    }
+  });
+  const port = await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      resolve(typeof address === "object" && address ? address.port : 0);
+    });
+  });
+  try {
+    const provider = new FileOAuthProvider({
+      home: deps.home,
+      serverUrl: spec.config.url,
+      redirectUrl: `http://127.0.0.1:${port}/callback`,
+      open: deps.open
+    });
+    const serverUrl = new URL(spec.config.url);
+    const result = await auth(provider, { serverUrl, fetchFn: deps.fetchFn });
+    if (result === "AUTHORIZED") return;
+    const timer = setTimeout(() => settle.reject(new Error("Timed out waiting for the OAuth callback.")), CALLBACK_TIMEOUT_MS);
+    let code;
+    try {
+      code = await codeReceived;
+    } finally {
+      clearTimeout(timer);
+    }
+    const second = await auth(provider, { serverUrl, authorizationCode: code, fetchFn: deps.fetchFn });
+    if (second !== "AUTHORIZED") throw new Error("OAuth authorization did not complete.");
+  } finally {
+    server.close();
+  }
+}
+
+export {
+  hasStoredTokens,
+  clearTokens,
+  defaultOpen,
+  FileOAuthProvider,
+  authorizeMcpServer
+};

package/dist/chunk-YYTFJUO2.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+// src/permissions.ts
+import { isAbsolute, relative, resolve } from "path";
+var MODE_ORDER = ["default", "acceptEdits", "plan", "allowAll"];
+function nextMode(mode) {
+  return MODE_ORDER[(MODE_ORDER.indexOf(mode) + 1) % MODE_ORDER.length];
+}
+var ALWAYS_ASK_COMMANDS = /* @__PURE__ */ new Set(["sudo", "sh", "bash", "zsh", "su"]);
+function isAlwaysAsk(segment) {
+  const words = segment.trim().split(/\s+/);
+  const first = words[0] ?? "";
+  if (ALWAYS_ASK_COMMANDS.has(first)) return true;
+  const flags = words.slice(1).filter((w) => w.startsWith("-"));
+  if (first === "rm" && flags.some((w) => w.includes("r"))) return true;
+  if (first === "chmod" && flags.some((w) => w.includes("R"))) return true;
+  if (first === "kill" && words.slice(1).includes("-9")) return true;
+  if (first === "git" && words[1] === "push") {
+    return words.slice(2).some((w) => w === "-f" || w === "--force" || w.startsWith("--force="));
+  }
+  return false;
+}
+var RUNNER_COMMANDS = /* @__PURE__ */ new Set([
+  "npm",
+  "npx",
+  "pnpm",
+  "pnpx",
+  "yarn",
+  "bun",
+  "bunx",
+  "deno",
+  "node",
+  "tsx",
+  "ts-node",
+  "python",
+  "python3",
+  "py",
+  "uv",
+  "uvx",
+  "pip",
+  "pip3",
+  "pipx",
+  "pytest",
+  "make",
+  "cargo",
+  "go",
+  "dotnet",
+  "java",
+  "ruby",
+  "bundle",
+  "rake",
+  "gradle",
+  "mvn",
+  "php",
+  "composer"
+]);
+function commandKey(segment) {
+  const words = segment.trim().split(/\s+/);
+  if (RUNNER_COMMANDS.has(words[0] ?? "") && words[2] && !words[2].startsWith("-")) return words.slice(0, 3).join(" ");
+  return words[1] ? `${words[0]} ${words[1]}` : words[0];
+}
+function requiresSensitiveToolApproval(req) {
+  const target = req.target.trim();
+  if (req.kind === "read" || req.kind === "edit") {
+    return /(?:^|[\s/\\])(?:\.env(?:\.[^\s/\\]+)?|\.ssh|\.aws|\.config[/\\]gcloud|\.npmrc|\.netrc|\.git-credentials|(?:secrets?|credentials?)(?:\.[a-z0-9_-]+)?)(?:[\s/\\]|$)/i.test(
+      target
+    ) || /(?:id_rsa|id_ed25519|\.pem|\.p12|\.key)(?:\s|$)/i.test(target);
+  }
+  if (req.kind === "bash") {
+    return /\b(?:rm\s+-[a-z]*r[a-z]*f[a-z]*\s|rm\s+-[a-z]*f[a-z]*r[a-z]*\s|mkfs(?:\.|\s)|wipefs\b|shred\s|git\s+push\s+(?:--force|-f)\b|docker\s+(?:system\s+prune|volume\s+rm)|kubectl\s+delete\b|drop\s+(?:database|table)|npm\s+publish\b)/i.test(target) || /\b(?:deploy-service\.sh|aws\s+secretsmanager|cat\s+[^;&|]*\.env\b)/i.test(target);
+  }
+  if (req.kind === "mcp") {
+    return /(?:delete|remove|revoke|transfer|send_email|publish|deploy|execute_command|run_command|read_secret)/i.test(req.tool);
+  }
+  return false;
+}
+var Permissions = class {
+  constructor(mode, rules = [], cwd = process.cwd()) {
+    this.mode = mode;
+    this.cwd = cwd;
+    this.rules = new Set(rules);
+    this.configRules = new Set(rules);
+  }
+  mode;
+  cwd;
+  rules;
+  configRules;
+  /** Edits may only be auto-allowed inside the project and outside .git. */
+  editInProject(target) {
+    const rel = relative(this.cwd, resolve(this.cwd, target));
+    if (!rel || rel.startsWith("..") || isAbsolute(rel)) return false;
+    const parts = rel.split(/[/\\]/).map((p) => p.toLowerCase());
+    return !parts.includes(".git");
+  }
+  /** Rules that "[a] allow for this session" would add; undefined when it must always be asked. */
+  rulesFor(req) {
+    if (requiresSensitiveToolApproval(req) && (req.kind === "read" || req.kind === "edit" || process.env.BC_TOOL_POLICY_ENFORCE === "true"))
+      return void 0;
+    if (req.kind === "edit") return this.editInProject(req.target) ? ["edit(project)"] : void 0;
+    if (req.kind === "fetch") {
+      try {
+        return [`fetch(${new URL(req.target).hostname})`];
+      } catch {
+        return void 0;
+      }
+    }
+    if (req.kind === "bash") {
+      if (/`|\$\(|[<>]|^\s*[({]/.test(req.target)) return void 0;
+      const segments = req.target.split(/&&|\|\||[;&|\n]/).map((s) => s.trim()).filter(Boolean);
+      if (!segments.length) return void 0;
+      if (segments.some((s) => /^[({]/.test(s) || isAlwaysAsk(s))) return void 0;
+      return [...new Set(segments.map((s) => `bash(${commandKey(s)})`))];
+    }
+    if (req.kind === "mcp") return [`mcp(${req.tool})`];
+    return [];
+  }
+  check(req) {
+    if (this.mode === "plan" && req.kind !== "read") return "deny";
+    if ((req.kind === "read" || req.kind === "edit") && this.mode !== "allowAll" && requiresSensitiveToolApproval(req))
+      return "ask";
+    if (process.env.BC_TOOL_POLICY_ENFORCE === "true" && requiresSensitiveToolApproval(req)) return "ask";
+    if (req.kind === "read") return "allow";
+    if (this.mode === "allowAll") return "allow";
+    if (this.mode === "plan") return "deny";
+    if (this.rules.has(req.kind)) return "allow";
+    const needed = this.rulesFor(req);
+    if (!needed) return "ask";
+    if (req.kind === "edit" && this.mode === "acceptEdits") return "allow";
+    return needed.every((rule) => this.rules.has(rule)) ? "allow" : "ask";
+  }
+  list() {
+    return [...this.rules].map((rule) => ({ rule, source: this.configRules.has(rule) ? "config" : "session" }));
+  }
+  /** Removes a session grant; rules from config/flags stay until the user edits them. */
+  revoke(rule) {
+    if (!this.configRules.has(rule)) this.rules.delete(rule);
+  }
+  allowForSession(req) {
+    for (const rule of this.rulesFor(req) ?? []) this.rules.add(rule);
+  }
+};
+
+export {
+  MODE_ORDER,
+  nextMode,
+  requiresSensitiveToolApproval,
+  Permissions
+};