@botconnector/bccli 0.4.0-beta.8 → 0.4.0

package/dist/chunk-BNA74HPN.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import {
+  defaultOpen
+} from "./chunk-7F3IWBPQ.js";
+import {
+  removeCredential,
+  saveCredential
+} from "./chunk-LACUWBWS.js";
+import {
+  t
+} from "./chunk-UZWJQF67.js";
+
+// src/login.ts
+function readSecret(prompt) {
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    const stdin = process.stdin;
+    if (!stdin.isTTY) {
+      let data = "";
+      stdin.on("data", (d) => {
+        data += d;
+      });
+      stdin.on("end", () => resolve(data.trim()));
+      return;
+    }
+    let value = "";
+    stdin.setRawMode(true);
+    stdin.resume();
+    const onData = (buffer) => {
+      for (const ch of buffer.toString()) {
+        if (ch === "\r" || ch === "\n") {
+          stdin.setRawMode(false);
+          stdin.pause();
+          stdin.off("data", onData);
+          process.stdout.write("\n");
+          resolve(value.trim());
+          return;
+        }
+        if (ch === "") process.exit(130);
+        if (ch === "\x7F" || ch === "\b") value = value.slice(0, -1);
+        else value += ch;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+function readLine(prompt) {
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    const stdin = process.stdin;
+    if (!stdin.isTTY) {
+      let data = "";
+      stdin.on("data", (d) => {
+        data += d;
+      });
+      stdin.on("end", () => resolve(data.trim()));
+      return;
+    }
+    let value = "";
+    stdin.setRawMode(true);
+    stdin.resume();
+    const onData = (buffer) => {
+      for (const ch of buffer.toString()) {
+        const code = ch.charCodeAt(0);
+        if (code === 13 || code === 10) {
+          stdin.setRawMode(false);
+          stdin.pause();
+          stdin.off("data", onData);
+          process.stdout.write("\n");
+          resolve(value.trim());
+          return;
+        }
+        if (code === 3) process.exit(130);
+        if (code === 127 || code === 8) value = value.slice(0, -1);
+        else value += ch;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+function defaultLoginDeps() {
+  return {
+    out: (s) => console.log(s),
+    err: (s) => console.error(s),
+    env: process.env,
+    isTTY: process.stdin.isTTY ?? false,
+    open: (url) => defaultOpen(new URL(url)),
+    readLine,
+    saveCredential: (id, key) => saveCredential(id, key, process.env),
+    removeCredential: (id) => removeCredential(id, process.env),
+    fetch: globalThis.fetch,
+    // Wiring NYATA jalur lama: persis runLogin lama (provider add + prompt key).
+    legacyAdd: async (providerId, targetCwd) => {
+      const { runProviderCommand } = await import("./providerCli-FAOZHOKW.js");
+      const { parseCliArgs: parse } = await import("./args-J5ONVGIF.js");
+      return runProviderCommand(parse(["provider", "add", providerId]), {
+        env: process.env,
+        cwd: targetCwd,
+        out: (s) => console.log(s),
+        err: (s) => console.error(s),
+        readSecret
+      });
+    }
+  };
+}
+async function runLogin(providerId, cwd, args, deps) {
+  if (args.key && args.logout) {
+    deps.err(t("Use either --key or --logout, not both."));
+    return 1;
+  }
+  if (args.logout) {
+    if (providerId !== "openrouter") {
+      deps.err(
+        t("Logout is not supported for {id}; use bccli provider remove {id} to delete its stored key and config.", {
+          id: providerId
+        })
+      );
+      return 1;
+    }
+    const { runOauthLogout } = await import("./oauthLogin-6FWQABJ7.js");
+    return runOauthLogout({ out: deps.out, err: deps.err, env: deps.env, removeCredential: deps.removeCredential });
+  }
+  if (args.key) return deps.legacyAdd(providerId, cwd);
+  if (providerId === "openrouter") {
+    const { runOauthLogin } = await import("./oauthLogin-6FWQABJ7.js");
+    return runOauthLogin({
+      out: deps.out,
+      err: deps.err,
+      env: deps.env,
+      isTTY: deps.isTTY,
+      open: deps.open,
+      readLine: deps.readLine,
+      saveCredential: deps.saveCredential,
+      fetch: deps.fetch
+    });
+  }
+  return deps.legacyAdd(providerId, cwd);
+}
+
+export {
+  readSecret,
+  readLine,
+  defaultLoginDeps,
+  runLogin
+};

package/dist/{chunk-DX7CZTBB.js → chunk-BQ2IGPBR.js}

@@ -1,23 +1,28 @@
 #!/usr/bin/env node
 import {
   ConfigError
-} from "./chunk-2MGINW4O.js";
+} from "./chunk-LACUWBWS.js";
+import {
+  t
+} from "./chunk-UZWJQF67.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-JL5ZCSP2.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import {
+  listAllModels
+} from "./chunk-XBO5GACQ.js";
+import {
+  hasKey,
+  providerName,
+  removeGlobalProvider,
+  writeGlobalConfig
+} from "./chunk-SPRNLS7K.js";
+import {
+  PRESETS,
+  loadConfig,
+  saveCredential
+} from "./chunk-LACUWBWS.js";
+import {
+  t
+} from "./chunk-UZWJQF67.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);
+  if (!preset && !config.providers[id]) {
+    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) {
+    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-KEMYIGCP.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+import {
+  MODE_ORDER
+} from "./chunk-O7M3TGIW.js";
+import {
+  REASONING_LEVELS,
+  isReasoningLevel
+} from "./chunk-BLOYFIAD.js";
+import {
+  ConfigError
+} from "./chunk-LACUWBWS.js";
+import {
+  parseLang,
+  t
+} from "./chunk-UZWJQF67.js";
+
+// src/args.ts
+import { parseArgs } from "util";
+
+// src/serveProtocol.ts
+import { randomBytes, timingSafeEqual } from "crypto";
+var MAX_FRAME_BYTES = 262144;
+function parseClientFrame(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return { error: "invalid JSON frame" };
+  }
+  const f = value;
+  if (typeof f?.streamId !== "string" || f.streamId === "") return { error: "frame requires a streamId" };
+  if (f.type === "open") {
+    if (typeof f.target !== "string" || f.target === "") return { error: "open requires a target" };
+    return { type: "open", streamId: f.streamId, target: f.target };
+  }
+  if (f.type === "cancel") return { type: "cancel", streamId: f.streamId };
+  return { error: `unknown frame type: ${String(f?.type)}` };
+}
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]", "::1"]);
+var LOOPBACK_BIND = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1"]);
+function trustFence(headers, port) {
+  const host = headers.host;
+  if (!host) return "missing Host header";
+  const sep = host.lastIndexOf(":");
+  const hostname = sep > -1 ? host.slice(0, sep) : host;
+  const hostPort = sep > -1 ? Number(host.slice(sep + 1)) : 80;
+  if (!LOOPBACK_HOSTS.has(hostname)) return `non-loopback Host: ${hostname}`;
+  if (hostPort !== port) return `Host port ${hostPort} does not match listener ${port}`;
+  if (headers.origin) {
+    let origin;
+    try {
+      origin = new URL(headers.origin);
+    } catch {
+      return "malformed Origin header";
+    }
+    const originHost = origin.hostname === "::1" ? "[::1]" : origin.hostname;
+    const originPort = origin.port ? Number(origin.port) : origin.protocol === "https:" ? 443 : 80;
+    if (!LOOPBACK_HOSTS.has(originHost)) return `cross-origin Origin: ${headers.origin}`;
+    if (originPort !== port) return "Origin port mismatch";
+  }
+  if (headers["sec-fetch-site"] === "cross-site") return "cross-site request";
+  return null;
+}
+function bearerOk(header, token) {
+  if (!header?.startsWith("Bearer ")) return false;
+  const got = Buffer.from(header.slice(7));
+  const want = Buffer.from(token);
+  return got.length === want.length && timingSafeEqual(got, want);
+}
+function randomToken() {
+  return randomBytes(32).toString("hex");
+}
+
+// src/args.ts
+var HELP = `BCCLI \u2014 BotConnector's AI coding agent for the terminal
+
+Usage:
+  bccli [task]                  interactive mode (optionally start with a task)
+  bccli -p "task"               run one task without interaction (scripts/CI)
+  bccli login [provider]        OAuth login (or --key paste API key, --logout remove)
+  bccli models [provider]       list models (default: the active provider)
+  bccli update                  install the newest bccli from npm
+  bccli acp                     run as an ACP agent for editors (Zed, ...)
+  bccli serve [--port N]        serve sessions over HTTP+WS for IDEs/bots
+  bccli plugins               list, install, remove, or update plugins
+  bccli gh-bot [serve]         GitHub comment bot (off-by-default; needs config)
+  bccli provider list|add <id>|remove <id>   manage providers (custom: --url <url> [--name N] [--key-env ENV])
+  bccli mcp list|add <name>|remove <name>|auth <name>|logout <name>|serve [--base-url <url>]    manage MCP servers, or serve this account's tools over stdio
+  bccli completion <shell>     print a shell completion script (bash, zsh, fish, powershell)
+  bccli stats [--days N] [--tools N] [--models [N|all]] [--project slug]
+                                     show token usage from local sessions (default: last 7 days)
+  bccli export [session] [file]  copy a session JSONL to a file (default: last session here)
+  bccli import <file>          import a session JSONL into the current project
+  bccli pr <number> [--repo owner/name] [task]   check out a GitHub PR and run a task on it
+  bccli integrations             show the status of external agent integrations
+  bccli connect <agent>          opencode, aider, cline, dsh, codex, claude-code, cursor, openai-cli, openai-sdk, openai-compatible, openclaw, hermes
+  bccli disconnect <agent>       remove an integration and restore the previous config
+
+Options:
+  -m, --model <provider/model>  choose a model, e.g. bc-cloud/glm-5.3-flash
+      --reasoning <level>        auto | off | low | medium | high | max
+  -c, --continue                continue the last session in this folder
+  -r, --resume                  pick a session to continue
+      --allow-all               run all tools without asking for permission
+      --allowed-tools <a,b>     tools allowed without asking: bash, edit, fetch
+  -w, --worktree <name>        run in git worktree ../<repo>.worktrees/<name> (created, or reused if it exists)
+      --output-format <fmt>     text | json | stream-json for -p (machine-readable output)
+      --permission-mode <mode>  default | acceptEdits | plan | allowAll
+      --lang <en|id>            interface language (default: en; or BCCLI_LANG, or "language" in config)
+  -v, --version                 version
+  -h, --help                    this help`;
+var helpText = () => t(HELP);
+function parseCliArgs(argv) {
+  const expanded = argv.map(
+    (a, i) => a === "--models" && (i + 1 >= argv.length || argv[i + 1].startsWith("-")) ? "--models=all" : a
+  );
+  const { values, positionals } = parseArgs({
+    args: expanded,
+    allowPositionals: true,
+    options: {
+      print: { type: "boolean", short: "p" },
+      model: { type: "string", short: "m" },
+      reasoning: { type: "string" },
+      lang: { type: "string" },
+      continue: { type: "boolean", short: "c" },
+      resume: { type: "boolean", short: "r" },
+      "allow-all": { type: "boolean" },
+      "allowed-tools": { type: "string" },
+      worktree: { type: "string", short: "w" },
+      "output-format": { type: "string" },
+      "permission-mode": { type: "string" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" },
+      url: { type: "string" },
+      name: { type: "string" },
+      "key-env": { type: "string" },
+      value: { type: "string", multiple: true },
+      key: { type: "boolean" },
+      logout: { type: "boolean" },
+      port: { type: "string" },
+      host: { type: "string" },
+      token: { type: "string" },
+      "base-url": { type: "string" },
+      days: { type: "string" },
+      tools: { type: "string" },
+      models: { type: "string" },
+      project: { type: "string" },
+      repo: { type: "string" }
+    }
+  });
+  const reasoning = values.reasoning;
+  if (reasoning && !isReasoningLevel(reasoning)) {
+    throw new ConfigError(t("--reasoning must be one of: {levels}", { levels: REASONING_LEVELS.join(", ") }));
+  }
+  const mode = values["permission-mode"];
+  if (mode && !MODE_ORDER.includes(mode)) {
+    throw new ConfigError(t("--permission-mode must be one of: {modes}", { modes: MODE_ORDER.join(", ") }));
+  }
+  if (values.lang !== void 0 && !parseLang(values.lang)) throw new ConfigError(t("--lang must be one of: en, id"));
+  const outputFormat = values["output-format"];
+  if (outputFormat !== void 0 && !["text", "json", "stream-json"].includes(outputFormat)) {
+    throw new ConfigError(t("--output-format must be one of: {formats}", { formats: "text, json, stream-json" }));
+  }
+  const [first, ...rest] = positionals;
+  const SUBCOMMANDS = ["login", "models", "update", "acp", "serve", "plugins", "gh-bot", "provider", "mcp", "connect", "disconnect", "integrations", "completion", "stats", "export", "import", "pr"];
+  const command = SUBCOMMANDS.includes(first) ? first : "run";
+  const words = command === "run" ? positionals : rest;
+  const port = values.port !== void 0 ? Number(values.port) : void 0;
+  if (port !== void 0 && (!Number.isInteger(port) || port < 0 || port > 65535)) {
+    throw new ConfigError(t("--port must be a number between 0 and 65535"));
+  }
+  const days = values.days !== void 0 ? Number(values.days) : void 0;
+  if (days !== void 0 && (!Number.isInteger(days) || days < 1)) {
+    throw new ConfigError(t("--days must be a positive integer"));
+  }
+  const tools = values.tools !== void 0 ? Number(values.tools) : void 0;
+  if (tools !== void 0 && (!Number.isInteger(tools) || tools < 1)) {
+    throw new ConfigError(t("--tools must be a positive integer"));
+  }
+  let models;
+  if (values.models !== void 0) {
+    models = values.models === "" || values.models === "all" ? "all" : values.models;
+    if (models !== "all" && (!Number.isInteger(Number(models)) || Number(models) < 1)) {
+      throw new ConfigError(t('--models must be a positive integer or "all"'));
+    }
+  }
+  if (values.host !== void 0 && !LOOPBACK_BIND.has(values.host)) {
+    throw new ConfigError(t("serve only accepts loopback --host (127.0.0.1, localhost, ::1)"));
+  }
+  return {
+    command,
+    prompt: command === "run" && words.length ? words.join(" ") : void 0,
+    print: !!values.print,
+    model: values.model,
+    reasoning,
+    lang: parseLang(values.lang),
+    continue: !!values.continue,
+    resume: !!values.resume,
+    allowAll: !!values["allow-all"],
+    allowedTools: (values["allowed-tools"] ?? "").split(",").map((s) => s.trim()).filter(Boolean),
+    worktree: values.worktree,
+    outputFormat,
+    permissionMode: mode,
+    help: !!values.help,
+    version: !!values.version,
+    loginProvider: command === "login" ? rest[0] ?? "bc-cloud" : void 0,
+    key: !!values.key,
+    logout: !!values.logout,
+    subArgs: ["models", "plugins", "gh-bot", "provider", "mcp", "connect", "disconnect", "integrations", "completion", "stats", "export", "import", "pr"].includes(command) ? rest : [],
+    url: values.url,
+    name: values.name,
+    keyEnv: values["key-env"],
+    values: values.value ?? [],
+    port,
+    host: values.host,
+    token: values.token,
+    baseUrl: values["base-url"],
+    days,
+    tools,
+    models,
+    project: values.project,
+    repo: values.repo
+  };
+}
+
+export {
+  MAX_FRAME_BYTES,
+  parseClientFrame,
+  LOOPBACK_BIND,
+  trustFence,
+  bearerOk,
+  randomToken,
+  helpText,
+  parseCliArgs
+};

package/dist/{chunk-BFZXRKW5.js → chunk-L7QI6JN2.js}

@@ -1,12 +1,33 @@
 #!/usr/bin/env node
 import {
   ConfigError
-} from "./chunk-2MGINW4O.js";
+} from "./chunk-LACUWBWS.js";
+import {
+  t
+} from "./chunk-UZWJQF67.js";
 
 // src/mcp/config.ts
 import { createHash } from "crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } 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");
@@ -15,7 +36,7 @@ function readJson(path, fallback) {
   try {
     return JSON.parse(readFileSync(path, "utf8"));
   } catch (error) {
-    throw new ConfigError(`File MCP tidak valid: ${path} (${error.message})`);
+    throw new ConfigError(t("Invalid MCP file: {path} ({error})", { path, error: error.message }));
   }
 }
 function writePrivate(path, data) {
@@ -58,6 +79,7 @@ function serversToStart(home, cwd) {
 }
 
 export {
+  expandEnvVars,
   globalMcpPath,
   projectMcpPath,
   readMcpFile,