@botconnector/bccli 0.2.0-beta.1 → 0.3.0-beta.1

package/README.md

@@ -25,25 +25,70 @@ 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`.
 
-## Provider lain (OpenAI-compatible)
-
-`~/.bccli/config.json`:
-
-```json
-{
-  "model": "openrouter/qwen/qwen3-coder",
-  "providers": {
-    "openrouter": { "baseURL": "https://openrouter.ai/api/v1", "apiKeyEnv": "OPENROUTER_API_KEY" },
-    "local": { "baseURL": "http://127.0.0.1:11434/v1" }
-  },
-  "allow": ["bash(npm test)"]
-}
-```
+## Provider
+
+`/provider` di dalam sesi (atau `bccli provider add <id>`) memasang provider hanya dengan API key:
+
+| Id | Provider |
+|---|---|
+| `bc-cloud` | BotConnector Cloud (default) |
+| `openrouter` | OpenRouter |
+| `openai` | OpenAI |
+| `gemini` | Google Gemini |
+| `deepseek` | DeepSeek |
+| `groq` | Groq |
+| `ollama-cloud` | Ollama Cloud |
+| `ollama` | Ollama lokal (tanpa key) |
+| `lmstudio` | LM Studio lokal (tanpa key) |
+
+Provider lain yang OpenAI-compatible: pilih **Custom…** di `/provider`, atau
+`bccli provider add corp --url https://corp.example/v1 --name "Corp"`.
+
+`/model` menampilkan model dari **semua** provider yang sudah punya key, dikelompokkan
+per provider; ketik untuk menyaring. Pilihan tersimpan sebagai default.
 
 `.bccli/config.json` di dalam project hanya boleh memilih `model` dan menambah provider baru tanpa API key —
 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.
 
+## MCP
+
+`/mcp` (atau `bccli mcp add <nama>`) memasang server dari katalog:
+`playwright`, `context7`, `fetch`, `filesystem`, `git`, `github`. Server remote lain:
+`bccli mcp add nama --url https://…`. Tersimpan di `~/.bccli/mcp.json` (format `mcpServers`
+seperti Claude Code). Semua alat MCP selalu minta izin.
+
+`.bccli/mcp.json` di dalam repo tidak dijalankan sebelum kamu setujui (ditanya sekali per folder).
+
+## Subagent
+
+Agent bisa mendelegasikan pekerjaan lewat alat `task`:
+- `explore` — hanya baca & cari, bisa jalan paralel;
+- `general` — semua alat (edit/perintah tetap minta izin);
+- custom — `.bccli/agents/nama.md` atau `.claude/agents/nama.md`:
+
+```markdown
+---
+name: reviewer
+description: review perubahan kode
+tools: [read, grep, glob]
+model: openrouter/qwen/qwen3-coder
+---
+Kamu reviewer kode. Laporkan bug nyata saja.
+```
+
+## Skill & perintah custom
+
+- Skill: folder berisi `SKILL.md` di `~/.bccli/skills/`, `.bccli/skills/`, `~/.claude/skills/`,
+  `.claude/skills/` — dipakai agent otomatis bila cocok, atau `/nama-skill`.
+- Perintah: `commands/nama.md` di folder yang sama → `/nama argumen` (`$ARGUMENTS` diganti argumen).
+
+## Todo & mode plan
+
+Tugas ≥ 3 langkah menampilkan checklist di atas kotak input. Di mode plan (Shift+Tab),
+agent hanya membaca lalu mengajukan rencana; `[a]` setujui dengan edit otomatis,
+`[y]` setujui dengan tanya tiap langkah, `[n]` minta perbaikan.
+
 Instruksi project dibaca dari `AGENTS.md` dan `BCCLI.md`.
 
 ## Pengembangan

package/dist/args-EVIFNGPQ.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  HELP_TEXT,
+  parseCliArgs
+} from "./chunk-RDQ7HPWS.js";
+import "./chunk-5XN44Q55.js";
+import "./chunk-Z5JM76EL.js";
+export {
+  HELP_TEXT,
+  parseCliArgs
+};

