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

package/README.md

@@ -4,7 +4,7 @@ Agent AI coding dari BotConnector yang bekerja di terminal: membaca kode, menged
 dan menjalankan perintah — dengan izin kamu.
 
 ```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 +15,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 +27,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 +58,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 +93,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 +160,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`:

package/dist/acp-V5RP42VB.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+// src/acp.ts
+var ACP_PROTOCOL_VERSION = 1;
+function runAcp(input, output, opts) {
+  const sessions = /* @__PURE__ */ new Map();
+  let nextSession = 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 handle = async (msg) => {
+    const { id, method, params } = msg ?? {};
+    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 });
+      return reply(id, { sessionId });
+    }
+    if (method === "session/cancel") {
+      sessions.get(params?.sessionId ?? "")?.controller?.abort();
+      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 {
+        const agent = opts.newAgent(params?.cwd ?? opts.cwd);
+        await agent.run(
+          text,
+          (chunk) => {
+            write({
+              jsonrpc: "2.0",
+              method: "session/update",
+              params: {
+                sessionId: sid,
+                update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: chunk } }
+              }
+            });
+          },
+          controller.signal
+        );
+      } catch (e) {
+        return replyError(id, -32603, e.message);
+      } finally {
+        session.controller = null;
+      }
+      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) {
+  return {
+    async run(text, onChunk, signal) {
+      const { parseCliArgs } = await import("./args-2R45YZ42.js");
+      const { createRuntime } = await import("./setup-LLWREJQH.js");
+      const rt = createRuntime({ cwd, args: { ...parseCliArgs([]), allowAll: true } });
+      rt.agent.onEvent = (event) => {
+        if (event.type === "text") onChunk(event.delta);
+      };
+      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
+};