@botozap/cli 0.1.0

package/dist/commands/logs.js

@@ -0,0 +1,38 @@
+import { context, toInt } from "./shared.js";
+import { printJson, printTable, printCursorFooter } from "../output.js";
+export function registerLogs(program) {
+    const logs = program
+        .command("logs")
+        .description("Logs de requisições à API (api_logs)");
+    logs
+        .command("list")
+        .description("Lista logs de API (paginação por cursor)")
+        .option("--source <fonte>", "filtra por fonte")
+        .option("--method <metodo>", "filtra por método HTTP")
+        .option("--status-code <codigo>", "filtra por status HTTP")
+        .option("--limit <n>", "quantidade por página")
+        .option("--after <cursor>", "cursor da próxima página")
+        .option("--before <cursor>", "cursor da página anterior")
+        .action(async (opts, cmd) => {
+        const { client, format } = context(cmd);
+        const res = await client.apiLogs.list({
+            source: opts.source,
+            method: opts.method,
+            status_code: toInt(opts.statusCode),
+            limit: toInt(opts.limit),
+            after: opts.after,
+            before: opts.before,
+        });
+        if (format === "json")
+            return printJson(res);
+        printTable(res.data, [
+            { header: "ID", key: "id", max: 36 },
+            { header: "MÉTODO", key: "method" },
+            { header: "ROTA", key: "path", max: 40 },
+            { header: "STATUS", key: "status_code" },
+            { header: "FONTE", key: "source" },
+            { header: "CRIADO", key: "created_at" },
+        ]);
+        printCursorFooter(res.paging);
+    });
+}

package/dist/commands/media.js

@@ -0,0 +1,28 @@
+import { context } from "./shared.js";
+import { printJson, printDetail, printLine } from "../output.js";
+export function registerMedia(program) {
+    const media = program.command("media").description("Ingestão de mídia");
+    media
+        .command("ingest")
+        .description("Ingere uma mídia a partir de uma URL")
+        .requiredOption("--phone-number-id <id>", "número de origem (obrigatório)")
+        .requiredOption("--source <url>", "URL pública da mídia (obrigatório)")
+        .option("--filename <nome>", "nome do arquivo")
+        .option("--mime-type <tipo>", "tipo MIME (ex.: image/jpeg)")
+        .option("--delivery <modo>", "modo de entrega")
+        .action(async (opts, cmd) => {
+        const { client, format } = context(cmd);
+        const data = await client.media.upload({
+            phone_number_id: opts.phoneNumberId,
+            source: opts.source,
+            filename: opts.filename,
+            mime_type: opts.mimeType,
+            // A rota valida o valor; aqui só repassamos a string do flag.
+            delivery: opts.delivery,
+        });
+        if (format === "json")
+            return printJson(data);
+        printLine("Mídia ingerida.");
+        printDetail(data);
+    });
+}

package/dist/commands/messages.js

