@botconnector/bccli 0.4.0-beta.9 → 0.4.1

package/dist/chunk-MFHCQQEN.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+import {
+  quarantineCorruptFile,
+  writeFileAtomic
+} from "./chunk-FLQPE4S5.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) {
+      res.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+      res.end(`<html><body><p>${error.message}</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-MHIYLXJC.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+// src/permissions.ts
+import { isAbsolute, relative, resolve, sep } 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 /(?:^|[/\\])(?:\.env(?:\..*)?|\.ssh|\.aws|\.config\/gcloud|secrets?|credentials?)(?:[/\\]|$)/i.test(target) || /(?:id_rsa|id_ed25519|\.pem|\.p12|\.key)$/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;
+    return !rel.split(sep).includes(".git") && !rel.split("/").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" || 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(isAlwaysAsk)) 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" && 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,
+  Permissions
+};

package/dist/chunk-PSO7R5AD.js

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