@botconnector/bccli 0.4.0-beta.8 → 0.4.0

package/dist/login-SYIQP46J.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import {
+  defaultLoginDeps,
+  readLine,
+  readSecret,
+  runLogin
+} from "./chunk-BNA74HPN.js";
+import "./chunk-7F3IWBPQ.js";
+import "./chunk-LACUWBWS.js";
+import "./chunk-UZWJQF67.js";
+export {
+  defaultLoginDeps,
+  readLine,
+  readSecret,
+  runLogin
+};

package/dist/{mcpCli-DZWQPTOS.js → mcpCli-QUV5SD64.js}

@@ -2,21 +2,32 @@
 import {
   CATALOG,
   fillTemplate
-} from "./chunk-DX7CZTBB.js";
+} from "./chunk-BQ2IGPBR.js";
+import {
+  authorizeMcpServer,
+  clearTokens
+} from "./chunk-7F3IWBPQ.js";
 import {
   addGlobalServer,
   globalMcpPath,
   readMcpFile,
   removeGlobalServer
-} from "./chunk-BFZXRKW5.js";
+} from "./chunk-L7QI6JN2.js";
 import {
   bccliHome
-} from "./chunk-2MGINW4O.js";
+} from "./chunk-LACUWBWS.js";
+import {
+  t
+} from "./chunk-UZWJQF67.js";
 
 // src/mcpCli.ts
 async function runMcpCommand(args, deps) {
   const home = bccliHome(deps.env);
   const [action = "list", name] = args.subArgs;
+  if (action === "serve") {
+    const { runMcpServe } = await import("./serve-6QLBJUYW.js");
+    return runMcpServe(args, deps);
+  }
   const installed = readMcpFile(globalMcpPath(home));
   if (action === "list") {
     for (const entry2 of CATALOG) deps.out(`${installed[entry2.name] ? "\u2713" : "\u25CB"} ${entry2.name.padEnd(12)} ${entry2.description}`);
@@ -24,26 +35,48 @@ async function runMcpCommand(args, deps) {
     return 0;
   }
   if (!name) {
-    deps.err(`Pemakaian: bccli mcp ${action} <nama>`);
+    deps.err(t("Usage: bccli mcp {action} <name>", { action }));
     return 1;
   }
   if (action === "remove") {
     removeGlobalServer(home, name);
-    deps.out(`${name} dihapus.`);
+    deps.out(t("{name} removed.", { name }));
     return 0;
   }
+  if (action === "auth" || action === "logout") {
+    const config = installed[name];
+    if (config?.type !== "http") {
+      deps.err(
+        t("{name} is not an installed HTTP MCP server. Add it first with: bccli mcp add {name} --url <url>", { name })
+      );
+      return 1;
+    }
+    if (action === "logout") {
+      const removed = clearTokens(home, config.url);
+      deps.out(removed ? t("{name} logged out.", { name }) : t("{name} has no stored OAuth tokens.", { name }));
+      return 0;
+    }
+    try {
+      await authorizeMcpServer({ name, config }, { home });
+      deps.out(t("{name} authorized. Active in the next bccli session.", { name }));
+      return 0;
+    } catch (error) {
+      deps.err(t("OAuth login failed for {name}: {reason}", { name, reason: error.message }));
+      return 1;
+    }
+  }
   if (action !== "add") {
-    deps.err(`Aksi tidak dikenal: ${action}. Pakai list, add, atau remove.`);
+    deps.err(t("Unknown action: {action}. Use list, add, remove, auth, logout, or serve.", { action }));
     return 1;
   }
   if (args.url) {
     addGlobalServer(home, name, { type: "http", url: args.url });
-    deps.out(`${name} terpasang (${args.url}).`);
+    deps.out(t("{name} installed ({url}).", { name, url: args.url }));
     return 0;
   }
   const entry = CATALOG.find((c) => c.name === name);
   if (!entry) {
-    deps.err(`${name} tidak ada di katalog. Untuk server remote lain pakai: bccli mcp add ${name} --url <url>`);
+    deps.err(t("{name} is not in the catalog. For another remote server use: bccli mcp add {name} --url <url>", { name }));
     return 1;
   }
   const values = Object.fromEntries(args.values.map((v) => [v.slice(0, v.indexOf("=")), v.slice(v.indexOf("=") + 1)]));
@@ -57,7 +90,7 @@ async function runMcpCommand(args, deps) {
     deps.err(`${error.message}${hint ? `. Contoh: bccli mcp add ${name} ${hint}` : ""}`);
     return 1;
   }
-  deps.out(`${name} terpasang. Aktif di sesi bccli berikutnya.`);
+  deps.out(t("{name} installed. Active in the next bccli session.", { name }));
   return 0;
 }
 export {

package/dist/modelsCli-TRRB5LX4.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import {
+  listAllModels
+} from "./chunk-XBO5GACQ.js";
+import "./chunk-SPRNLS7K.js";
+import "./chunk-PUN4HMAG.js";
+import "./chunk-BLOYFIAD.js";
+import {
+  loadConfig,
+  resolveModel
+} from "./chunk-LACUWBWS.js";
+import {
+  t
+} from "./chunk-UZWJQF67.js";
+
+// src/modelsCli.ts
+async function runModelsCommand(args, deps) {
+  const config = loadConfig(deps.cwd, deps.env);
+  const arg = (args.subArgs[0] ?? "").trim();
+  const providerId = arg ? arg.split("/")[0] : resolveModel(config, args.model ?? config.model, deps.env).providerId;
+  if (!Object.hasOwn(config.providers, providerId)) {
+    deps.err(t('Provider "{id}" is not in the config. Available: {list}', { id: providerId, list: Object.keys(config.providers).join(", ") }));
+    return 1;
+  }
+  const groups = await listAllModels(config, deps.env, { fetch: deps.fetch, only: providerId });
+  const group = groups.find((g) => g.providerId === providerId);
+  if (!group || group.error) {
+    deps.err(`${providerId}: ${group?.error ?? t("could not be reached")}`);
+    return 1;
+  }
+  deps.out(group.models.map((m) => `${providerId}/${m}`).join("\n"));
+  return 0;
+}
+export {
+  runModelsCommand
+};

package/dist/npmRunner-LU43GM3W.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+// src/npmRunner.ts
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { delimiter, posix, win32 } from "path";
+function findNpmCli(platform, env, exists, execPath) {
+  const path = platform === "win32" ? win32 : posix;
+  const sibling = path.join(path.dirname(execPath), "node_modules", "npm", "bin", "npm-cli.js");
+  if (exists(sibling)) return sibling;
+  const sep = platform === "win32" ? ";" : delimiter;
+  for (const dir of (env.PATH ?? "").split(sep)) {
+    if (!dir) continue;
+    const shim = path.join(dir, platform === "win32" ? "npm.cmd" : "npm");
+    if (!exists(shim)) continue;
+    const cli = path.join(dir, "node_modules", "npm", "bin", "npm-cli.js");
+    if (exists(cli)) return cli;
+  }
+  return null;
+}
+var text = (v) => typeof v === "string" ? v : v ? v.toString() : "";
+function toResult(r) {
+  return {
+    code: r.status ?? 1,
+    stderr: text(r.stderr) || (r.error ? r.error.message : ""),
+    stdout: text(r.stdout)
+  };
+}
+function runNpmSync(prefix, argv, opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const spawn = opts.spawn ?? spawnSync;
+  const env = opts.env ?? process.env;
+  const exists = opts.exists ?? existsSync;
+  const execPath = opts.execPath ?? process.execPath;
+  if (platform !== "win32") {
+    return toResult(spawn("npm", ["--prefix", prefix, ...argv], { encoding: "utf8", env }));
+  }
+  const cli = findNpmCli(platform, env, exists, execPath);
+  if (!cli) {
+    return { code: 1, stderr: "npm CLI not found (looked beside the node executable and on PATH)" };
+  }
+  return toResult(spawn(execPath, [cli, "--prefix", prefix, ...argv], { encoding: "utf8", env }));
+}
+export {
+  runNpmSync
+};

package/dist/oauthLogin-6FWQABJ7.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+import {
+  t
+} from "./chunk-UZWJQF67.js";
+
+// src/oauthLogin.ts
+import { createHash, randomBytes } from "crypto";
+var OPENROUTER_AUTH_URL = "https://openrouter.ai/auth";
+var OPENROUTER_EXCHANGE_URL = "https://openrouter.ai/api/v1/auth/keys";
+var OPENROUTER_DASHBOARD_URL = "https://openrouter.ai/settings/keys";
+var OPENROUTER_ENV_KEY = "OPENROUTER_API_KEY";
+var KEY_LABEL = "bccli";
+var EXCHANGE_TIMEOUT_MS = 15e3;
+var DETAIL_MAX = 200;
+function pkcePair() {
+  const verifier = randomBytes(32).toString("base64url");
+  const challenge = createHash("sha256").update(verifier, "ascii").digest("base64url");
+  return { verifier, challenge };
+}
+function buildAuthUrl(challenge) {
+  const url = new URL(OPENROUTER_AUTH_URL);
+  url.searchParams.set("code_challenge", challenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  url.searchParams.set("key_label", KEY_LABEL);
+  return url.href;
+}
+function redact(text, secrets) {
+  let out = text;
+  for (const s of secrets) {
+    if (!s) continue;
+    out = out.split(s).join("***");
+  }
+  return out;
+}
+function classifyExchange403(detail) {
+  return detail.toLowerCase().includes("expired") ? "expired" : "rejected";
+}
+function extractWhitelistDetail(body) {
+  if (typeof body !== "object" || body === null) return "";
+  const rec = body;
+  return typeof rec.error === "string" ? rec.error : typeof rec.message === "string" ? rec.message : "";
+}
+function safeDetail(raw, secrets) {
+  return redact(raw, secrets).slice(0, DETAIL_MAX);
+}
+async function exchangeAuthCode(code, verifier, deps) {
+  const secrets = [code, verifier];
+  const timeoutSignal = AbortSignal.timeout(deps.timeoutMs ?? EXCHANGE_TIMEOUT_MS);
+  const signal = deps.signal ? AbortSignal.any([timeoutSignal, deps.signal]) : timeoutSignal;
+  let parsed;
+  let status = 0;
+  try {
+    const res = await deps.fetch(OPENROUTER_EXCHANGE_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code, code_verifier: verifier, code_challenge_method: "S256" }),
+      signal
+    });
+    status = res.status;
+    if (signal.aborted) {
+      if (deps.signal?.aborted) return { ok: false, kind: "cancelled", detail: "" };
+      return { ok: false, kind: "timeout", detail: "" };
+    }
+    try {
+      parsed = await res.json();
+    } catch (error) {
+      if (deps.signal?.aborted || timeoutSignal.aborted) throw error;
+      parsed = void 0;
+    }
+  } catch (error) {
+    if (deps.signal?.aborted) return { ok: false, kind: "cancelled", detail: "" };
+    if (timeoutSignal.aborted) return { ok: false, kind: "timeout", detail: "" };
+    return { ok: false, kind: "network", detail: safeDetail(String(error?.message ?? ""), secrets) };
+  }
+  const detail = safeDetail(extractWhitelistDetail(parsed), secrets);
+  if (status !== 200) {
+    if (status === 403) {
+      return classifyExchange403(detail) === "expired" ? { ok: false, kind: "http403-expired", status: 403, detail } : { ok: false, kind: "http403-rejected", status: 403, detail };
+    }
+    return { ok: false, kind: "http-other", status, detail };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { ok: false, kind: "invalid-body", detail: "" };
+  }
+  const key = parsed.key;
+  if (typeof key !== "string" || key.trim() === "") return { ok: false, kind: "invalid-body", detail: "" };
+  return { ok: true, key };
+}
+var ABORT = /* @__PURE__ */ Symbol("aborted");
+function isReadCancel(error) {
+  const e = error;
+  return e?.name === "AbortError" || e?.code === "SIGINT";
+}
+async function runOauthLogin(deps) {
+  if (!deps.isTTY) {
+    deps.err(t("bccli login openrouter needs a terminal. Use --key to paste an API key instead."));
+    return 1;
+  }
+  const { verifier, challenge } = pkcePair();
+  const url = buildAuthUrl(challenge);
+  try {
+    deps.open(url);
+  } catch {
+    deps.out(t("Could not open the browser automatically \u2014 open this URL manually: {url}", { url }));
+  }
+  let code;
+  try {
+    code = await deps.readLine(t("Paste the authorization code from the browser: "));
+  } catch (error) {
+    if (isReadCancel(error)) return 130;
+    deps.err(
+      t("Failed to read the authorization code: {reason}. Your stored credential was not changed.", {
+        reason: String(error?.message ?? error).slice(0, 200)
+      })
+    );
+    return 1;
+  }
+  if (code === ABORT) return 130;
+  if (typeof code !== "string" || code.trim() === "") {
+    deps.err(t("Authorization code is empty. Run bccli login openrouter again."));
+    return 1;
+  }
+  const trimmed = code.trim();
+  const secrets = [trimmed, verifier];
+  const result = await (async () => {
+    const controller = new AbortController();
+    const onSigint = () => controller.abort();
+    process.once("SIGINT", onSigint);
+    try {
+      return await exchangeAuthCode(trimmed, verifier, {
+        fetch: deps.fetch,
+        timeoutMs: deps.timeoutMs,
+        signal: controller.signal
+      });
+    } finally {
+      process.removeListener("SIGINT", onSigint);
+    }
+  })();
+  if (!result.ok) {
+    const detail = redact(result.detail, secrets);
+    switch (result.kind) {
+      case "cancelled":
+        deps.err(t("Login cancelled."));
+        return 130;
+      case "timeout":
+        deps.err(
+          t("The exchange with OpenRouter timed out after {seconds}s. Your stored credential was not changed.", {
+            seconds: String(Math.round((deps.timeoutMs ?? EXCHANGE_TIMEOUT_MS) / 1e3))
+          })
+        );
+        return 1;
+      case "network":
+        deps.err(t("Could not reach OpenRouter: {reason}. Your stored credential was not changed.", { reason: detail }));
+        return 1;
+      case "http403-expired":
+        deps.err(t("Authorization code expired \u2014 codes are valid for 10 minutes. Run bccli login openrouter again."));
+        return 1;
+      case "http403-rejected":
+        deps.err(t("OpenRouter rejected the authorization code (403): {detail}. Run bccli login openrouter again.", { detail: detail || "no details" }));
+        return 1;
+      case "invalid-body":
+        deps.err(t("OpenRouter did not return an API key in the expected format. Your stored credential was not changed."));
+        return 1;
+      case "http-other":
+        deps.err(t("OpenRouter exchange failed ({status}): {detail}. Your stored credential was not changed.", { status: String(result.status ?? 0), detail }));
+        return 1;
+    }
+  }
+  try {
+    deps.saveCredential("openrouter", result.key);
+  } catch (error) {
+    deps.err(
+      t("The key was created on your OpenRouter account but could not be saved locally ({reason}). Manage it (copy or revoke) at {dashboard}, then run bccli login openrouter again.", {
+        reason: redact(String(error?.message ?? ""), [result.key, trimmed, verifier]).slice(0, 200),
+        dashboard: OPENROUTER_DASHBOARD_URL
+      })
+    );
+    return 1;
+  }
+  deps.out(t("Logged in: openrouter credential saved."));
+  if (deps.env[OPENROUTER_ENV_KEY]) {
+    deps.out(t("Note: {env} is also set in the environment; the stored credential takes priority and {env} is only the fallback.", { env: OPENROUTER_ENV_KEY }));
+  }
+  deps.out(t("Verify with: bccli models openrouter (your key is never printed)."));
+  return 0;
+}
+async function runOauthLogout(deps) {
+  const removed = deps.removeCredential("openrouter");
+  if (removed) deps.out(t("openrouter credential removed."));
+  else deps.out(t("openrouter credential was not stored."));
+  if (deps.env[OPENROUTER_ENV_KEY]) {
+    deps.out(t("Note: {env} is still set in the environment and will keep being used.", { env: OPENROUTER_ENV_KEY }));
+  }
+  deps.out(t("To revoke keys on your account, open {dashboard}.", { dashboard: OPENROUTER_DASHBOARD_URL }));
+  return 0;
+}
+export {
+  ABORT,
+  OPENROUTER_AUTH_URL,
+  OPENROUTER_DASHBOARD_URL,
+  OPENROUTER_ENV_KEY,
+  OPENROUTER_EXCHANGE_URL,
+  buildAuthUrl,
+  classifyExchange403,
+  exchangeAuthCode,
+  pkcePair,
+  redact,
+  runOauthLogin,
+  runOauthLogout
+};