@@ -0,0 +1,113 @@
+import { readFileSync } from "node:fs";
+import { context, toInt } from "./shared.js";
+import { printJson, printTable, printDetail, printCursorFooter, printLine, } from "../output.js";
+/** Lê JSON cru de um arquivo (--input) ou do stdin (--stdin). */
+function readRawBody(file, fromStdin) {
+    let raw;
+    if (file) {
+        raw = readFileSync(file, "utf8");
+    }
+    else if (fromStdin) {
+        raw = readFileSync(0, "utf8");
+    }
+    else {
+        throw new Error("Nenhuma fonte de payload informada.");
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error("O payload informado não é um JSON válido.");
+    }
+}
+export function registerMessages(program) {
+    const messages = program
+        .command("messages")
+        .description("Enviar e consultar mensagens de WhatsApp");
+    messages
+        .command("send")
+        .description("Envia uma mensagem (texto simples ou payload completo)")
+        .option("--to <wa_id>", "destinatário (número E.164 sem +, ex.: 5511999999999)")
+        .option("--text <body>", "corpo de uma mensagem de texto")
+        .option("--from <phone_number_id>", "número de origem (opcional)")
+        .option("--input <arquivo>", "arquivo JSON com o corpo bruto da mensagem")
+        .option("--stdin", "lê o corpo bruto da mensagem do stdin")
+        .action(async (opts, cmd) => {
+        const { client, format } = context(cmd);
+        // POST /messages responde o objeto DIRETO (sem envelope `data`); ambos os
+        // caminhos devolvem o mesmo shape { id, wamid, to, status }.
+        let result;
+        if (opts.input || opts.stdin) {
+            // Payload cru: contrato de baixo nível do SDK (`request`), sem montar o corpo.
+            const body = readRawBody(opts.input, opts.stdin);
+            result = await client.request("POST", "/messages", { body });
+        }
+        else {
+            if (!opts.to || !opts.text) {
+                throw new Error("Informe --to e --text, ou use --input <arquivo.json> / --stdin para payload completo.");
+            }
+            result = await client.messages.send({
+                to: opts.to,
+                text: opts.text,
+                ...(opts.from ? { from: opts.from } : {}),
+            });
+        }
+        if (format === "json")
+            return printJson(result);
+        printLine("Mensagem enfileirada.");
+        printDetail(result, [
+            "id",
+            "wamid",
+            "to",
+            "status",
+        ]);
+    });
+    messages
+        .command("list")
+        .description("Lista mensagens (paginação por cursor)")
+        .option("--phone-number-id <id>", "filtra por número")
+        .option("--conversation-id <id>", "filtra por conversa")
+        .option("--direction <dir>", "inbound | outbound")
+        .option("--status <status>", "status da mensagem")
+        .option("--message-type <tipo>", "tipo (text, image, template, …)")
+        .option("--has-media", "apenas mensagens com mídia")
+        .option("--limit <n>", "quantidade por página")
+        .option("--after <cursor>", "cursor da próxima página")
+        .option("--before <cursor>", "cursor da página anterior")
+        .action(async (opts, cmd) => {
+        const { client, format } = context(cmd);
+        const res = await client.messages.list({
+            phone_number_id: opts.phoneNumberId,
+            conversation_id: opts.conversationId,
+            direction: opts.direction,
+            status: opts.status,
+            message_type: opts.messageType,
+            has_media: opts.hasMedia ? true : undefined,
+            limit: toInt(opts.limit),
+            after: opts.after,
+            before: opts.before,
+        });
+        if (format === "json")
+            return printJson(res);
+        printTable(res.data, [
+            { header: "ID", key: "id", max: 36 },
+            { header: "DIREÇÃO", key: "direction" },
+            { header: "TIPO", key: "kind" },
+            { header: "STATUS", key: "status" },
+            { header: "DE", key: "from" },
+            { header: "PARA", key: "to" },
+            { header: "CRIADA", key: "created_at" },
+        ]);
+        printCursorFooter(res.paging);
+    });
+    messages
+        .command("get <id>")
+        .description("Detalha uma mensagem por UUID interno ou wamid")
+        .action(async (id, _opts, cmd) => {
+        const { client, format } = context(cmd);
+        const data = await client.messages.get(id);
+        if (format === "json")
+            return printJson(data);
+        printDetail(data);
+    });
+}

package/dist/commands/numbers.js

@@ -0,0 +1,51 @@
+import { context, toInt } from "./shared.js";
+import { printJson, printTable, printDetail, printOffsetFooter, } from "../output.js";
+export function registerNumbers(program) {
+    const numbers = program
+        .command("numbers")
+        .description("Números de telefone (WhatsApp) conectados");
+    numbers
+        .command("list")
+        .description("Lista números (paginação por offset)")
+        .option("--customer-id <id>", "filtra por cliente")
+        .option("--page <n>", "página")
+        .option("--per-page <n>", "itens por página")
+        .action(async (opts, cmd) => {
+        const { client, format } = context(cmd);
+        const res = await client.phoneNumbers.list({
+            customer_id: opts.customerId,
+            page: toInt(opts.page),
+            per_page: toInt(opts.perPage),
+        });
+        if (format === "json")
+            return printJson(res);
+        printTable(res.data, [
+            { header: "ID", key: "id", max: 36 },
+            { header: "NÚMERO", key: "display_phone_number" },
+            { header: "NOME", key: "verified_name" },
+            { header: "STATUS", key: "status" },
+            { header: "QUALIDADE", key: "quality_rating" },
+        ]);
+        printOffsetFooter(res.meta);
+    });
+    numbers
+        .command("get <id>")
+        .description("Detalha um número")
+        .action(async (id, _opts, cmd) => {
+        const { client, format } = context(cmd);
+        const data = await client.phoneNumbers.get(id);
+        if (format === "json")
+            return printJson(data);
+        printDetail(data);
+    });
+    numbers
+        .command("health <id>")
+        .description("Verifica a saúde de um número")
+        .action(async (id, _opts, cmd) => {
+        const { client, format } = context(cmd);
+        const data = await client.phoneNumbers.health(id);
+        if (format === "json")
+            return printJson(data);
+        printDetail(data);
+    });
+}