package/dist/chunk-5C6NQFSI.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import {
+  PRESETS,
+  bccliHome,
+  readCredentials,
+  readJsonConfig,
+  removeCredential
+} from "./chunk-Z5JM76EL.js";
+
+// src/providers.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+function providerName(config, id) {
+  return PRESETS.find((p) => p.id === id)?.name ?? config.providers[id]?.name ?? id;
+}
+function hasKey(config, id, env = process.env) {
+  const provider = config.providers[id];
+  if (!provider) return false;
+  if (!provider.apiKeyEnv) return true;
+  return !!env[provider.apiKeyEnv] || !!readCredentials(env)[id];
+}
+var globalPath = (env) => join(bccliHome(env), "config.json");
+function readGlobalConfigFile(env = process.env) {
+  return readJsonConfig(globalPath(env));
+}
+function save(data, env) {
+  mkdirSync(bccliHome(env), { recursive: true });
+  writeFileSync(globalPath(env), `${JSON.stringify(data, null, 2)}
+`);
+}
+function writeGlobalConfig(patch, env = process.env) {
+  const current = readGlobalConfigFile(env);
+  const next = { ...current, ...patch };
+  if (patch.providers) next.providers = { ...current.providers, ...patch.providers };
+  save(next, env);
+}
+function removeGlobalProvider(id, env = process.env) {
+  removeCredential(id, env);
+  const current = readGlobalConfigFile(env);
+  if (!current.providers?.[id]) return;
+  const { [id]: _removed, ...providers } = current.providers;
+  save({ ...current, providers }, env);
+}
+
+export {
+  providerName,
+  hasKey,
+  writeGlobalConfig,
+  removeGlobalProvider
+};

package/dist/{chunk-WZYWKWPD.js → chunk-5XN44Q55.js}

@@ -1,58 +1,5 @@
 #!/usr/bin/env node
 
-// src/print.ts
-function toolLabel(tool) {
-  return tool.charAt(0).toUpperCase() + tool.slice(1);
-}
-async function runPrint(rt, prompt, io = { out: process.stdout, err: process.stderr }) {
-  let failed = false;
-  let wroteText = false;
-  rt.agent.onEvent = (event) => {
-    switch (event.type) {
-      case "text":
-        io.out.write(event.delta);
-        wroteText = true;
-        break;
-      case "toolStart":
-        io.err.write(`\u23BF ${toolLabel(event.tool)}  ${event.target}
-`);
-        break;
-      case "toolEnd":
-        if (event.isError) io.err.write(`  \u2717 ${event.output.split("\n")[0]}
-`);
-        break;
-      case "stepLimit":
-        io.err.write("Batas langkah tercapai.\n");
-        failed = true;
-        break;
-      case "aborted":
-        io.err.write("Dibatalkan.\n");
-        failed = true;
-        break;
-      case "error":
-        io.err.write(`Error: ${event.message}
-`);
-        failed = true;
-        break;
-    }
-  };
-  rt.agent.askPermission = async (req) => {
-    io.err.write(`  Butuh izin untuk ${req.tool}. Jalankan dengan --allow-all atau --allowed-tools ${req.kind}.
-`);
-    return "no";
-  };
-  const controller = new AbortController();
-  const onSigint = () => controller.abort();
-  process.once("SIGINT", onSigint);
-  try {
-    await rt.agent.run(prompt, controller.signal);
-  } finally {
-    process.off("SIGINT", onSigint);
-  }
-  if (wroteText) io.out.write("\n");
-  return failed ? 1 : 0;
-}
-
 // src/permissions.ts
 import { isAbsolute, relative, resolve, sep } from "path";
 var MODE_ORDER = ["default", "acceptEdits", "plan", "allowAll"];
@@ -95,6 +42,7 @@ var Permissions = class {
       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) {
@@ -107,36 +55,16 @@ var Permissions = class {
     if (req.kind === "edit" && this.mode === "acceptEdits") return "allow";
     return needed.every((rule) => this.rules.has(rule)) ? "allow" : "ask";
   }
+  revoke(rule) {
+    this.rules.delete(rule);
+  }
   allowForSession(req) {
     for (const rule of this.rulesFor(req) ?? []) this.rules.add(rule);
   }
 };
 
