@botconnector/bccli 0.4.0-beta.9 → 0.4.1

package/dist/update-TZ2G6KQ3.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import {
+  VERSION
+} from "./chunk-BKGFA2PT.js";
+import {
+  t
+} from "./chunk-UZWJQF67.js";
+
+// src/update.ts
+import { spawnSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var REGISTRY_URL = "https://registry.npmjs.org/-/package/@botconnector/bccli/dist-tags";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function splitVersion(v) {
+  const i = v.indexOf("-");
+  const coreStr = i < 0 ? v : v.slice(0, i);
+  const preStr = i < 0 ? "" : v.slice(i + 1);
+  return {
+    core: coreStr.split(".").map((p) => Number.parseInt(p, 10) || 0),
+    pre: preStr ? preStr.split(".") : []
+  };
+}
+function compareVersions(a, b) {
+  const A = splitVersion(a);
+  const B = splitVersion(b);
+  for (let i = 0; i < Math.max(A.core.length, B.core.length); i++) {
+    const x = A.core[i] ?? 0;
+    const y = B.core[i] ?? 0;
+    if (x !== y) return x < y ? -1 : 1;
+  }
+  if (!A.pre.length && !B.pre.length) return 0;
+  if (!A.pre.length) return 1;
+  if (!B.pre.length) return -1;
+  for (let i = 0; i < Math.max(A.pre.length, B.pre.length); i++) {
+    const x = A.pre[i];
+    const y = B.pre[i];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    const nx = Number.parseInt(x, 10);
+    const ny = Number.parseInt(y, 10);
+    if (String(nx) === x && String(ny) === y) {
+      if (nx !== ny) return nx < ny ? -1 : 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function channelFor(version) {
+  return version.includes("-") ? "next" : "latest";
+}
+function cachePath(home) {
+  return join(home, "update-check.json");
+}
+function readCache(home) {
+  try {
+    const parsed = JSON.parse(readFileSync(cachePath(home), "utf8"));
+    return typeof parsed?.checkedAt === "string" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeCache(home, cache) {
+  mkdirSync(home, { recursive: true });
+  const tmp = `${cachePath(home)}.tmp`;
+  writeFileSync(tmp, JSON.stringify(cache));
+  renameSync(tmp, cachePath(home));
+}
+function dueForCheck(cache, now, intervalMs = CHECK_INTERVAL_MS) {
+  if (!cache) return true;
+  const at = Date.parse(cache.checkedAt);
+  if (!Number.isFinite(at)) return true;
+  return now.getTime() - at >= intervalMs;
+}
+function updateNotice(current, latest) {
+  if (!latest || latest.length > 64 || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(latest) || compareVersions(current, latest) >= 0) return void 0;
+  return t("A new bccli is available: {latest} (you have {current}). Run: bccli update", { latest, current });
+}
+function notifyOnce(home, cache) {
+  const message = updateNotice(VERSION, cache?.latest);
+  if (!message || !cache?.latest || cache.notified === cache.latest) return void 0;
+  writeCache(home, { ...cache, notified: cache.latest });
+  return message;
+}
+async function checkForUpdate(deps) {
+  try {
+    const cached = readCache(deps.home);
+    if (!dueForCheck(cached, deps.now)) return notifyOnce(deps.home, cached);
+    const res = await deps.fetch(REGISTRY_URL, { signal: AbortSignal.timeout(deps.timeoutMs ?? 3e3) });
+    if (!res.ok) return notifyOnce(deps.home, cached);
+    const tags = await res.json();
+    const latest = tags[channelFor(VERSION)] ?? tags.latest;
+    const updated = { checkedAt: deps.now.toISOString(), latest, notified: cached?.notified };
+    writeCache(deps.home, updated);
+    return notifyOnce(deps.home, updated);
+  } catch {
+    return void 0;
+  }
+}
+function updateSpawnCommand(version, platform = process.platform, nodeExecPath = process.execPath, targetVersion) {
+  const spec = `@botconnector/bccli@${targetVersion ?? channelFor(version)}`;
+  if (platform !== "win32") return { command: "npm", args: ["i", "-g", spec] };
+  const npmCli = join(dirname(nodeExecPath), "node_modules", "npm", "bin", "npm-cli.js");
+  return { command: nodeExecPath, args: [npmCli, "i", "-g", spec], npmCli };
+}
+async function runUpdateCommand(deps) {
+  const current = deps.env.BCCLI_VERSION_OVERRIDE ?? VERSION;
+  let target;
+  try {
+    const response = await (deps.fetch ?? fetch)(REGISTRY_URL, {
+      signal: AbortSignal.timeout(8e3),
+      cache: "no-store",
+      headers: { "cache-control": "no-cache" }
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const tags = await response.json();
+    target = tags[channelFor(current)];
+    if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(target ?? "")) throw new Error("invalid registry version");
+  } catch (error) {
+    console.error(`Could not verify BCCLI update version: ${String(error)}. No changes made.`);
+    return 1;
+  }
+  if (compareVersions(target, current) <= 0) {
+    console.log(`BCCLI ${current} is already up to date (registry: ${target}); no changes made.`);
+    return 0;
+  }
+  const spec = updateSpawnCommand(current, deps.platform, deps.nodeExecPath, target);
+  if (spec.npmCli && !existsSync(spec.npmCli)) {
+    console.error(`npm CLI was not found at ${spec.npmCli}. Update manually with: npm install -g @botconnector/bccli@${channelFor(deps.env.BCCLI_VERSION_OVERRIDE ?? VERSION)}`);
+    return 1;
+  }
+  const r = (deps.spawn ?? spawnSync)(spec.command, spec.args, { stdio: "inherit", env: deps.env, shell: false });
+  if (r.error) console.error(`BCCLI update failed: ${r.error.message}. Try: npm install -g @botconnector/bccli@${channelFor(deps.env.BCCLI_VERSION_OVERRIDE ?? VERSION)}`);
+  return typeof r.status === "number" ? r.status : 1;
+}
+export {
+  channelFor,
+  checkForUpdate,
+  compareVersions,
+  dueForCheck,
+  runUpdateCommand,
+  updateNotice,
+  updateSpawnCommand
+};

package/dist/update.d.ts

@@ -0,0 +1,30 @@
+import { spawnSync } from 'node:child_process';
+export interface UpdateCache {
+    checkedAt: string;
+    latest?: string;
+    notified?: string;
+}
+/** Simplified semver: numeric cores, prerelease sorts below release, numeric prerelease parts compare numerically. */
+export declare function compareVersions(a: string, b: string): number;
+export declare function channelFor(version: string): 'next' | 'latest';
+export declare function dueForCheck(cache: UpdateCache | undefined, now: Date, intervalMs?: number): boolean;
+export declare function updateNotice(current: string, latest: string | undefined): string | undefined;
+/** Best-effort registry check with a 24h cache; never throws, never blocks startup for long. */
+export declare function checkForUpdate(deps: {
+    home: string;
+    fetch: typeof fetch;
+    now: Date;
+    timeoutMs?: number;
+}): Promise<string | undefined>;
+export declare function updateSpawnCommand(version: string, platform?: NodeJS.Platform, nodeExecPath?: string, targetVersion?: string): {
+    command: string;
+    args: string[];
+    npmCli?: string;
+};
+export declare function runUpdateCommand(deps: {
+    env: NodeJS.ProcessEnv;
+    spawn?: typeof spawnSync;
+    platform?: NodeJS.Platform;
+    nodeExecPath?: string;
+    fetch?: typeof fetch;
+}): Promise<number>;

package/dist/verify.d.ts

@@ -0,0 +1,16 @@
+import { runCommand } from './tools/bash';
+export interface VerifyFailure {
+    cmd: string;
+    exitCode: number;
+    output: string;
+}
+/** Fix rounds per user turn; keeps a failing verify command from looping forever. */
+export declare const MAX_VERIFY_ROUNDS = 2;
+export declare function runVerify(commands: string[], opts: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    signal: AbortSignal;
+    timeoutMs?: number;
+    run?: typeof runCommand;
+}): Promise<VerifyFailure[]>;
+export declare function verifyFollowup(failures: VerifyFailure[], maxBytes?: number): string;

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string;

package/dist/webBudget.d.ts

@@ -0,0 +1,25 @@
+import type { ChatMessage } from './provider';
+export declare const isStub: (content: string) => boolean;
+/**
+ * Replaces old `fetch` results with a one-line stub, in one batch and only once they add up to more than
+ * PRUNE_MIN_TOKENS, so the prompt prefix (and its cache) changes rarely. The newest KEEP_TOKENS worth stay intact.
+ */
+export declare function pruneOldFetches(messages: ChatMessage[]): boolean;
+export interface WebBudgetLimits {
+    perTurn?: number;
+    sessionChars?: number;
+}
+export declare class WebBudget {
+    private fetches;
+    private chars;
+    private readonly perTurn;
+    private readonly sessionChars;
+    constructor(limits?: WebBudgetLimits);
+    startTurn(): void;
+    /** Gives back a reservation, e.g. when the fetch was served from cache and cost nothing. */
+    refund(): void;
+    reset(): void;
+    /** Reserves one fetch; returns the refusal to show the model when over budget. */
+    take(): string | undefined;
+    record(chars: number): void;
+}

package/dist/worktree.d.ts

@@ -0,0 +1,12 @@
+export interface WorktreePlan {
+    path: string;
+    created: boolean;
+}
+/**
+ * Resolve (creating when needed) the sibling worktree for `-w <name>`: always derived from the
+ * MAIN checkout, so running inside an existing worktree nests nothing. The returned path becomes
+ * the session cwd, so config, prompts, sessions, and permissions all follow it.
+ */
+export declare function resolveWorktree(cwd: string, name: string, bin?: string): Promise<WorktreePlan>;
+/** Read-only status for /worktree: what exists and how to remove it safely. */
+export declare function worktreeListText(cwd: string, bin?: string): Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botconnector/bccli",
-  "version": "0.4.0-beta.9",
+  "version": "0.4.1",
   "description": "BCCLI — BotConnector AI coding agent for the terminal",
   "type": "module",
   "bin": {
@@ -18,26 +18,60 @@
   },
   "license": "MIT",
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
-    "lint": "biome lint src test",
-    "test": "vitest run"
+    "lint": "biome lint --error-on-warnings src test",
+    "test": "vitest run",
+    "coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.1",
+    "@modelcontextprotocol/sdk": "^1.32.1",
     "diff": "^9.0.0",
-    "fast-glob": "^3.3.3",
     "ink": "^7.1.1",
+    "openai": "^7.27.0",
     "react": "^19.3.0",
+    "undici": "^8.12.1",
+    "ws": "^8.22.0",
+    "yaml": "^2.9.1",
     "zod": "^4.6.5"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.14",
     "@types/node": "^26.6.3",
     "@types/react": "^19.3.0",
+    "@types/ws": "^8.18.2",
+    "@vitest/coverage-v8": "^5.0.5",
     "ink-testing-library": "^4.0.0",
-    "tsup": "^8.5.1",
+    "tsup": "^9.0.0",
     "typescript": "^7.0.2",
     "vitest": "^5.0.2"
-  }
+  },
+  "overrides": {
+    "esbuild": "0.28.2"
+  },
+  "main": "dist/sdk.js",
+  "types": "dist/sdk.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/sdk.d.ts",
+      "default": "./dist/sdk.js"
+    }
+  },
+  "keywords": [
+    "bccli",
+    "ai",
+    "coding-agent",
+    "agent",
+    "cli",
+    "tui",
+    "terminal",
+    "mcp",
+    "openai",
+    "indonesia"
+  ],
+  "author": "BotConnector (https://botconnector.id)",
+  "bugs": {
+    "url": "https://github.com/farijarifriyanto-debug/bccli/issues"
+  },
+  "homepage": "https://github.com/farijarifriyanto-debug/bccli#readme"
 }

package/dist/args-JPVSGCGY.js

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-import {
-  HELP_TEXT,
-  parseCliArgs
-} from "./chunk-ZYCYTEKD.js";
-import "./chunk-ELML4KVQ.js";
-import "./chunk-CLN4Z5E3.js";
-import "./chunk-2MGINW4O.js";
-export {
-  HELP_TEXT,
-  parseCliArgs
-};

package/dist/chunk-2MGINW4O.js

@@ -1,114 +0,0 @@
-#!/usr/bin/env node
-
-// src/presets.ts
-var PRESETS = [
-  { id: "bc-cloud", name: "BotConnector Cloud", baseURL: "https://api.botconnector.id/v1", apiKeyEnv: "BOTCONNECTOR_API_KEY" },
-  { id: "openrouter", name: "OpenRouter", baseURL: "https://openrouter.ai/api/v1", apiKeyEnv: "OPENROUTER_API_KEY" },
-  { id: "openai", name: "OpenAI", baseURL: "https://api.openai.com/v1", apiKeyEnv: "OPENAI_API_KEY" },
-  { id: "gemini", name: "Google Gemini", baseURL: "https://generativelanguage.googleapis.com/v1beta/openai", apiKeyEnv: "GEMINI_API_KEY" },
-  { id: "deepseek", name: "DeepSeek", baseURL: "https://api.deepseek.com/v1", apiKeyEnv: "DEEPSEEK_API_KEY" },
-  { id: "groq", name: "Groq", baseURL: "https://api.groq.com/openai/v1", apiKeyEnv: "GROQ_API_KEY" },
-  { id: "ollama-cloud", name: "Ollama Cloud", baseURL: "https://ollama.com/v1", apiKeyEnv: "OLLAMA_API_KEY" },
-  { id: "ollama", name: "Ollama lokal", baseURL: "http://127.0.0.1:11434/v1", local: true },
-  { id: "lmstudio", name: "LM Studio lokal", baseURL: "http://127.0.0.1:1234/v1", local: true }
-];
-
-// src/config.ts
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var ConfigError = class extends Error {
-};
-var DEFAULT_CONFIG = {
-  model: "bc-cloud/glm-5.3-flash",
-  permissionMode: "default",
-  reasoning: "auto",
-  providers: Object.fromEntries(PRESETS.map((p) => [p.id, { baseURL: p.baseURL, apiKeyEnv: p.apiKeyEnv }])),
-  allow: []
-};
-function bccliHome(env = process.env) {
-  return env.BCCLI_HOME ?? join(homedir(), ".bccli");
-}
-function readJsonConfig(path) {
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch (error) {
-    throw new ConfigError(`Config tidak valid: ${path} (${error.message})`);
-  }
-}
-function untrustedProviders(project, known) {
-  const out = {};
-  for (const [id, provider] of Object.entries(project.providers ?? {})) {
-    if (known[id] || typeof provider?.baseURL !== "string") continue;
-    out[id] = { baseURL: provider.baseURL };
-  }
-  return out;
-}
-function loadConfig(cwd, env = process.env) {
-  const global = readJsonConfig(join(bccliHome(env), "config.json"));
-  const project = readJsonConfig(join(cwd, ".bccli", "config.json"));
-  const known = { ...DEFAULT_CONFIG.providers, ...global.providers };
-  const fromProject = untrustedProviders(project, known);
-  return {
-    model: project.model ?? global.model ?? DEFAULT_CONFIG.model,
-    permissionMode: global.permissionMode ?? DEFAULT_CONFIG.permissionMode,
-    reasoning: global.reasoning ?? DEFAULT_CONFIG.reasoning,
-    providers: { ...known, ...fromProject },
-    projectProviders: Object.keys(fromProject),
-    allow: [...global.allow ?? []]
-  };
-}
-function readCredentials(env = process.env) {
-  const path = join(bccliHome(env), "credentials");
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function saveCredential(providerId, key, env = process.env) {
-  const home = bccliHome(env);
-  mkdirSync(home, { recursive: true });
-  const path = join(home, "credentials");
-  writeFileSync(path, JSON.stringify({ ...readCredentials(env), [providerId]: key }, null, 2), { mode: 384 });
-  chmodSync(path, 384);
-}
-function resolveModel(config, modelRef, env = process.env) {
-  const slash = modelRef.indexOf("/");
-  if (slash <= 0 || slash === modelRef.length - 1) {
-    throw new ConfigError(`Model harus berformat provider/model, contoh bc-cloud/glm-5.3-flash (dapat: ${modelRef})`);
-  }
-  const providerId = modelRef.slice(0, slash);
-  const provider = config.providers[providerId];
-  if (!provider) {
-    throw new ConfigError(`Provider "${providerId}" tidak ada di config. Tersedia: ${Object.keys(config.providers).join(", ")}`);
-  }
-  const apiKey = (provider.apiKeyEnv ? env[provider.apiKeyEnv] : void 0) || readCredentials(env)[providerId] || void 0;
-  if (provider.apiKeyEnv && !apiKey) {
-    throw new ConfigError(`API key untuk ${providerId} belum ada. Jalankan \`bccli login\` atau set env ${provider.apiKeyEnv}.`);
-  }
-  return { providerId, model: modelRef.slice(slash + 1), baseURL: provider.baseURL.replace(/\/+$/, ""), apiKey };
-}
-function removeCredential(providerId, env = process.env) {
-  const creds = readCredentials(env);
-  if (!(providerId in creds)) return false;
-  delete creds[providerId];
-  const path = join(bccliHome(env), "credentials");
-  writeFileSync(path, JSON.stringify(creds, null, 2), { mode: 384 });
-  chmodSync(path, 384);
-  return true;
-}
-
-export {
-  PRESETS,
-  ConfigError,
-  bccliHome,
-  readJsonConfig,
-  loadConfig,
-  readCredentials,
-  saveCredential,
-  resolveModel,
-  removeCredential
-};

package/dist/chunk-ELML4KVQ.js

@@ -1,76 +0,0 @@
-#!/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 TWO_WORD = /* @__PURE__ */ new Set(["npm", "npx", "pnpm", "yarn", "bun", "git", "cargo", "go", "docker", "python", "python3", "uv", "make"]);
-function commandKey(segment) {
-  const words = segment.trim().split(/\s+/);
-  return TWO_WORD.has(words[0]) && words[1] ? `${words[0]} ${words[1]}` : words[0];
-}
-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 (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;
-      return [...new Set(segments.map((s) => `bash(${commandKey(s)})`))];
-    }
-    if (req.kind === "mcp") return [`mcp(${req.tool})`];
-    return [];
-  }
-  check(req) {
-    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-ISGBGFSU.js

@@ -1,52 +0,0 @@
-#!/usr/bin/env node
-
-// 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);
-  });
-}
-async function runLogin(providerId, cwd) {
-  const { runProviderCommand } = await import("./providerCli-Q7LRM2NP.js");
-  const { parseCliArgs } = await import("./args-JPVSGCGY.js");
-  return runProviderCommand(parseCliArgs(["provider", "add", providerId]), {
-    env: process.env,
-    cwd,
-    out: (s) => console.log(s),
-    err: (s) => console.error(s),
-    readSecret
-  });
-}
-
-export {
-  readSecret,
-  runLogin
-};