kafox-cli 0.9.8 → 0.10.0

package/src/models.js

@@ -1,11 +1,16 @@
 const chalk = require("chalk");
 const storage = require("./storage");
 const { ensureSession, fetchApi } = require("./auth");
+const { listProviders } = require("./providers");
 
 function fmtBRL(micros) {
   return `${(micros / 1_000_000).toFixed(2)} R$`;
 }
 
+function fmtPrice(value) {
+  return value === null || value === undefined ? "—" : `R$ ${value.toFixed(2)}`;
+}
+
 async function listModels() {
   const res = await fetchApi("/api/public/pricing");
   if (!res.ok) {
@@ -19,6 +24,20 @@ async function listModels() {
     console.log(`  ${chalk.bold(p.model)}`);
   }
   console.log(chalk.dim(`\nGateway: ${data.gateway_url}`));
+
+  // Provedores alternativos (OpenAI-compatible) tem catalogo local com precos.
+  for (const provider of listProviders()) {
+    if (!provider.models?.length) continue;
+    console.log(chalk.cyan(`\n${provider.label} models (${provider.baseUrl}):\n`));
+    for (const model of provider.models) {
+      console.log(
+        `  ${chalk.bold(`${provider.id}/${model.id}`)}  ${chalk.dim(
+          `in ${fmtPrice(model.brl.in)} · out ${fmtPrice(model.brl.out)} · cache ${fmtPrice(model.brl.cache)}`
+        )}`
+      );
+    }
+  }
+  console.log("");
 }
 
 async function showBalance() {

package/src/providers-cli.js

@@ -0,0 +1,82 @@
+const chalk = require("chalk");
+const storage = require("./storage");
+const { listProviders, getProvider } = require("./providers");
+
+function fmtBrl(value) {
+  return value === null || value === undefined ? "—" : `R$ ${value.toFixed(2)}`;
+}
+
+/** Imprime a tabela de modelos de um provedor, em BRL por 1M tokens. */
+function printModels(provider) {
+  const models = provider.models || [];
+  if (!models.length) {
+    console.log(chalk.dim("  (sem catálogo local)"));
+    return;
+  }
+  console.log(chalk.bold(`\n  ${provider.label}  ${chalk.dim(provider.baseUrl || "")}`));
+  console.log(
+    chalk.dim(
+      `  ${"modelo".padEnd(44)} ${"in".padStart(9)} ${"out".padStart(9)} ${"cache".padStart(9)}  ctx`
+    )
+  );
+  for (const model of models) {
+    const id = model.id.length > 44 ? `${model.id.slice(0, 41)}...` : model.id;
+    const tools = model.tools ? "" : chalk.dim(" (sem tools)");
+    console.log(
+      `  ${id.padEnd(44)} ${fmtBrl(model.brl.in).padStart(9)} ${fmtBrl(model.brl.out).padStart(9)} ${fmtBrl(
+        model.brl.cache
+      ).padStart(9)}  ${model.ctx}${tools}`
+    );
+  }
+}
+
+/**
+ * `kafox provider` — lista provedores; `kafox provider <id> <chave>` guarda a
+ * chave; `kafox provider <id> --off` remove. A chave fica em
+ * ~/.kafox/config.json (provider_keys) ou na env `PROVIDER_API_KEY`.
+ */
+async function runProvider({ provider, chave, off, list } = {}) {
+  if (!provider || list) {
+    console.log(chalk.cyan("\nProvedores:\n"));
+    for (const item of listProviders()) {
+      const key = item.id === "kafox" ? "(conta kafox)" : storage.getProviderKey(item.id) ? "chave ok" : "sem chave";
+      console.log(`  ${chalk.bold(item.id.padEnd(8))} ${item.label.padEnd(10)} ${chalk.dim(key)}`);
+    }
+    for (const item of listProviders()) {
+      if (item.models?.length) printModels(item);
+    }
+    console.log(
+      chalk.dim("\nUse `kafox provider <id> <chave>` para registrar. Modelo no chat: `<id>/<modelo>`.\n")
+    );
+    return;
+  }
+
+  const target = getProvider(provider);
+  if (!target || target.id === "kafox") {
+    console.log(chalk.red(`\nProvedor desconhecido: ${provider}`));
+    console.log(chalk.dim("Veja `kafox provider` para a lista.\n"));
+    return;
+  }
+
+  if (off) {
+    storage.setProviderKey(target.id, null);
+    console.log(chalk.green(`\nChave de ${target.label} removida.\n`));
+    return;
+  }
+
+  if (!chave) {
+    const current = storage.getProviderKey(target.id);
+    console.log(
+      current
+        ? chalk.dim(`\n${target.label}: chave já salva. Use \`kafox provider ${target.id} <nova>\` para trocar.\n`)
+        : chalk.yellow(`\nInforme a chave: kafox provider ${target.id} <chave>\n`)
+    );
+    return;
+  }
+
+  storage.setProviderKey(target.id, chave.trim());
+  console.log(chalk.green(`\nChave de ${target.label} salva.`));
+  console.log(chalk.dim(`Use os modelos com: kafox --model ${target.id}/${target.models?.[0]?.id || "modelo"}\n`));
+}
+
+module.exports = { runProvider, printModels };

package/src/providers.js

@@ -0,0 +1,87 @@
+/**
+ * Catalogo de provedores do kafox.
+ *
+ * O caminho normal e o proprio gateway kafox (`kafox`), servido em
+ * `${api_url}/api/chat`. Os modelos "sem censura" e os pagos tambem passam por
+ * ele: quem atende por baixo e assunto do backend, e o cliente nunca ve a chave
+ * nem o provedor de origem.
+ *
+ * A estrutura abaixo continua generica para provedores alternativos
+ * OpenAI-compatible: se um dia alguem registrar um, a CLI chama
+ * `{base_url}/chat/completions` direto, com a chave do usuario. Hoje so existe
+ * o kafox, entao nada disso e usado no fluxo padrao.
+ *
+ * Cada modelo guarda o preco em USD (fonte) e em BRL (o que a gente cobra).
+ * Regra da casa: BRL = USD * USD_BRL * MARKUP, arredondado a 2 casas.
+ */
+const USD_BRL = 5.35;
+const MARKUP = 2;
+
+/** Converte um preco em USD por 1M tokens para o preco cobrado em BRL. */
+function usdToBrl(usd) {
+  if (usd === null || usd === undefined) return null;
+  return Math.round(usd * USD_BRL * MARKUP * 100) / 100;
+}
+
+const PROVIDERS = {
+  kafox: {
+    id: "kafox",
+    label: "Kafox",
+    kind: "kafox",
+    baseUrl: null, // resolvido do api_url em ~/.kafox/config.json
+    envKey: "KAFOX_API_KEY",
+  },
+};
+
+/** Lista os provedores (com os modelos, quando conhecidos offline). */
+function listProviders() {
+  return Object.values(PROVIDERS);
+}
+
+function getProvider(id) {
+  return PROVIDERS[id] || null;
+}
+
+/**
+ * Descobre a qual provedor um modelo pertence, olhando os ids conhecidos.
+ * Prefixo explicito "provedor/modelo" (ex.: "acme/modelo-x") vence.
+ */
+function providerForModel(model) {
+  const raw = String(model || "").trim();
+  if (!raw) return { provider: PROVIDERS.kafox, model: raw };
+  const slash = raw.indexOf("/");
+  if (slash > 0) {
+    const candidate = PROVIDERS[raw.slice(0, slash)];
+    if (candidate) return { provider: candidate, model: raw.slice(slash + 1) };
+  }
+  for (const provider of Object.values(PROVIDERS)) {
+    if ((provider.models || []).some((item) => item.id === raw)) {
+      return { provider, model: raw };
+    }
+  }
+  return { provider: PROVIDERS.kafox, model: raw };
+}
+
+/** Ficha do modelo conhecido (nome, precos, contexto) ou null. */
+function findModel(model) {
+  const { provider, model: bare } = providerForModel(model);
+  return (provider.models || []).find((item) => item.id === bare) || null;
+}
+
+/** Preco cobrado do modelo, em BRL por 1M tokens. */
+function modelCost(model) {
+  const info = findModel(model);
+  return info ? info.brl : null;
+}
+
+module.exports = {
+  USD_BRL,
+  MARKUP,
+  usdToBrl,
+  PROVIDERS,
+  listProviders,
+  getProvider,
+  providerForModel,
+  findModel,
+  modelCost,
+};

package/src/storage.js

@@ -31,6 +31,22 @@ function getApiUrl() {
   return cfg.api_url || process.env.KAFOX_API_URL || "https://backend.kafox.dev";
 }
 
+/**
+ * Hosts alternativos para a API, na ordem de tentativa. Todos apontam para o
+ * MESMO backend (o Caddy serve backend.kafox.dev e back.kafox.dev iguais).
+ * Serve para o login nao morrer quando um nome estiver com DNS/cache ruim:
+ * se o primeiro der timeout/conexao recusada, tenta o proximo.
+ */
+function apiUrlCandidates() {
+  const primary = getApiUrl();
+  const list = [primary];
+  // Fallbacks conhecidos do mesmo backend (so quando o host e kafox.dev).
+  if (/\/\/backend\.kafox\.dev/.test(primary)) list.push(primary.replace("backend.kafox.dev", "back.kafox.dev"));
+  if (/\/\/backend\.kafox\.dev/.test(primary)) list.push(primary.replace("backend.kafox.dev", "api.kafox.dev"));
+  // Dedup preservando a ordem.
+  return [...new Set(list)];
+}
+
 /** Endereco do site (painel, login, documentacao) — a API mora em outro host. */
 function getWebUrl() {
   return process.env.KAFOX_WEB_URL || "https://kafox.dev";
@@ -51,6 +67,27 @@ function clearApiKey() {
   writeJSON(CONFIG_FILE, cfg);
 }
 
+/**
+ * Chaves de provedores alternativos: { <id>: "<chave>" }.
+ * O provedor padrao kafox usa `api_key` (criada pelo backend), nao entra aqui.
+ */
+function getProviderKeys() {
+  const cfg = readJSON(CONFIG_FILE, {});
+  return { ...(cfg.provider_keys || {}) };
+}
+function getProviderKey(provider) {
+  const env = process.env[`${String(provider || "").toUpperCase()}_API_KEY`];
+  if (env) return env;
+  return getProviderKeys()[provider] || null;
+}
+function setProviderKey(provider, key) {
+  const cfg = readJSON(CONFIG_FILE, {});
+  const keys = { ...(cfg.provider_keys || {}) };
+  if (key) keys[provider] = key;
+  else delete keys[provider];
+  writeJSON(CONFIG_FILE, { ...cfg, provider_keys: keys });
+}
+
 function getConfig() {
   return readJSON(CONFIG_FILE, {});
 }
@@ -98,5 +135,7 @@ module.exports = {
   DIR, TOKEN_FILE, CONFIG_FILE,
   ensureDir, readJSON, writeJSON,
   getApiUrl, getWebUrl, getToken, setToken, clearToken,
+  apiUrlCandidates,
   getConfig, setConfig, clearApiKey, getAuthHeaders, parseCookies,
+  getProviderKeys, getProviderKey, setProviderKey,
 };

package/src/tools.js

@@ -122,9 +122,20 @@ function toolMeta(name, hub) {
 
 function resolveInside(cwd, target) {
   const root = path.resolve(cwd);
-  const full = path.resolve(root, target || ".");
+  const raw = String(target ?? ".");
+  // Caminho absoluto de outro sistema (ex.: "C:\Windows\..." no Linux) e
+  // NUL nunca valem: sem isso o `path.resolve` trata como nome de arquivo.
+  if (raw.includes("\0")) throw new Error(`caminho invalido: ${raw}`);
+  if (path.win32.isAbsolute(raw) || path.posix.isAbsolute(raw)) {
+    const full = path.isAbsolute(raw) ? path.resolve(raw) : null;
+    if (!full || (full !== root && !full.startsWith(root + path.sep))) {
+      throw new Error(`caminho fora do diretorio de trabalho: ${raw}`);
+    }
+    return full;
+  }
+  const full = path.resolve(root, raw);
   if (full !== root && !full.startsWith(root + path.sep)) {
-    throw new Error(`caminho fora do diretorio de trabalho: ${target}`);
+    throw new Error(`caminho fora do diretorio de trabalho: ${raw}`);
   }
   return full;
 }