@botconnector/bccli 0.4.0-beta.5 → 0.4.0-beta.51

package/README.md

@@ -1,10 +1,20 @@
 # BCCLI
 
-Agent AI coding dari BotConnector yang bekerja di terminal: membaca kode, mengedit file,
+[![npm](https://img.shields.io/npm/v/@botconnector/bccli?label=@botconnector/bccli)](https://www.npmjs.com/package/@botconnector/bccli)
+[![npm downloads](https://img.shields.io/npm/dm/@botconnector/bccli)](https://www.npmjs.com/package/@botconnector/bccli)
+[![Node.js](https://img.shields.io/node/v/@botconnector/bccli)](https://nodejs.org/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Website](https://img.shields.io/badge/website-botconnector.id-06305A)](https://botconnector.id/id/download)
+
+Agent AI coding dari [BotConnector](https://botconnector.id/) yang bekerja di terminal: membaca kode, mengedit file,
 dan menjalankan perintah — dengan izin kamu.
 
+![BCCLI membuat hello.js dan menjalankannya dengan node](docs/demo.gif)
+
+*Rekaman sesi asli: BCCLI membuat file `hello.js` lalu menjalankannya dengan `node`.*
+
 ```bash
-npm i -g @botconnector/bccli@next    # v0.2 beta, butuh Node.js 22+
+npm i -g @botconnector/bccli@next    # beta terbaru, butuh Node.js 22+
 bccli login                     # simpan API key BotConnector Cloud
 cd project-kamu && bccli
 ```
@@ -15,8 +25,10 @@ cd project-kamu && bccli
 |---|---|
 | `bccli` | mode interaktif |
 | `bccli -p "tugas"` | satu tugas tanpa interaksi (skrip/CI) |
+| `bccli -p "tugas" --output-format json` | hasil akhir sebagai satu objek JSON; `stream-json` = event JSONL per tahap (tool_use/tool_result/message/result) untuk CI |
 | `bccli -c` / `bccli -r` | lanjutkan sesi terakhir / pilih sesi |
 | `bccli -m provider/model` | pilih model |
+| `bccli --reasoning <auto|off|low|medium|high|max>` | pilih level reasoning untuk invocation ini |
 | `bccli models` | daftar model |
 
 Perintah di dalam sesi (ketik `/` untuk saran, ↑↓ pilih, Enter jalankan):
@@ -25,7 +37,9 @@ Perintah di dalam sesi (ketik `/` untuk saran, ↑↓ pilih, Enter jalankan):
 |---|---|
 | `/help` | daftar perintah dan pintasan |
 | `/model` | ganti model |
+| `/reasoning` | pilih Auto / Off / Low / Medium / High / Max |
 | `/provider` | tambah/pilih provider AI |
+| `/language` | ganti bahasa tampilan (`en` / `id`) |
 | `/mcp` | pasang/kelola server MCP |
 | `/new` | sesi baru (sesi lama tetap tersimpan) |
 | `/resume` | lanjutkan sesi lain di folder ini |
@@ -54,6 +68,19 @@ Shift+Tab ganti mode izin: `default` → `acceptEdits` → `plan` → `allowAll`
 Mode `-p` tidak pernah bertanya: alat yang butuh izin ditolak, kecuali memakai
 `--allow-all` atau `--allowed-tools bash,edit,fetch`.
 
+## Bahasa
+
+Tampilan BCCLI (bantuan, pesan, prompt izin) memakai **bahasa Inggris secara default**. Bahasa Indonesia tetap tersedia:
+
+```bash
+bccli --lang id          # hanya untuk satu kali jalan
+BCCLI_LANG=id bccli      # lewat environment
+/language id             # di dalam sesi; disimpan di ~/.bccli/config.json ("language")
+```
+
+Urutan prioritas: `--lang`, lalu `BCCLI_LANG`, lalu `language` di config, lalu Inggris. Bahasa jawaban model mengikuti bahasa yang kamu tulis, dan
+pesan alat yang dibaca model (hasil tool, galat) selalu berbahasa Inggris supaya tidak mengganggu bahasa jawabannya.
+
 ## Provider
 
 `/provider` di dalam sesi (atau `bccli provider add <id>`) memasang provider hanya dengan API key:
@@ -76,10 +103,64 @@ Provider lain yang OpenAI-compatible: pilih **Custom…** di `/provider`, atau
 `/model` menampilkan model dari **semua** provider yang sudah punya key, dikelompokkan
 per provider; ketik untuk menyaring. Pilihan tersimpan sebagai default.
 
+Reasoning dapat dipilih lewat `bccli --reasoning <auto|off|low|medium|high|max>` atau `/reasoning`.
+**Auto** memakai default model/provider dan BCCLI tidak mengirim override reasoning apa pun. BCCLI tidak
+otomatis menurunkan atau menaikkan reasoning effort. Level manual diteruskan bila kontrak provider/model
+mendukungnya; level yang tidak didukung menghasilkan error yang jelas dan tidak di-downgrade diam-diam.
+
 `.bccli/config.json` di dalam project hanya boleh memilih `model` dan menambah provider baru tanpa API key —
+preference `reasoning` hanya dibaca dari config user `~/.bccli/config.json`, bukan dari repo yang di-clone —
 izin (`permissionMode`, `allow`) dan provider yang sudah ada hanya diatur dari `~/.bccli/config.json`,
 supaya repo yang kamu clone tidak bisa memberi dirinya izin penuh atau mencuri API key.
 
+## Integrasi agent eksternal
+
+BCCLI dapat memasang BotConnector sebagai provider untuk agent lain:
+
+| Perintah | Fungsi |
+|---|---|
+| `bccli integrations` | lihat status integrasi |
+| `bccli connect opencode` | hubungkan OpenCode ke BotConnector |
+| `bccli connect aider` | hubungkan Aider ke BotConnector |
+| `bccli connect cline` | hubungkan Cline CLI ke BotConnector |
+| `bccli connect deepseek-harness` / `bccli connect dsh` | hubungkan DeepSeek Harness ke BotConnector |
+| `bccli connect codex` | buat profile Codex Responses API + launcher BotConnector |
+| `bccli connect claude-code` | buat launcher Claude Code via Anthropic Messages compatibility |
+| `bccli connect cursor` | buat guided setup Cursor + warning override Base URL |
+| `bccli connect openai-cli` | buat launcher OpenAI CLI khusus BotConnector |
+| `bccli connect openai-sdk` | buat env profile untuk OpenAI Python/Node SDK |
+| `bccli connect openai-compatible` | buat env profile universal OpenAI-compatible |
+| `bccli disconnect <agent>` | pulihkan config sebelum integrasi |
+
+OpenCode memakai config global `~/.config/opencode/opencode.json`. BCCLI mengambil katalog model BotConnector saat connect,
+menjaga config provider lain, dan menyimpan secret di file terpisah di `~/.bccli/integrations/`.
+Aider memakai `~/.aider.conf.yml` yang menunjuk ke env file BCCLI terpisah; BCCLI menolak menimpa setting
+OpenAI/env-file Aider yang sudah ada.
+
+Cline memakai provider `openai-compatible` di `~/.cline/data/settings/providers.json`. Jika slot itu sudah dipakai
+endpoint lain, BCCLI menolak menimpanya. Cline sendiri menyimpan API key provider di file tersebut.
+
+DeepSeek Harness memakai custom provider `botconnector` di `$DSH_HOME/settings.yaml` dengan
+`api: openai-completions` dan `apiKeyEnv: BOTCONNECTOR_API_KEY`; key diletakkan pada blok BCCLI di
+`$DSH_HOME/.env`. Provider DSH lain tetap dipertahankan. Setelah connect, jalankan profile web dengan
+`dsh web` (setara dengan `dsh --profile web`); `dsh` tanpa profile memang ditolak oleh DSH 0.1.x.
+
+Codex memakai profile `$CODEX_HOME/botconnector.config.toml` dengan `wire_api = "responses"` dan launcher
+BCCLI yang membaca key dari storage BCCLI saat dijalankan. Claude Code memakai launcher terisolasi dengan
+`ANTHROPIC_BASE_URL=https://api.botconnector.id` dan endpoint kompatibilitas `/v1/messages` + token counting.
+Login/config utama Codex dan Claude Code tidak ditimpa.
+
+External agent memanggil BotConnector langsung, jadi discovery model tidak memakai identitas khusus BCCLI.
+Akses yang memang dibatasi ke BCCLI/Web App (misalnya Luna launch access) tidak otomatis diwariskan.
+Sebelum mengubah config eksternal, BCCLI membuat backup agar disconnect dapat memulihkannya.
+
+## Internet
+
+- `web_search`: mencari di web tanpa perlu izin. Memakai akun BotConnector Cloud
+  bila ada key, kalau tidak langsung ke Keenable (gratis, tanpa key). Hasilnya
+  judul, URL, dan cuplikan singkat, jadi hemat token.
+- `fetch`: membuka satu URL dari komputer ini (butuh izin per host).
+
 ## MCP
 
 `/mcp` (atau `bccli mcp add <nama>`) memasang server dari katalog:
@@ -89,6 +170,14 @@ seperti Claude Code). Semua alat MCP selalu minta izin.
 
 `.bccli/mcp.json` di dalam repo tidak dijalankan sebelum kamu setujui (ditanya sekali per folder).
 
+`bccli mcp serve` menjalankan MCP server stdio dengan tools BotConnector milikmu
+(`bc_search`, `bc_fetch`, `bc_models`, `bc_chat`) untuk dipakai Claude Code, Cursor,
+opencode, dan host MCP lain. Butuh `bccli login` (atau `BOTCONNECTOR_API_KEY`):
+
+```bash
+claude mcp add botconnector -- npx -y @botconnector/bccli mcp serve
+```
+
 ## Subagent
 
 Agent bisa mendelegasikan pekerjaan lewat alat `task`:
@@ -130,3 +219,9 @@ npm test && npm run typecheck && npm run lint && npm run build
 CI (`ci.yml`) menjalankan hal yang sama di Linux, macOS, dan Windows.
 Rilis: naikkan `version` di `package.json`, lalu push tag `v<version>` — `release.yml`
 menjalankan test, smoke test ke BotConnector Cloud, dan `npm publish --provenance`.
+
+## Pelajari lebih lanjut
+
+- [Unduh & panduan BCCLI](https://botconnector.id/id/download)
+- [Developer API BotConnector](https://botconnector.id/id/developers/api) — endpoint kompatibel OpenAI SDK
+- [Switchboard](https://github.com/farijarifriyanto-debug/switchboard) — harness agent open source dari BotConnector

package/dist/acp-NWP4FFTG.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+// src/acp.ts
+var ACP_PROTOCOL_VERSION = 1;
+var TOOL_KINDS = {
+  read: "read",
+  repo_map: "read",
+  edit: "edit",
+  write: "edit",
+  grep: "search",
+  glob: "search",
+  bash: "execute",
+  powershell: "execute",
+  fetch: "fetch",
+  web_search: "fetch"
+};
+var kindOf = (tool) => TOOL_KINDS[tool] ?? "other";
+var titleOf = (tool, target) => (target ? `${tool}: ${target}` : tool).slice(0, 200);
+var MAX_OUTPUT = 4e3;
+var PERMISSION_OPTIONS = [
+  { optionId: "allow", name: "Allow", kind: "allow_once" },
+  { optionId: "allow_session", name: "Allow for this session", kind: "allow_always" },
+  { optionId: "reject", name: "Reject", kind: "reject_once" }
+];
+var ANSWERS = { allow: "yes", allow_session: "session", reject: "no" };
+function runAcp(input, output, opts) {
+  const sessions = /* @__PURE__ */ new Map();
+  const awaiting = /* @__PURE__ */ new Map();
+  let nextSession = 1;
+  let nextRequest = 1;
+  const write = (msg) => {
+    output.write(`${JSON.stringify(msg)}
+`);
+  };
+  const reply = (id, result) => write({ jsonrpc: "2.0", id, result });
+  const replyError = (id, code, message) => write({ jsonrpc: "2.0", id, error: { code, message } });
+  const update = (sessionId, body) => write({ jsonrpc: "2.0", method: "session/update", params: { sessionId, update: body } });
+  const ioFor = (sid, session) => ({
+    toolStart(id, tool, target) {
+      session.open.push({ id, tool, target });
+      update(sid, { sessionUpdate: "tool_call", toolCallId: id, title: titleOf(tool, target), kind: kindOf(tool), status: "in_progress", rawInput: { target } });
+    },
+    toolEnd(id, output2, isError) {
+      session.open = session.open.filter((c) => c.id !== id);
+      const text = output2.length > MAX_OUTPUT ? `${output2.slice(0, MAX_OUTPUT)}
+[truncated]` : output2;
+      update(sid, {
+        sessionUpdate: "tool_call_update",
+        toolCallId: id,
+        status: isError ? "failed" : "completed",
+        ...text ? { content: [{ type: "content", content: { type: "text", text } }] } : {}
+      });
+    },
+    askPermission(req) {
+      return new Promise((resolve) => {
+        const requestId = nextRequest++;
+        const call = [...session.open].reverse().find((c) => c.tool === req.tool && c.target === req.target);
+        const settle = (answer) => {
+          session.pending.delete(settle);
+          awaiting.delete(requestId);
+          resolve(answer);
+        };
+        session.pending.add(settle);
+        awaiting.set(requestId, (message) => {
+          const outcome = message.result?.outcome;
+          settle(outcome?.outcome === "selected" ? ANSWERS[outcome.optionId ?? ""] ?? "no" : "no");
+        });
+        write({
+          jsonrpc: "2.0",
+          id: requestId,
+          method: "session/request_permission",
+          params: {
+            sessionId: sid,
+            toolCall: { toolCallId: call?.id ?? `permission-${requestId}`, title: titleOf(req.tool, req.target), kind: kindOf(req.tool), status: "pending" },
+            options: PERMISSION_OPTIONS
+          }
+        });
+      });
+    }
+  });
+  const handle = async (msg) => {
+    const { id, method, params } = msg ?? {};
+    if (method === void 0 && id !== void 0 && (msg.result !== void 0 || msg.error !== void 0)) {
+      awaiting.get(id)?.(msg);
+      return;
+    }
+    if (method === "initialize") {
+      return reply(id, {
+        protocolVersion: ACP_PROTOCOL_VERSION,
+        agentCapabilities: {
+          loadSession: false,
+          promptCapabilities: { image: false, audio: false, embeddedContext: false }
+        }
+      });
+    }
+    if (method === "session/new") {
+      const sessionId = `s${nextSession++}`;
+      sessions.set(sessionId, { controller: null, pending: /* @__PURE__ */ new Set(), open: [] });
+      return reply(id, { sessionId });
+    }
+    if (method === "session/cancel") {
+      const session = sessions.get(params?.sessionId ?? "");
+      session?.controller?.abort();
+      for (const settle of [...session?.pending ?? []]) settle("no");
+      return;
+    }
+    if (method === "session/prompt") {
+      const sid = params?.sessionId ?? "";
+      const session = sessions.get(sid);
+      if (!session) return replyError(id, -32602, "Unknown session");
+      const text = (params?.prompt ?? []).filter((p) => p?.type === "text").map((p) => String(p.text ?? "")).join("\n");
+      const controller = new AbortController();
+      session.controller = controller;
+      let cancelled = false;
+      controller.signal.addEventListener("abort", () => {
+        cancelled = true;
+      });
+      try {
+        session.agent ??= opts.newAgent(params?.cwd ?? opts.cwd);
+        await session.agent.run(text, (chunk) => update(sid, { sessionUpdate: "agent_message_chunk", content: { type: "text", text: chunk } }), controller.signal, ioFor(sid, session));
+      } catch (e) {
+        if (cancelled) return reply(id, { stopReason: "cancelled" });
+        return replyError(id, -32603, e.message);
+      } finally {
+        session.controller = null;
+        session.open = [];
+      }
+      return reply(id, { stopReason: cancelled ? "cancelled" : "end_turn" });
+    }
+    if (id !== void 0) return replyError(id, -32601, "Method not found");
+  };
+  return new Promise((resolve) => {
+    let buf = "";
+    const onData = (chunk) => {
+      buf += chunk.toString();
+      let idx = buf.indexOf("\n");
+      while (idx >= 0) {
+        const line = buf.slice(0, idx);
+        buf = buf.slice(idx + 1);
+        idx = buf.indexOf("\n");
+        if (!line.trim()) continue;
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        void handle(msg);
+      }
+    };
+    const onEnd = () => {
+      input.removeListener("data", onData);
+      resolve();
+    };
+    input.on("data", onData);
+    input.on("end", onEnd);
+  });
+}
+function runtimeAgent(cwd, allowAll = false) {
+  let rt;
+  return {
+    async run(text, onChunk, signal, io) {
+      if (!rt) {
+        const { parseCliArgs } = await import("./args-2R45YZ42.js");
+        const { createRuntime } = await import("./setup-LLWREJQH.js");
+        rt = createRuntime({ cwd, args: { ...parseCliArgs([]), allowAll } });
+      }
+      if (io && !allowAll) rt.agent.askPermission = (req) => io.askPermission(req);
+      rt.agent.onEvent = (event) => {
+        if (event.type === "text") onChunk(event.delta);
+        else if (event.type === "toolStart") io?.toolStart(event.id, event.tool, event.target);
+        else if (event.type === "toolEnd") io?.toolEnd(event.id, event.output, event.isError);
+      };
+      await rt.agent.run(text, signal);
+    }
+  };
+}
+export {
+  ACP_PROTOCOL_VERSION,
+  runAcp,
+  runtimeAgent
+};

package/dist/args-2R45YZ42.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  helpText,
+  parseCliArgs
+} from "./chunk-FTFVW7XD.js";
+import "./chunk-GAFJEQTJ.js";
+import "./chunk-SNKVS26H.js";
+import "./chunk-NDEJUL44.js";
+import "./chunk-XLC6T4SX.js";
+export {
+  helpText,
+  parseCliArgs
+};

package/dist/{chunk-U7DLMVPZ.js → chunk-2QYHSESB.js}

@@ -5,7 +5,7 @@ import {
   readCredentials,
   readJsonConfig,
   removeCredential
-} from "./chunk-RZUJYAQV.js";
+} from "./chunk-NDEJUL44.js";
 
 // src/providers.ts
 import { mkdirSync, writeFileSync } from "fs";
@@ -45,6 +45,7 @@ function removeGlobalProvider(id, env = process.env) {
 export {
   providerName,
   hasKey,
+  readGlobalConfigFile,
   writeGlobalConfig,
   removeGlobalProvider
 };

package/dist/{chunk-UESQNU4A.js → chunk-4WVIPZFV.js}

@@ -1,23 +1,28 @@
 #!/usr/bin/env node
 import {
   ConfigError
-} from "./chunk-RZUJYAQV.js";
+} from "./chunk-NDEJUL44.js";
+import {
+  t
+} from "./chunk-XLC6T4SX.js";
 
 // src/mcp/catalog.ts
 var CATALOG = [
-  { name: "playwright", description: "kontrol browser (buka halaman, klik, isi form, screenshot)", config: { command: "npx", args: ["-y", "@playwright/mcp@latest"] } },
-  { name: "context7", description: "dokumentasi library terbaru", config: { type: "http", url: "https://mcp.context7.com/mcp" } },
-  { name: "fetch", description: "ambil halaman web jadi markdown (butuh uv)", config: { command: "uvx", args: ["mcp-server-fetch"] } },
+  { name: "playwright", description: "control a browser (open pages, click, fill forms, screenshot)", config: { command: "npx", args: ["-y", "@playwright/mcp@latest"] } },
+  { name: "context7", description: "up-to-date library documentation", config: { type: "http", url: "https://mcp.context7.com/mcp" } },
+  { name: "fetch", description: "fetch web pages as markdown (needs uv)", config: { command: "uvx", args: ["mcp-server-fetch"] } },
   {
     name: "filesystem",
-    description: "akses folder di luar project",
+    description: "access folders outside the project",
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: ${dir} is filled by fillTemplate, not a template literal
     config: { command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "${dir}"] },
-    inputs: [{ key: "dir", label: "Folder yang boleh diakses" }]
+    inputs: [{ key: "dir", label: "Folder the server may access" }]
   },
-  { name: "git", description: "operasi git terstruktur (butuh uv)", config: { command: "uvx", args: ["mcp-server-git"] } },
+  { name: "git", description: "structured git operations (needs uv)", config: { command: "uvx", args: ["mcp-server-git"] } },
   {
     name: "github",
-    description: "issue, PR, dan repo GitHub",
+    description: "GitHub issues, PRs, and repos",
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: ${token} is filled by fillTemplate, not a template literal
     config: { type: "http", url: "https://api.githubcopilot.com/mcp/", headers: { Authorization: "Bearer ${token}" } },
     inputs: [{ key: "token", label: "GitHub Personal Access Token", secret: true }]
   }
@@ -35,7 +40,7 @@ function fillTemplate(config, values) {
     ...config.args ? { args: config.args.map(fill) } : {},
     ...config.env ? { env: mapValues(config.env) } : {}
   };
-  if (missing.size) throw new ConfigError(`Isian MCP belum lengkap: ${[...missing].join(", ")}`);
+  if (missing.size) throw new ConfigError(t("Missing MCP fields: {fields}", { fields: [...missing].join(", ") }));
   return out;
 }
 

package/dist/chunk-7F3IWBPQ.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+// src/mcp/oauth.ts
+import { spawn } from "child_process";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } 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 {
+    return {};
+  }
+}
+function writeStore(home, store) {
+  const path = oauthStorePath(home);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(store, null, 2)}
+`, { mode: 384 });
+  chmodSync(path, 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 defaultOpen(url) {
+  const target = url.href;
+  const child = process.platform === "win32" ? spawn("cmd", ["/c", "start", "", target], { detached: true, stdio: "ignore" }) : spawn(process.platform === "darwin" ? "open" : "xdg-open", [target], { 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
+};