package/dist/pluginsCli-GNW4TPVV.js

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+import {
+  bccliHome,
+  globalConfigPath
+} from "./chunk-LACUWBWS.js";
+import {
+  t
+} from "./chunk-UZWJQF67.js";
+
+// src/pluginsCli.ts
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, isAbsolute, join } from "path";
+
+// src/pluginSpec.ts
+var NPM_SPEC_RE = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*(?:@[a-z0-9][a-z0-9._+-]*)?$/;
+var BARE_NAME_RE = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+var MANAGED_PREFIX = "./plugins/node_modules/";
+function parseNpmSpec(raw) {
+  const spec = raw.trim();
+  if (!NPM_SPEC_RE.test(spec)) return null;
+  const at = spec.lastIndexOf("@");
+  const name = at > 0 ? spec.slice(0, at) : spec;
+  if (!NPM_SPEC_RE.test(name)) return null;
+  return { name, spec };
+}
+function managedEntry(name) {
+  return `${MANAGED_PREFIX}${name}`;
+}
+function isManagedEntry(entry) {
+  return entry.startsWith(MANAGED_PREFIX);
+}
+function managedEntryName(entry) {
+  if (!isManagedEntry(entry)) return null;
+  const rest = entry.slice(MANAGED_PREFIX.length);
+  return BARE_NAME_RE.test(rest) ? rest : null;
+}
+
+// src/pluginsCli.ts
+function ensurePrefixDir(prefix) {
+  mkdirSync(prefix, { recursive: true });
+  const pkg = join(prefix, "package.json");
+  if (!existsSync(pkg)) {
+    writeFileSync(pkg, `${JSON.stringify({ name: "bccli-plugins", private: true, version: "0.0.0" }, null, 2)}
+`);
+  }
+}
+async function runPluginsCommand(args, deps) {
+  const [action, target] = args.subArgs;
+  const prefix = join(bccliHome(deps.env), "plugins");
+  switch (action ?? "list") {
+    case "list":
+      return listAction(deps);
+    case "install":
+      return installAction(target, deps, prefix);
+    case "remove":
+      return removeAction(target, deps, prefix);
+    case "update":
+      return updateAction(target, deps, prefix);
+    default:
+      deps.err(t("Unknown action: {action}. Use list, install <spec>, remove <name>, or update [name].", { action: action ?? "" }));
+      return 1;
+  }
+}
+var require_ = createRequire(import.meta.url);
+function resolveEntryPath(entry, home) {
+  if (isAbsolute(entry)) return entry;
+  if (entry.startsWith(".")) return join(home, entry);
+  try {
+    return require_.resolve(entry);
+  } catch {
+    return null;
+  }
+}
+function readFailure(action, error, deps) {
+  deps.err(
+    t("Cannot read the plugin config while running {action}: {reason} at {path} \u2014 no changes were made; fix the config, then retry.", {
+      action,
+      reason: error.message,
+      path: globalConfigPath(deps.env)
+    })
+  );
+  return 1;
+}
+function listAction(deps) {
+  let entries;
+  try {
+    entries = deps.readPlugins();
+  } catch (error) {
+    return readFailure("list", error, deps);
+  }
+  const home = bccliHome(deps.env);
+  for (const entry of entries) {
+    const managed = isManagedEntry(entry);
+    const bare = managed ? managedEntryName(entry) : entry;
+    const suffix = !managed ? " (manual)" : bare === null ? " (malformed)" : "";
+    const resolved = resolveEntryPath(entry, home);
+    if (!resolved || !existsSync(resolved)) {
+      deps.out(`\u2717 ${entry}${suffix}`);
+      continue;
+    }
+    let version = "";
+    try {
+      const pkgPath = statSync(resolved).isDirectory() ? join(resolved, "package.json") : join(dirname(resolved), "package.json");
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      if (pkg.version) version = ` (${pkg.version})`;
+    } catch {
+    }
+    deps.out(`\u2713 ${entry}${suffix}${version}`);
+  }
+  return 0;
+}
+function npmFailure(res, deps) {
+  deps.err(t("npm install failed ({code}): {stderr}", { code: String(res.code), stderr: res.stderr.slice(-400) }));
+  return 1;
+}
+async function installAction(target, deps, prefix) {
+  if (!target) {
+    deps.err(t("install requires a package spec: bccli plugins install <spec>"));
+    return 1;
+  }
+  const parsed = parseNpmSpec(target);
+  if (!parsed) {
+    deps.err(
+      t("Invalid npm package spec: {spec}. Use a name, @scope/name, name@version, or name@tag \u2014 URLs, git, paths, and flags are not accepted.", { spec: target })
+    );
+    return 1;
+  }
+  ensurePrefixDir(prefix);
+  const res = await deps.runNpm(prefix, ["install", parsed.spec]);
+  if (res.code !== 0) return npmFailure(res, deps);
+  const entry = managedEntry(parsed.name);
+  let entries;
+  try {
+    entries = deps.readPlugins();
+  } catch (error) {
+    deps.err(t("npm finished but the config could not be read: {reason} \u2014 the entry list is unchanged; fix {path}, then rerun the same command (safe to repeat).", { reason: error.message, path: globalConfigPath(deps.env) }));
+    return 1;
+  }
+  const wasRegistered = entries.includes(entry);
+  try {
+    deps.savePlugins(wasRegistered ? entries : [...entries, entry]);
+  } catch (error) {
+    const reason = error.message;
+    deps.err(
+      wasRegistered ? t("npm finished but the config update failed: {reason}. {name} stays enabled through its existing entry {entry}; the package files may already be new. Fix the config error at {path} \u2014 no entry change was required.", { reason, name: parsed.name, entry, path: globalConfigPath(deps.env) }) : t('npm finished but the config update failed: {reason}. {name} is installed but NOT enabled \u2014 fix the config error, then run "bccli plugins install {name}" again (safe to repeat), or add {entry} to {path} manually.', { reason, name: parsed.name, entry, path: globalConfigPath(deps.env) })
+    );
+    return 1;
+  }
+  deps.out(wasRegistered ? t("{name} is already enabled.", { name: parsed.name }) : t("{name} installed and enabled.", { name: parsed.name }));
+  return 0;
+}
+function resolveTarget(target, deps, action) {
+  if (!target) return "missing-arg";
+  let entries;
+  try {
+    entries = deps.readPlugins();
+  } catch (error) {
+    return {
+      error: t("Cannot read the plugin config while running {action}: {reason} at {path} \u2014 no changes were made; fix the config, then retry.", {
+        action,
+        reason: error.message,
+        path: globalConfigPath(deps.env)
+      })
+    };
+  }
+  if (entries.includes(target)) {
+    if (isManagedEntry(target)) {
+      const name = managedEntryName(target);
+      if (!name) {
+        return {
+          error: t("Malformed managed entry: {entry} \u2014 fix it manually in {path}; bccli will not pass it to npm.", {
+            entry: target,
+            path: globalConfigPath(deps.env)
+          })
+        };
+      }
+      return { entry: target, name };
+    }
+    return { error: t("{entry} is a manual plugin entry \u2014 edit the global config.json directly to remove it.", { entry: target }) };
+  }
+  const parsed = parseNpmSpec(target);
+  if (parsed) {
+    const entry = managedEntry(parsed.name);
+    if (entries.includes(entry)) return { entry, name: parsed.name };
+    return { error: t("{name} is not an installed managed plugin.", { name: parsed.name }) };
+  }
+  return { error: t("Unknown plugin: {arg}.", { arg: target }) };
+}
+async function removeAction(target, deps, prefix) {
+  const r = resolveTarget(target, deps, "remove");
+  if (r === "missing-arg") {
+    deps.err(t("remove requires a plugin name: bccli plugins remove <name>"));
+    return 1;
+  }
+  if ("error" in r) {
+    deps.err(r.error);
+    return 1;
+  }
+  const res = await deps.runNpm(prefix, ["uninstall", r.name]);
+  if (res.code !== 0) return npmFailure(res, deps);
+  let next;
+  try {
+    next = deps.readPlugins().filter((e) => e !== r.entry);
+  } catch (error) {
+    deps.err(
+      t('npm removed the files of {name} but the plugin config could not be read: {reason} \u2014 the entry list is unchanged; fix {path}, then run "bccli plugins remove {name}" again (safe to repeat).', {
+        name: r.name,
+        reason: error.message,
+        path: globalConfigPath(deps.env)
+      })
+    );
+    return 1;
+  }
+  try {
+    deps.savePlugins(next);
+  } catch (error) {
+    deps.err(
+      t('npm removed the files of {name} but the config entry {entry} remains: {reason}. bccli will refuse to start while that entry is listed \u2014 fix the config error at {path}, then run "bccli plugins remove {name}" again (safe to repeat), or delete the entry manually.', {
+        name: r.name,
+        entry: r.entry,
+        reason: error.message,
+        path: globalConfigPath(deps.env)
+      })
+    );
+    return 1;
+  }
+  deps.out(t("{name} removed.", { name: r.name }));
+  return 0;
+}
+async function updateAction(target, deps, prefix) {
+  let names;
+  let hadMalformed = false;
+  if (target === void 0) {
+    let entries;
+    try {
+      entries = deps.readPlugins();
+    } catch (error) {
+      return readFailure("update", error, deps);
+    }
+    names = [];
+    for (const entry of entries) {
+      if (!isManagedEntry(entry)) continue;
+      const name = managedEntryName(entry);
+      if (name) names.push(name);
+      else {
+        hadMalformed = true;
+        deps.err(t("Skipping malformed entry: {entry} \u2014 fix it manually in {path}.", { entry, path: globalConfigPath(deps.env) }));
+      }
+    }
+    if (!names.length) {
+      if (!hadMalformed) deps.out(t("No managed plugins to update."));
+      return hadMalformed ? 1 : 0;
+    }
+  } else {
+    const r = resolveTarget(target, deps, "update");
+    if (r === "missing-arg") {
+      deps.err(t("update requires a plugin name or no argument: bccli plugins update [name]"));
+      return 1;
+    }
+    if ("error" in r) {
+      deps.err(r.error);
+      return 1;
+    }
+    names = [r.name];
+  }
+  ensurePrefixDir(prefix);
+  let failed = false;
+  for (const name of names) {
+    const argv = ["install", `${name}@latest`];
+    const res = await deps.runNpm(prefix, argv);
+    if (res.code !== 0) {
+      failed = true;
+      deps.err(t("npm install failed ({code}): {stderr}", { code: String(res.code), stderr: res.stderr.slice(-400) }));
+    } else {
+      deps.out(t("{name} updated to latest.", { name }));
+    }
+  }
+  return failed || hadMalformed ? 1 : 0;
+}
+export {
+  ensurePrefixDir,
+  runPluginsCommand
+};