package/dist/commands/setup-links.js

@@ -0,0 +1,63 @@
+import { context, toInt } from "./shared.js";
+import { printJson, printTable, printDetail, printOffsetFooter, printLine, } from "../output.js";
+export function registerSetupLinks(program) {
+    const links = program
+        .command("setup-links")
+        .description("Links de configuração (Embedded Signup) de um cliente");
+    links
+        .command("list")
+        .description("Lista os setup links de um cliente (offset)")
+        .requiredOption("--customer <id>", "id do cliente (obrigatório)")
+        .option("--page <n>", "página")
+        .option("--per-page <n>", "itens por página")
+        .action(async (opts, cmd) => {
+        const { client, format } = context(cmd);
+        const res = await client.customers.listSetupLinks(opts.customer, {
+            page: toInt(opts.page),
+            per_page: toInt(opts.perPage),
+        });
+        if (format === "json")
+            return printJson(res);
+        printTable(res.data, [
+            { header: "ID", key: "id", max: 36 },
+            { header: "STATUS", key: "status" },
+            { header: "URL", key: "url", max: 60 },
+            { header: "EXPIRA", key: "expires_at" },
+        ]);
+        printOffsetFooter(res.meta);
+    });
+    links
+        .command("create")
+        .description("Cria um setup link para um cliente")
+        .requiredOption("--customer <id>", "id do cliente (obrigatório)")
+        .action(async (opts, cmd) => {
+        const { client, format } = context(cmd);
+        const data = await client.customers.createSetupLink(opts.customer);
+        if (format === "json")
+            return printJson(data);
+        printLine("Setup link criado.");
+        printDetail(data);
+    });
+    links
+        .command("update <linkId>")
+        .description("Atualiza um setup link (status / expiração)")
+        .requiredOption("--customer <id>", "id do cliente (obrigatório)")
+        .option("--status <status>", "novo status")
+        .option("--expires-at <data>", "nova expiração (ISO 8601)")
+        .action(async (linkId, opts, cmd) => {
+        const { client, format } = context(cmd);
+        const body = {};
+        if (opts.status !== undefined)
+            body.status = opts.status;
+        if (opts.expiresAt !== undefined)
+            body.expires_at = opts.expiresAt;
+        if (Object.keys(body).length === 0) {
+            throw new Error("Informe ao menos --status ou --expires-at.");
+        }
+        const data = await client.customers.updateSetupLink(opts.customer, linkId, body);
+        if (format === "json")
+            return printJson(data);
+        printLine("Setup link atualizado.");
+        printDetail(data);
+    });
+}

package/dist/commands/shared.js

@@ -0,0 +1,37 @@
+import { createClient } from "../client.js";
+import { resolveFormat } from "../output.js";
+/** Lê as flags globais (--api-key/--api-url/--output) de qualquer subcomando. */
+export function readGlobals(cmd) {
+    const opts = cmd.optsWithGlobals();
+    return {
+        apiKey: opts.apiKey,
+        apiUrl: opts.apiUrl,
+        output: opts.output,
+    };
+}
+/** Constrói client (SDK) + formato a partir do comando atual. */
+export function context(cmd) {
+    const g = readGlobals(cmd);
+    const global = { apiKey: g.apiKey, apiUrl: g.apiUrl };
+    return {
+        client: createClient(global),
+        format: resolveFormat(g.output),
+    };
+}
+/** Converte string para inteiro, ou undefined se vazio/ inválido. */
+export function toInt(value) {
+    if (value === undefined)
+        return undefined;
+    const n = Number.parseInt(value, 10);
+    return Number.isNaN(n) ? undefined : n;
+}
+/** Booleano a partir de string "true"/"false" (ou undefined). */
+export function toBool(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    return undefined;
+}