-// src/tools/ignore.ts
-import { readFileSync } from "fs";
-import { join } from "path";
-function ignorePatterns(root) {
-  const patterns = ["**/node_modules/**", "**/.git/**"];
-  let lines = [];
-  try {
-    lines = readFileSync(join(root, ".gitignore"), "utf8").split(/\r?\n/);
-  } catch {
-    return patterns;
-  }
-  for (const raw of lines) {
-    const line = raw.trim();
-    if (!line || line.startsWith("#") || line.startsWith("!")) continue;
-    const p = line.replace(/^\//, "").replace(/\/$/, "");
-    patterns.push(`**/${p}`, `**/${p}/**`);
-  }
-  return patterns;
-}
-
 export {
   MODE_ORDER,
   nextMode,
-  Permissions,
-  toolLabel,
-  runPrint,
-  ignorePatterns
+  Permissions
 };

package/dist/chunk-E4BWUMQ2.js

@@ -0,0 +1,52 @@
+#!/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-7QNAYIFT.js");
+  const { parseCliArgs } = await import("./args-EVIFNGPQ.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
+};

package/dist/chunk-MANM7HY6.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+import {
+  hasKey,
+  providerName,
+  removeGlobalProvider,
+  writeGlobalConfig
+} from "./chunk-5C6NQFSI.js";
+import {
+  PRESETS,
+  loadConfig,
+  readCredentials,
+  saveCredential
+} from "./chunk-Z5JM76EL.js";
+
+// src/provider.ts
+var ProviderError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var retryable = (status) => status === 429 || status >= 500;
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+      },
+      { once: true }
+    );
+  });
+}
+function errorMessage(body) {
+  try {
+    const parsed = JSON.parse(body);
+    return parsed?.error?.message ?? parsed?.message ?? body.slice(0, 300);
+  } catch {
+    return body.slice(0, 300);
+  }
+}
+var toUsage = (u) => u ? { inputTokens: u.prompt_tokens ?? 0, outputTokens: u.completion_tokens ?? 0 } : void 0;
+async function readStream(res, onText) {
+  let text = "";
+  let usage;
+  let finishReason;
+  const calls = [];
+  const byIndex = /* @__PURE__ */ new Map();
+  let current;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const handle = (line) => {
+    if (!line.startsWith("data:")) return;
+    const data = line.slice(5).trim();
+    if (!data || data === "[DONE]") return;
+    let event;
+    try {
+      event = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (event.error) throw new ProviderError(`Error dari provider: ${event.error.message ?? JSON.stringify(event.error)}`);
+    if (event.usage) usage = toUsage(event.usage);
+    const choice = event.choices?.[0];
+    if (!choice) return;
+    if (choice.finish_reason) finishReason = choice.finish_reason;
+    const delta = choice.delta ?? {};
+    if (delta.content) {
+      text += delta.content;
+      onText?.(delta.content);
+    }
+    for (const tc of delta.tool_calls ?? []) {
+      let target = tc.index !== void 0 ? byIndex.get(tc.index) : current;
+      if (!target || tc.index === void 0 && tc.id && target.id && target.id !== tc.id) {
+        target = { id: "", name: "", arguments: "" };
+        calls.push(target);
+        if (tc.index !== void 0) byIndex.set(tc.index, target);
+      }
+      current = target;
+      if (tc.id) target.id = tc.id;
+      if (tc.function?.name && !target.name) target.name = tc.function.name;
+      if (tc.function?.arguments) target.arguments += tc.function.arguments;
+    }
+  };
+  for await (const chunk of res.body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let newline = buffer.indexOf("\n");
+    while (newline >= 0) {
+      handle(buffer.slice(0, newline).trim());
+      buffer = buffer.slice(newline + 1);
+      newline = buffer.indexOf("\n");
+    }
+  }
+  handle(buffer.trim());
+  const toolCalls = calls.map((call, index) => ({ ...call, id: call.id || `call_${index}` }));
+  return { text, toolCalls, usage, finishReason };
+}
+async function readJson(res) {
+  const body = await res.json();
+  const choice = body.choices?.[0];
+  const toolCalls = (choice?.message?.tool_calls ?? []).map((tc, i) => ({
+    id: tc.id || `call_${i}`,
+    name: tc.function?.name ?? "",
+    arguments: tc.function?.arguments ?? ""
+  }));
+  return { text: choice?.message?.content ?? "", toolCalls, usage: toUsage(body.usage), finishReason: choice?.finish_reason };
+}
+function createProvider({ baseURL, apiKey, model, fetch: doFetch = fetch, retryDelayMs = 1e3 }) {
+  const headers = { "content-type": "application/json" };
+  if (apiKey) headers.authorization = `Bearer ${apiKey}`;
+  async function post(path, body, signal) {
+    let lastError;
+    for (let attempt = 0; attempt < 4; attempt++) {
+      if (attempt > 0) await sleep(retryDelayMs * 2 ** (attempt - 1), signal);
+      let res;
+      try {
+        res = await doFetch(`${baseURL}${path}`, { method: "POST", headers, body: JSON.stringify(body), signal });
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        lastError = new ProviderError(`Tidak bisa terhubung ke ${baseURL}: ${error.message}`);
+        continue;
+      }
+      if (res.ok) return res;
+      const text = await res.text().catch(() => "");
+      lastError = new ProviderError(`${res.status} dari ${baseURL}: ${errorMessage(text)}`, res.status);
+      if (!retryable(res.status)) throw lastError;
+    }
+    throw lastError ?? new ProviderError("Permintaan gagal");
+  }
+  return {
+    async chat({ messages, tools, signal, onText }) {
+      const res = await post(
+        "/chat/completions",
+        { model, messages, stream: true, stream_options: { include_usage: true }, ...tools?.length ? { tools } : {} },
+        signal
+      );
+      if ((res.headers.get("content-type") ?? "").includes("application/json")) return readJson(res);
+      if (!res.body) throw new ProviderError("Respons provider kosong");
+      return readStream(res, onText);
+    },
+    async listModels() {
+      const res = await doFetch(`${baseURL}/models`, { headers });
+      if (!res.ok) throw new ProviderError(`${res.status} saat mengambil daftar model`, res.status);
+      const body = await res.json();
+      return (body.data ?? []).map((m) => m.id).sort();
+    }
+  };
+}
+
+// src/models.ts
+function order(ids) {
+  const presetIds = PRESETS.map((p) => p.id);
+  const presets = presetIds.filter((id) => ids.includes(id));
+  const custom = ids.filter((id) => !presetIds.includes(id)).sort();
+  return [...presets, ...custom];
+}
+async function listAllModels(config, env = process.env, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const baseFetch = opts.fetch ?? fetch;
+  const untrusted = new Set(config.projectProviders ?? []);
+  const ids = order(Object.keys(config.providers)).filter((id) => opts.only ? id === opts.only : !untrusted.has(id) && hasKey(config, id, env));
+  const results = await Promise.all(
+    ids.map(async (id) => {
+      const provider = config.providers[id];
+      const apiKey = (opts.keyOverride && id === opts.only ? opts.keyOverride : void 0) || (provider.apiKeyEnv ? env[provider.apiKeyEnv] : void 0) || readCredentials(env)[id] || void 0;
+      const local = !provider.apiKeyEnv;
+      const timedFetch = ((input, init) => baseFetch(input, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
+      const list = createProvider({ baseURL: provider.baseURL.replace(/\/+$/, ""), apiKey, model: "", fetch: timedFetch }).listModels();
+      let timer;
+      const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("timeout")), timeoutMs);
+      });
+      try {
+        const models = await Promise.race([list, timeout]);
+        return { providerId: id, providerName: providerName(config, id), models };
+      } catch {
+        if (local && !opts.only) return void 0;
+        return { providerId: id, providerName: providerName(config, id), models: [], error: "tidak bisa dihubungi" };
+      } finally {
+        clearTimeout(timer);
+      }
+    })
+  );
+  return results.filter((g) => !!g);
+}
+
+// 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: `API key ditolak atau ${providerName(config, providerId)} tidak bisa dihubungi.` };
+  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(`Pemakaian: bccli provider ${action} <id>`);
+    return 1;
+  }
+  if (action === "remove") {
+    removeGlobalProvider(id, deps.env);
+    deps.out(`${id} dihapus.`);
+    return 0;
+  }
+  if (action !== "add") {
+    deps.err(`Aksi tidak dikenal: ${action}. Pakai list, add, atau remove.`);
+    return 1;
+  }
+  const preset = PRESETS.find((p) => p.id === id);
+  if (!preset && !config.providers[id]) {
+    if (!args.url) {
+      deps.err(`${id} bukan preset. Untuk provider custom tambahkan --url <base URL OpenAI-compatible>.`);
+      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(`API key untuk ${id} (kosongkan bila tidak perlu): `) : "";
+  const result = await addProviderKey(id, key, deps);
+  if (!result.ok) {
+    deps.err(result.error);
+    return 1;
+  }
+  deps.out(`${id} siap. ${result.models} model tersedia.`);
+  return 0;
+}
+
+export {
+  createProvider,
+  listAllModels,
+  addProviderKey,
+  runProviderCommand
+};

package/dist/chunk-RDQ7HPWS.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import {
+  MODE_ORDER
+} from "./chunk-5XN44Q55.js";
+import {
+  ConfigError
+} from "./chunk-Z5JM76EL.js";
+
+// src/args.ts
+import { parseArgs } from "util";
+var HELP_TEXT = `BCCLI \u2014 agent AI BotConnector di terminal
+
+Pemakaian:
+  bccli [tugas]                 mode interaktif (opsional langsung dengan tugas)
+  bccli -p "tugas"              jalankan satu tugas tanpa interaksi (skrip/CI)
+  bccli login [provider]        simpan API key (default: bc-cloud)
+  bccli models                  daftar model dari provider aktif
+  bccli provider list|add <id>|remove <id>   kelola provider (custom: --url <url> [--name N] [--key-env ENV])
+  bccli mcp list|add <nama>|remove <nama>    kelola server MCP (katalog, atau --url <url>)
+
+Opsi:
+  -m, --model <provider/model>  pilih model, contoh bc-cloud/glm-5.3-flash
+  -c, --continue                lanjutkan sesi terakhir di folder ini
+  -r, --resume                  pilih sesi untuk dilanjutkan
+      --allow-all               jalankan semua alat tanpa minta izin
+      --allowed-tools <a,b>     alat yang boleh tanpa izin: bash, edit, fetch
+      --permission-mode <mode>  default | acceptEdits | plan | allowAll
+  -v, --version                 versi
+  -h, --help                    bantuan ini`;
+function parseCliArgs(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      print: { type: "boolean", short: "p" },
+      model: { type: "string", short: "m" },
+      continue: { type: "boolean", short: "c" },
+      resume: { type: "boolean", short: "r" },
+      "allow-all": { type: "boolean" },
+      "allowed-tools": { 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 }
+    }
+  });
+  const mode = values["permission-mode"];
+  if (mode && !MODE_ORDER.includes(mode)) {
+    throw new ConfigError(`--permission-mode harus salah satu dari: ${MODE_ORDER.join(", ")}`);
+  }
+  const [first, ...rest] = positionals;
+  const SUBCOMMANDS = ["login", "models", "provider", "mcp"];
+  const command = SUBCOMMANDS.includes(first) ? first : "run";
+  const words = command === "run" ? positionals : rest;
+  return {
+    command,
+    prompt: command === "run" && words.length ? words.join(" ") : void 0,
+    print: !!values.print,
+    model: values.model,
+    continue: !!values.continue,
+    resume: !!values.resume,
+    allowAll: !!values["allow-all"],
+    allowedTools: (values["allowed-tools"] ?? "").split(",").map((s) => s.trim()).filter(Boolean),
+    permissionMode: mode,
+    help: !!values.help,
+    version: !!values.version,
+    loginProvider: command === "login" ? rest[0] ?? "bc-cloud" : void 0,
+    subArgs: command === "provider" || command === "mcp" ? rest : [],
+    url: values.url,
+    name: values.name,
+    keyEnv: values["key-env"],
+    values: values.value ?? []
+  };
+}
+
+export {
+  HELP_TEXT,
+  parseCliArgs
+};