@botozap/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { Command } from "commander";
+import pc from "picocolors";
+import { resolveFormat } from "./output.js";
+import { renderErrorText, renderErrorJson } from "./render-error.js";
+import { registerMessages } from "./commands/messages.js";
+import { registerConversations } from "./commands/conversations.js";
+import { registerContacts } from "./commands/contacts.js";
+import { registerMedia } from "./commands/media.js";
+import { registerCustomers } from "./commands/customers.js";
+import { registerSetupLinks } from "./commands/setup-links.js";
+import { registerNumbers } from "./commands/numbers.js";
+import { registerTemplates } from "./commands/templates.js";
+import { registerWebhooks } from "./commands/webhooks.js";
+import { registerDeliveries } from "./commands/deliveries.js";
+import { registerLogs } from "./commands/logs.js";
+import { registerUsers } from "./commands/users.js";
+import { registerConfig } from "./commands/config.js";
+import { registerStatus } from "./commands/status.js";
+import { registerLogin } from "./commands/login.js";
+const { version: VERSION } = createRequire(import.meta.url)("../package.json");
+const program = new Command();
+program
+    .name("botozap")
+    .description("CLI dev-first do BotoZap — WhatsApp Cloud API multi-tenant (a Kapso brasileira).")
+    .version(VERSION, "-v, --version", "mostra a versão")
+    .option("--api-key <chave>", "API key (sobrepõe env e config; prefira BOTOZAP_API_KEY ou `botozap login` — argv fica no histórico do shell)")
+    .option("--api-url <url>", "URL base da API (sobrepõe env e config)")
+    .option("-o, --output <formato>", "formato de saída: human | json", "human")
+    .showHelpAfterError("(use --help para ver as opções)");
+// Captura o formato de saída resolvido (flag global -o/--output) antes de cada
+// ação, para o handler central de erro renderizar human vs. json de forma
+// consistente com o que o comando usaria. `preAction` só roda para comandos com
+// ação (não para --help/--version), então não altera esses caminhos.
+let selectedFormat = "human";
+program.hook("preAction", (_thisCommand, actionCommand) => {
+    selectedFormat = resolveFormat(actionCommand.optsWithGlobals().output);
+});
+// Recursos
+registerMessages(program);
+registerConversations(program);
+registerContacts(program);
+registerMedia(program);
+registerCustomers(program);
+registerSetupLinks(program);
+registerNumbers(program);
+registerTemplates(program);
+registerWebhooks(program);
+registerDeliveries(program);
+registerLogs(program);
+registerUsers(program);
+// Sessão / utilidades
+registerLogin(program);
+registerConfig(program);
+registerStatus(program);
+async function main() {
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (err) {
+        // Erros (incl. o objeto json estruturado) vão para stderr — stdout fica
+        // reservado à saída de sucesso, para não poluir um `-o json` consumido por
+        // script. Exit code uniforme = 1 é decisão de design.
+        if (selectedFormat === "json") {
+            process.stderr.write(JSON.stringify(renderErrorJson(err), null, 2) + "\n");
+        }
+        else {
+            process.stderr.write(pc.red(renderErrorText(err)) + "\n");
+        }
+        process.exit(1);
+    }
+}
+void main();

package/dist/output.js