package/dist/commands/status.js

@@ -0,0 +1,32 @@
+import { createClient } from "../client.js";
+import { resolveAuth } from "../config.js";
+import { resolveFormat, printJson, printLine, dim } from "../output.js";
+import pc from "picocolors";
+export function registerStatus(program) {
+    program
+        .command("status")
+        .description("Verifica a autenticação e a conectividade com a API")
+        .action(async (_opts, cmd) => {
+        const g = cmd.optsWithGlobals();
+        const format = resolveFormat(g.output);
+        const auth = resolveAuth({ apiKey: g.apiKey, apiUrl: g.apiUrl });
+        const global = { apiKey: g.apiKey, apiUrl: g.apiUrl };
+        const client = createClient(global);
+        // Sonda leve: 1 número apenas confirma que a chave alcança a conta.
+        const res = await client.phoneNumbers.list({ per_page: 1 });
+        const total = res.meta?.total_count ?? res.data.length;
+        if (format === "json") {
+            return printJson({
+                ok: true,
+                base_url: auth.baseUrl,
+                api_key_source: auth.apiKeySource,
+                phone_numbers_total: total,
+            });
+        }
+        printLine(pc.green("Autenticado. Conta acessível."));
+        printLine(`URL base       ${auth.baseUrl}`);
+        printLine(`Origem da chave ${auth.apiKeySource}`);
+        printLine(`Números        ${total}`);
+        printLine(dim("Sonda: GET /phone_numbers?per_page=1"));
+    });
+}

package/dist/commands/templates.js