@@ -0,0 +1,101 @@
+import pc from "picocolors";
+/** Resolve o formato a partir do valor da flag `-o/--output`. */
+export function resolveFormat(value) {
+    return value === "json" ? "json" : "human";
+}
+/** Imprime JSON cru (indentado) — modo `--output json` para scripting. */
+export function printJson(value) {
+    process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+/** Mensagem informativa simples (stderr não; vai pro stdout). */
+export function printLine(line) {
+    process.stdout.write(line + "\n");
+}
+export function dim(text) {
+    return pc.dim(text);
+}
+function valueToString(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}
+function truncate(text, max = 48) {
+    const flat = text.replace(/\s+/g, " ");
+    return flat.length > max ? flat.slice(0, max - 1) + "…" : flat;
+}
+function pick(row, key) {
+    if (!key.includes("."))
+        return row[key];
+    return key.split(".").reduce((acc, part) => {
+        if (acc && typeof acc === "object") {
+            return acc[part];
+        }
+        return undefined;
+    }, row);
+}
+/** Tabela compacta de largura fixa para o modo `human`. */
+export function printTable(rows, columns) {
+    if (rows.length === 0) {
+        printLine(dim("(nenhum resultado)"));
+        return;
+    }
+    const cells = rows.map((row) => columns.map((col) => {
+        const raw = pick(row, col.key);
+        const str = col.format ? col.format(raw, row) : valueToString(raw);
+        return truncate(str, col.max ?? 48);
+    }));
+    const widths = columns.map((col, i) => {
+        const headerLen = col.header.length;
+        const maxCell = cells.reduce((w, r) => Math.max(w, (r[i] ?? "").length), 0);
+        return Math.max(headerLen, maxCell);
+    });
+    const headerLine = columns
+        .map((col, i) => pc.bold(col.header.padEnd(widths[i] ?? 0)))
+        .join("  ");
+    printLine(headerLine);
+    for (const row of cells) {
+        printLine(row.map((cell, i) => cell.padEnd(widths[i] ?? 0)).join("  "));
+    }
+}
+/** Pares chave/valor para detalhe de um único recurso (modo `human`). */
+export function printDetail(obj, keys) {
+    const entries = keys
+        ? keys.map((k) => [k, pick(obj, k)])
+        : Object.entries(obj);
+    const width = Math.max(...entries.map(([k]) => k.length));
+    for (const [key, value] of entries) {
+        if (value === undefined)
+            continue;
+        printLine(`${pc.bold(key.padEnd(width))}  ${valueToString(value)}`);
+    }
+}
+/** Rodapé de paginação por cursor. */
+export function printCursorFooter(paging) {
+    if (!paging)
+        return;
+    const after = paging.cursors?.after;
+    const before = paging.cursors?.before;
+    const parts = [];
+    if (after)
+        parts.push(`próxima: --after ${after}`);
+    if (before)
+        parts.push(`anterior: --before ${before}`);
+    if (parts.length)
+        printLine(dim(parts.join("   ")));
+}
+/** Rodapé de paginação por offset. */
+export function printOffsetFooter(meta) {
+    if (!meta)
+        return;
+    const { page, total_pages, total_count } = meta;
+    const bits = [];
+    if (page !== undefined && total_pages !== undefined) {
+        bits.push(`página ${page}/${total_pages}`);
+    }
+    if (total_count !== undefined)
+        bits.push(`${total_count} no total`);
+    if (bits.length)
+        printLine(dim(bits.join("   ")));
+}

package/dist/render-error.js

@@ -0,0 +1,100 @@
+import { BotoZapError, ConfigError } from "./client.js";
+function lowerKeys(h) {
+    const out = {};
+    for (const [k, v] of Object.entries(h))
+        out[k.toLowerCase()] = v;
+    return out;
+}
+/**
+ * Extrai `Retry-After`/`X-RateLimit-*` de um `BotoZapError` 429. Só nesse caso —
+ * fora dele os headers não têm significado de rate-limit. Vazio se ausentes.
+ * Lookup case-insensitive (o SDK guarda em minúsculas, mas não dependemos disso).
+ */
+export function rateLimitInfo(err) {
+    if (err.status !== 429 || !err.headers)
+        return {};
+    const h = lowerKeys(err.headers);
+    const info = {};
+    if (h["retry-after"] !== undefined)
+        info.retryAfter = h["retry-after"];
+    if (h["x-ratelimit-limit"] !== undefined)
+        info.limit = h["x-ratelimit-limit"];
+    if (h["x-ratelimit-remaining"] !== undefined) {
+        info.remaining = h["x-ratelimit-remaining"];
+    }
+    if (h["x-ratelimit-reset"] !== undefined)
+        info.reset = h["x-ratelimit-reset"];
+    return info;
+}
+function hasAny(info) {
+    return (info.retryAfter !== undefined ||
+        info.limit !== undefined ||
+        info.remaining !== undefined ||
+        info.reset !== undefined);
+}
+/** Sufixo humano com os dados do 429 (só o que veio nos headers). */
+function rateLimitSuffix(info) {
+    const parts = [];
+    // Mostra o valor CRU de Retry-After (a spec HTTP permite segundos OU data;
+    // não afirmamos a unidade). Os contadores são informativos.
+    if (info.retryAfter !== undefined)
+        parts.push(`Retry-After: ${info.retryAfter}`);
+    if (info.remaining !== undefined)
+        parts.push(`restantes: ${info.remaining}`);
+    if (info.limit !== undefined)
+        parts.push(`limite: ${info.limit}`);
+    if (info.reset !== undefined)
+        parts.push(`reset: ${info.reset}`);
+    return parts.length ? ` — ${parts.join(", ")}` : "";
+}
+/**
+ * Texto humano de um erro. Base preservada:
+ *   - `BotoZapError` → `Erro [code]: message`
+ *   - `ConfigError`/genérico → `Erro: message`
+ * Num 429, ACRESCENTA (não reformata) o sufixo de rate-limit ao fim.
+ */
+export function renderErrorText(err) {
+    if (err instanceof BotoZapError) {
+        const suffix = err.status === 429 ? rateLimitSuffix(rateLimitInfo(err)) : "";
+        return `Erro [${err.code}]: ${err.message}${suffix}`;
+    }
+    if (err instanceof ConfigError)
+        return `Erro: ${err.message}`;
+    const message = err instanceof Error ? err.message : String(err);
+    return `Erro: ${message}`;
+}
+/**
+ * Objeto de erro estruturado para `-o json` (envelope `{ error: {...} }`, o
+ * mesmo shape da API). Num 429 inclui `rate_limit` com os campos presentes.
+ */
+export function renderErrorJson(err) {
+    if (err instanceof BotoZapError) {
+        const info = rateLimitInfo(err);
+        return {
+            error: {
+                code: err.code,
+                message: err.message,
+                status: err.status,
+                ...(hasAny(info)
+                    ? {
+                        rate_limit: {
+                            ...(info.retryAfter !== undefined
+                                ? { retry_after: info.retryAfter }
+                                : {}),
+                            ...(info.limit !== undefined ? { limit: info.limit } : {}),
+                            ...(info.remaining !== undefined
+                                ? { remaining: info.remaining }
+                                : {}),
+                            ...(info.reset !== undefined ? { reset: info.reset } : {}),
+                        },
+                    }
+                    : {}),
+            },
+        };
+    }
+    if (err instanceof ConfigError) {
+        return { error: { code: "config_error", message: err.message } };
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return { error: { code: "error", message } };
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@botozap/cli",
+  "version": "0.1.0",
+  "description": "CLI dev-first para a API pública do BotoZap (WhatsApp Cloud API multi-tenant).",
+  "license": "MIT",
+  "type": "module",
+  "homepage": "https://botozap.com.br",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bytecraft-fernando/botozap-js.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/bytecraft-fernando/botozap-js/issues"
+  },
+  "bin": {
+    "botozap": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.19"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "picocolors": "^1.1.1",
+    "@botozap/sdk": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.0",
+    "typescript": "^5.6.0",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "start": "node dist/index.js"
+  }
+}