@@ -0,0 +1,87 @@
+import { readFileSync } from "node:fs";
+import { context, toInt } from "./shared.js";
+import { printJson, printTable, printDetail, printOffsetFooter, printLine, } from "../output.js";
+/** Lê e parseia JSON de um arquivo. */
+function readJsonFile(file) {
+    let raw;
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch {
+        throw new Error(`Não foi possível ler o arquivo: ${file}`);
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Arquivo não é JSON válido: ${file}`);
+    }
+}
+export function registerTemplates(program) {
+    const templates = program
+        .command("templates")
+        .description("Gerenciar templates de mensagem");
+    templates
+        .command("list")
+        .description("Lista templates (paginação por offset)")
+        .option("--status <status>", "filtra por status")
+        .option("--category <categoria>", "filtra por categoria")
+        .option("--phone-number-id <id>", "filtra por número")
+        .option("--page <n>", "página")
+        .option("--per-page <n>", "itens por página")
+        .action(async (opts, cmd) => {
+        const { client, format } = context(cmd);
+        const res = await client.templates.list({
+            status: opts.status,
+            category: opts.category,
+            phone_number_id: opts.phoneNumberId,
+            page: toInt(opts.page),
+            per_page: toInt(opts.perPage),
+        });
+        if (format === "json")
+            return printJson(res);
+        printTable(res.data, [
+            { header: "ID", key: "id", max: 36 },
+            { header: "NOME", key: "name" },
+            { header: "IDIOMA", key: "language" },
+            { header: "CATEGORIA", key: "category" },
+            { header: "STATUS", key: "status" },
+        ]);
+        printOffsetFooter(res.meta);
+    });
+    templates
+        .command("get <id>")
+        .description("Detalha um template")
+        .action(async (id, _opts, cmd) => {
+        const { client, format } = context(cmd);
+        const data = await client.templates.get(id);
+        if (format === "json")
+            return printJson(data);
+        printDetail(data);
+    });
+    templates
+        .command("create")
+        .description("Cria um template (componentes via --components arquivo.json)")
+        .requiredOption("--name <nome>", "nome do template")
+        .requiredOption("--language <idioma>", "código de idioma (ex.: pt_BR)")
+        .requiredOption("--category <categoria>", "categoria (MARKETING, UTILITY, …)")
+        .requiredOption("--components <arquivo>", "arquivo JSON com o array de componentes")
+        .option("--waba-connection-id <id>", "conexão WABA alvo")
+        .option("--phone-number-id <id>", "número alvo")
+        .action(async (opts, cmd) => {
+        const { client, format } = context(cmd);
+        const components = readJsonFile(opts.components);
+        const data = await client.templates.create({
+            name: opts.name,
+            language: opts.language,
+            category: opts.category,
+            components: components,
+            waba_connection_id: opts.wabaConnectionId,
+            phone_number_id: opts.phoneNumberId,
+        });
+        if (format === "json")
+            return printJson(data);
+        printLine("Template criado.");
+        printDetail(data);
+    });
+}

package/dist/commands/users.js

@@ -0,0 +1,28 @@
+import { context, toInt } from "./shared.js";
+import { printJson, printTable, printOffsetFooter } from "../output.js";
+export function registerUsers(program) {
+    const users = program
+        .command("users")
+        .description("Usuários do workspace");
+    users
+        .command("list")
+        .description("Lista usuários (paginação por offset)")
+        .option("--page <n>", "página")
+        .option("--per-page <n>", "itens por página")
+        .action(async (opts, cmd) => {
+        const { client, format } = context(cmd);
+        const res = await client.users.list({
+            page: toInt(opts.page),
+            per_page: toInt(opts.perPage),
+        });
+        if (format === "json")
+            return printJson(res);
+        printTable(res.data, [
+            { header: "ID", key: "id", max: 36 },
+            { header: "NOME", key: "name" },
+            { header: "EMAIL", key: "email" },
+            { header: "PAPEL", key: "role" },
+        ]);
+        printOffsetFooter(res.meta);
+    });
+}

package/dist/commands/webhooks.js

@@ -0,0 +1,116 @@
+import { context, toInt, toBool } from "./shared.js";
+import { printJson, printTable, printDetail, printCursorFooter, printLine, } from "../output.js";
+export function registerWebhooks(program) {
+    const webhooks = program
+        .command("webhooks")
+        .description("Gerenciar endpoints de webhook");
+    webhooks
+        .command("list")
+        .description("Lista webhooks (paginação por cursor)")
+        .option("--limit <n>", "quantidade por página")
+        .option("--after <cursor>", "cursor da próxima página")
+        .option("--before <cursor>", "cursor da página anterior")
+        .action(async (opts, cmd) => {
+        const { client, format } = context(cmd);
+        const res = await client.webhooks.list({
+            limit: toInt(opts.limit),
+            after: opts.after,
+            before: opts.before,
+        });
+        if (format === "json")
+            return printJson(res);
+        printTable(res.data, [
+            { header: "ID", key: "id", max: 36 },
+            { header: "URL", key: "url", max: 50 },
+            { header: "ATIVO", key: "active" },
+            { header: "EVENTOS", key: "events" },
+        ]);
+        printCursorFooter(res.paging);
+    });
+    webhooks
+        .command("get <id>")
+        .description("Detalha um webhook")
+        .action(async (id, _opts, cmd) => {
+        const { client, format } = context(cmd);
+        const data = await client.webhooks.get(id);
+        if (format === "json")
+            return printJson(data);
+        printDetail(data);
+    });
+    webhooks
+        .command("create")
+        .description("Cria um webhook")
+        .requiredOption("--url <url>", "URL de entrega (obrigatório)")
+        .requiredOption("--events <lista>", "eventos separados por vírgula (obrigatório)")
+        .option("--secret <segredo>", "segredo para assinar as entregas")
+        .option("--active <bool>", "true | false")
+        .action(async (opts, cmd) => {
+        const { client, format } = context(cmd);
+        const events = String(opts.events)
+            .split(",")
+            .map((e) => e.trim())
+            .filter(Boolean);
+        const data = await client.webhooks.create({
+            url: opts.url,
+            events,
+            secret: opts.secret,
+            active: toBool(opts.active),
+        });
+        if (format === "json")
+            return printJson(data);
+        printLine("Webhook criado.");
+        printDetail(data);
+    });
+    webhooks
+        .command("update <id>")
+        .description("Atualiza um webhook")
+        .option("--url <url>", "nova URL")
+        .option("--events <lista>", "novos eventos (separados por vírgula)")
+        .option("--secret <segredo>", "novo segredo")
+        .option("--active <bool>", "true | false")
+        .action(async (id, opts, cmd) => {
+        const { client, format } = context(cmd);
+        const body = {};
+        if (opts.url !== undefined)
+            body.url = opts.url;
+        if (opts.events !== undefined) {
+            body.events = String(opts.events)
+                .split(",")
+                .map((e) => e.trim())
+                .filter(Boolean);
+        }
+        if (opts.secret !== undefined)
+            body.secret = opts.secret;
+        if (opts.active !== undefined)
+            body.active = toBool(opts.active);
+        if (Object.keys(body).length === 0) {
+            throw new Error("Informe ao menos um campo para atualizar.");
+        }
+        const data = await client.webhooks.update(id, body);
+        if (format === "json")
+            return printJson(data);
+        printLine("Webhook atualizado.");
+        printDetail(data);
+    });
+    webhooks
+        .command("delete <id>")
+        .description("Remove um webhook")
+        .action(async (id, _opts, cmd) => {
+        const { client, format } = context(cmd);
+        await client.webhooks.delete(id);
+        if (format === "json")
+            return printJson({ deleted: true });
+        printLine("Webhook removido.");
+    });
+    webhooks
+        .command("test <id>")
+        .description("Dispara uma entrega de teste para o webhook")
+        .action(async (id, _opts, cmd) => {
+        const { client, format } = context(cmd);
+        const result = await client.webhooks.test(id);
+        if (format === "json")
+            return printJson(result);
+        printLine("Entrega de teste disparada.");
+        printDetail(result);
+    });
+}

package/dist/config.js

@@ -0,0 +1,77 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync, existsSync, chmodSync, } from "node:fs";
+/** URL base padrão da API pública do BotoZap. */
+export const DEFAULT_BASE_URL = "https://botozap.com.br/api/v1";
+/** Diretório de configuração: `~/.botozap/cli/`. */
+export function configDir() {
+    return join(homedir(), ".botozap", "cli");
+}
+/** Caminho do arquivo de configuração: `~/.botozap/cli/config.json`. */
+export function configPath() {
+    return join(configDir(), "config.json");
+}
+/** Lê o config do disco (ou objeto vazio se não existir/inválido). */
+export function readConfig() {
+    const path = configPath();
+    if (!existsSync(path))
+        return {};
+    try {
+        const raw = readFileSync(path, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Grava o config no disco, criando o diretório com permissão restrita. */
+export function writeConfig(config) {
+    const dir = configDir();
+    const path = configPath();
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    // Permissões restritas ANTES de gravar o segredo: `mode` do writeFileSync só
+    // vale na criação; num arquivo preexistente frouxo (ex.: legado 0644), gravar
+    // primeiro abriria uma janela em que a API key fica legível por outros
+    // usuários locais (TOCTOU). Endurece → escreve → reforça.
+    chmodSync(dir, 0o700);
+    if (existsSync(path))
+        chmodSync(path, 0o600);
+    writeFileSync(path, JSON.stringify(config, null, 2) + "\n", {
+        mode: 0o600,
+    });
+    chmodSync(path, 0o600);
+}
+/** Define uma chave individual no config persistido. */
+export function setConfigValue(key, value) {
+    const current = readConfig();
+    current[key] = value;
+    writeConfig(current);
+}
+/**
+ * Resolve credenciais com a prioridade documentada:
+ * apiKey:  --api-key  > BOTOZAP_API_KEY  > config.json
+ * baseUrl: --api-url  > BOTOZAP_API_URL  > config.json > DEFAULT_BASE_URL
+ */
+export function resolveAuth(opts) {
+    const stored = readConfig();
+    let apiKey;
+    let apiKeySource = "none";
+    if (opts.apiKey) {
+        apiKey = opts.apiKey;
+        apiKeySource = "flag";
+    }
+    else if (process.env.BOTOZAP_API_KEY) {
+        apiKey = process.env.BOTOZAP_API_KEY;
+        apiKeySource = "env";
+    }
+    else if (stored.apiKey) {
+        apiKey = stored.apiKey;
+        apiKeySource = "config";
+    }
+    const baseUrl = opts.apiUrl ||
+        process.env.BOTOZAP_API_URL ||
+        stored.baseUrl ||
+        DEFAULT_BASE_URL;
+    return { apiKey, baseUrl: baseUrl.replace(/\/+$/, ""), apiKeySource };
+}