kafox-cli 0.3.0 → 0.7.0

package/src/gateway.js

@@ -3,26 +3,20 @@ const storage = require("./storage");
 const { ensureSession, fetchApi } = require("./auth");
 
 /**
- * Envia a pergunta ao gateway e devolve o resultado estruturado.
- * A TUI usa o retorno; o comando `kafox ask` so imprime.
+ * Garante sessao, saldo, modelo e chave antes de qualquer chamada.
+ * A chave `kafox_live_...` e da propria conta: o gateway cobra por ela.
  */
-async function askModel(question, options = {}) {
-  const text = typeof question === "string" ? question : (question || []).join(" ");
-  if (!text.trim()) {
-    return { ok: false, error: 'Usage: kafox ask "your question" [-m model]' };
-  }
-
+async function ensureReady(options = {}) {
   const token = await ensureSession();
   if (!token) {
     return { ok: false, error: "Login first: `kafox login`" };
   }
 
-  // Saldo decide se a CLI responde: sem credito, nem chega no gateway.
   const boot = await fetchApi("/api/bootstrap");
   if (!boot.ok) {
     return { ok: false, error: "Session invalid. Run `kafox login`" };
   }
-  const account = await boot.json();
+  const account = await boot.json().catch(() => null);
   const balance = Number(account?.user?.balance_micros || 0);
   if (balance <= 0) {
     return {
@@ -38,9 +32,7 @@ async function askModel(question, options = {}) {
       .then((response) => response.json())
       .catch(() => null);
     model = pricing?.pricing?.[0]?.model;
-    if (!model) {
-      return { ok: false, error: "Could not load model catalog." };
-    }
+    if (!model) return { ok: false, error: "Could not load model catalog." };
   }
 
   let keyCreated = false;
@@ -59,51 +51,237 @@ async function askModel(question, options = {}) {
     keyCreated = true;
   }
 
-  const response = await fetchApi("/api/public/playground", {
-    method: "POST",
-    body: JSON.stringify({ api_key: apiKey, model, message: text }),
+  return { ok: true, model, apiKey, keyCreated, balance };
+}
+
+function mergeToolCalls(target, deltas) {
+  for (const delta of deltas) {
+    const index = Number.isInteger(delta?.index) ? delta.index : target.length;
+    const current = target[index] || {
+      id: "",
+      type: "function",
+      function: { name: "", arguments: "" },
+    };
+    if (delta.id) current.id = delta.id;
+    if (delta.type) current.type = delta.type;
+    if (delta.function?.name) current.function.name += delta.function.name;
+    if (delta.function?.arguments) current.function.arguments += delta.function.arguments;
+    target[index] = current;
+  }
+}
+
+/* ---------------------------------------------------------------- retry */
+
+// Rede do provedor cai e o fetch devolve "fetch failed": em vez de morrer na
+// primeira tentativa, espera e tenta de novo dobrando o intervalo.
+const RETRY_MAX = 20;
+const RETRY_BASE_MS = Number(process.env.KAFOX_RETRY_BASE_MS) || 3000;
+const RETRY_MAX_MS = Number(process.env.KAFOX_RETRY_MAX_MS) || 60_000;
+const RETRYABLE_STATUS = new Set([408, 425, 429, 500, 502, 503, 504, 521, 522, 523, 524]);
+
+/** Espera do retry: 3s, 6s, 12s, 24s... ate 60s. */
+function backoffMs(attempt) {
+  return Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** Math.max(0, attempt - 1));
+}
+
+/** Vale a pena tentar de novo? Erro de rede, timeout e 5xx sim; 4xx de
+ * conteudo (saldo, chave, modelo) nao adianta repetir. */
+function retryableMessage(message) {
+  return /fetch failed|failed to fetch|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ECONNREFUSED|socket hang up|network|stream interrompido|terminated|other side closed/i.test(
+    String(message || "")
+  );
+}
+
+/** Dorme respeitando o abort: o Esc mata a espera na hora. */
+function wait(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve(false);
+    const done = (value) => {
+      clearTimeout(timer);
+      signal?.removeEventListener?.("abort", onAbort);
+      resolve(value);
+    };
+    const timer = setTimeout(() => done(true), ms);
+    timer.unref?.();
+    function onAbort() {
+      done(false);
+    }
+    signal?.addEventListener?.("abort", onAbort, { once: true });
   });
-  const data = await response.json().catch(() => ({}));
+}
+
+function errorFrom(data, status) {
+  const message =
+    data?.error?.message || data?.error || data?.body?.error?.message || `gateway error (${status})`;
+  return {
+    ok: false,
+    code: data?.code || (status === 402 ? "no_balance" : "gateway_error"),
+    error: String(message),
+  };
+}
+
+/**
+ * Uma tentativa: request + leitura do stream.
+ * Devolve `retryable` quando o erro foi de rede/servidor e ainda nao veio texto.
+ */
+async function attemptChat({ messages, model, tools, onDelta, onReasoning, signal } = {}) {
+  const ready = await ensureReady({ model });
+  if (!ready.ok) return ready;
+
+  const started = Date.now();
+  let response;
+  try {
+    response = await fetchApi("/api/chat", {
+      method: "POST",
+      headers: { accept: "text/event-stream" },
+      body: JSON.stringify({
+        api_key: ready.apiKey,
+        model: ready.model,
+        messages,
+        tools: tools && tools.length ? tools : undefined,
+        stream: true,
+      }),
+      signal,
+    });
+  } catch (error) {
+    if (error?.name === "AbortError") return { ok: false, code: "aborted", error: "Cancelado." };
+    return {
+      ok: false,
+      error: `Falha de rede: ${error.message}`,
+      retryable: retryableMessage(error.message),
+      keyCreated: ready.keyCreated,
+    };
+  }
 
   if (!response.ok) {
-    if (response.status === 402) {
-      return {
-        ok: false,
-        code: "no_balance",
-        error: "Sem saldo para responder. Recarregue em https://kafox.pypag.com/dashboard",
-      };
-    }
-    return { ok: false, error: `Failed: ${data.error || "gateway error"}` };
+    const data = await response.json().catch(() => ({}));
+    return {
+      ...errorFrom(data, response.status),
+      status: response.status,
+      keyCreated: ready.keyCreated,
+      retryable: RETRYABLE_STATUS.has(response.status),
+    };
   }
 
-  // O playground devolve 200 mesmo quando o gateway recusa a chamada.
-  if (data.ok === false) {
-    const detail = data.body?.error?.message || data.body?.error || "gateway error";
-    if (data.status === 402) {
-      return {
-        ok: false,
-        code: "no_balance",
-        error: "Sem saldo para responder. Recarregue em https://kafox.pypag.com/dashboard",
-      };
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let text = "";
+  let reasoning = "";
+  let usage = null;
+  const toolCalls = [];
+
+  const handleLine = (line) => {
+    if (!line.startsWith("data:")) return null;
+    const data = line.slice(5).trim();
+    if (!data || data === "[DONE]") return null;
+    let event;
+    try {
+      event = JSON.parse(data);
+    } catch {
+      return null;
     }
-    return { ok: false, error: `Failed (${data.status}): ${detail}` };
+    if (event?.error) {
+      const message = event.error.message || String(event.error);
+      return { error: message, retryable: retryableMessage(message) };
+    }
+    if (event?.usage) usage = event.usage;
+    const delta = event?.choices?.[0]?.delta;
+    if (!delta) return null;
+    // Cada provedor manda o "pensamento" com um nome diferente.
+    const think = delta.reasoning_content ?? delta.reasoning ?? delta.thinking;
+    if (typeof think === "string" && think) {
+      reasoning += think;
+      onReasoning?.(think);
+    }
+    if (delta.content) {
+      text += delta.content;
+      onDelta?.(delta.content);
+    }
+    if (Array.isArray(delta.tool_calls)) mergeToolCalls(toolCalls, delta.tool_calls);
+    return null;
+  };
+
+  try {
+    for await (const chunk of response.body) {
+      buffer += decoder.decode(chunk, { stream: true });
+      let index = buffer.indexOf("\n");
+      while (index >= 0) {
+        const line = buffer.slice(0, index).replace(/\r$/, "");
+        buffer = buffer.slice(index + 1);
+        const failure = handleLine(line);
+        if (failure) return { ok: false, error: failure.error, retryable: failure.retryable };
+        index = buffer.indexOf("\n");
+      }
+    }
+    if (buffer.trim()) handleLine(buffer.trim());
+  } catch (error) {
+    if (error?.name === "AbortError") {
+      return { ok: true, text, reasoning, toolCalls, ms: Date.now() - started, aborted: true };
+    }
+    return {
+      ok: false,
+      error: `Stream interrompido: ${error.message}`,
+      text,
+      retryable: retryableMessage(error.message),
+    };
+  }
+
+  return {
+    ok: true,
+    text,
+    reasoning,
+    toolCalls: toolCalls.filter(Boolean),
+    usage,
+    ms: Date.now() - started,
+    model: ready.model,
+    keyCreated: ready.keyCreated,
+    provider: response.headers?.get?.("x-kafox-provider") || "",
+  };
+}
+
+/**
+ * Chat completions com stream (SSE) via /api/chat, com retry em falha de rede.
+ * onRetry avisa a TUI (tentativa, espera) para ela mostrar a contagem.
+ */
+async function chat({ messages, model, tools, onDelta, onReasoning, onRetry, signal, retries = RETRY_MAX } = {}) {
+  const maxAttempts = Math.max(1, Number(retries) || RETRY_MAX);
+  let attempt = 0;
+  let last = null;
+
+  while (attempt < maxAttempts) {
+    attempt += 1;
+    const result = await attemptChat({ messages, model, tools, onDelta, onReasoning, signal });
+
+    if (result.ok || result.code === "aborted") return result;
+    // Ja saiu texto: repetir duplicaria a resposta na tela.
+    if (!result.retryable || result.text) return result;
+    last = result;
+
+    if (attempt >= maxAttempts) break;
+
+    const delay = backoffMs(attempt);
+    onRetry?.({ attempt, maxAttempts, delay, error: result.error });
+    const slept = await wait(delay, signal);
+    if (!slept) return { ok: false, code: "aborted", error: "Cancelado.", keyCreated: result.keyCreated };
   }
 
-  const body = data.body;
-  const output =
-    typeof body === "string"
-      ? body
-      : body?.choices?.[0]?.message?.content ||
-        body?.choices?.[0]?.text ||
-        JSON.stringify(body, null, 2);
+  return { ...last, attempts: attempt };
+}
 
+/** Compatibilidade: resposta unica, sem callbacks (usada por `kafox ask`). */
+async function askModel(question, options = {}) {
+  const text = typeof question === "string" ? question : (question || []).join(" ");
+  if (!text.trim()) {
+    return { ok: false, error: 'Usage: kafox ask "your question" [-m model]' };
+  }
+  const result = await chat({ messages: [{ role: "user", content: text }], model: options.model });
+  if (!result.ok) return result;
   return {
     ok: true,
-    text: String(output || "").trim() || "(resposta vazia)",
-    ms: data.ms,
-    provider: data.provider,
-    model,
-    keyCreated,
+    text: String(result.text || "").trim() || "(resposta vazia)",
+    ms: result.ms,
+    model: result.model,
+    keyCreated: result.keyCreated,
   };
 }
 
@@ -124,4 +302,13 @@ async function ask(question, options = {}) {
   }
 }
 
-module.exports = { ask, askModel };
+module.exports = {
+  ask,
+  askModel,
+  chat,
+  ensureReady,
+  mergeToolCalls,
+  backoffMs,
+  RETRY_MAX,
+  RETRY_BASE_MS,
+};

package/src/login-screen.js

@@ -0,0 +1,203 @@
+/**
+ * Tela de login do kafox (estilo Cline): ocupa o terminal inteiro, com a arte
+ * grande em cima, o link centralizado e o status de aprovacao animado.
+ *
+ * Sem TTY (pipe/CI) quem chama usa o fluxo de texto do auth.
+ */
+const chalk = require("chalk");
+const { logoLines } = require("./logo");
+const { borderColor } = require("./theme");
+
+const ANSI = /\x1b\[[0-9;]*m/g;
+const visible = (value) => String(value).replace(ANSI, "").length;
+const center = (text, width) => {
+  const pad = Math.max(0, Math.floor((width - visible(text)) / 2));
+  return " ".repeat(pad) + text;
+};
+const rule = (width) => "─".repeat(Math.max(0, width));
+
+function boxed(lines, width, theme) {
+  const border = borderColor(theme);
+  const inner = Math.max(20, Math.min(width, Math.max(...lines.map(visible)) + 4));
+  const out = [border(`┌${rule(inner)}┐`)];
+  for (const line of lines) {
+    out.push(border("│") + " " + line + " ".repeat(Math.max(0, inner - visible(line) - 1)) + border("│"));
+  }
+  out.push(border(`└${rule(inner)}┘`));
+  return out;
+}
+
+/**
+ * @param {object} options
+ * @param {string} options.url     URL que o usuario abre no navegador
+ * @param {string} options.code    codigo curto (para digitar no site)
+ * @param {number} options.interval segundos entre consultas
+ * @param {number} options.expiresIn segundos de validade
+ * @param {(signal:AbortSignal) => Promise<{ok:boolean, session?:string, error?:string}>} options.poll
+ * @param {string} [options.theme]
+ * @param {string} [options.account] email ja conhecido (opcional)
+ */
+function runLoginScreen({
+  url,
+  code,
+  interval = 3,
+  expiresIn = 300,
+  poll,
+  theme = "default",
+  version = "",
+} = {}) {
+  const stdout = process.stdout;
+  const stdin = process.stdin;
+  const controller = new AbortController();
+  const columns = Math.max(40, stdout.columns || 80);
+  const rows = Math.max(16, stdout.rows || 24);
+  const startedAt = Date.now();
+  const deadline = startedAt + (Number(expiresIn) || 300) * 1000;
+
+  let dots = 0;
+  let done = false;
+  let cancelled = false;
+  let status = "aguardando aprovacao";
+  let statusColor = chalk.cyan;
+
+  const logo = logoLines(theme);
+  const logoWidth = Math.max(...logo.map(visible));
+
+  function lines() {
+    const out = [];
+    const spin = "⠋⠙⠹⠸⠼⠴⠦⠧".charAt(dots % 8);
+    if (columns >= logoWidth + 4 && rows >= 22) {
+      out.push("");
+      for (const line of logo) out.push(center(line, columns));
+      out.push("");
+    }
+    out.push(center(chalk.bold("Entre na sua conta"), columns));
+    out.push(center(chalk.dim("Aprove o acesso no navegador para continuar."), columns));
+    out.push("");
+    for (const line of boxed([chalk.cyan(url)], columns - 4, theme)) out.push(center(line, columns));
+    out.push("");
+    out.push(center(chalk.dim("codigo") + "  " + chalk.bold(code), columns));
+    out.push("");
+    const elapsed = Math.floor((Date.now() - startedAt) / 1000);
+    const left = Math.max(0, Math.floor((deadline - Date.now()) / 1000));
+    out.push(
+      center(
+        statusColor(`${spin} ${status}${".".repeat(dots % 4)}`) +
+          chalk.dim(`   ${left}s para expirar · ${elapsed}s esperando`),
+        columns
+      )
+    );
+    out.push("");
+    out.push(
+      center(
+        chalk.dim("Esc cancela") + "  ·  " + chalk.dim("abra o link em qualquer navegador"),
+        columns
+      )
+    );
+    if (version) out.push(center(chalk.dim(`kafox v${version}`), columns));
+
+    // Centraliza o bloco inteiro na vertical, sem estourar a altura.
+    const slice = out.slice(0, rows - 1);
+    const top = Math.max(0, Math.floor((rows - slice.length) / 2));
+    return [...Array(top).fill(""), ...slice].slice(0, rows);
+  }
+
+  function paint() {
+    const frame = lines();
+    // Atualizacao sincronizada: o terminal troca o frame inteiro de uma vez,
+    // sem piscar entre as linhas.
+    stdout.write(
+      "\x1b[?2026h\x1b[?25l\x1b[H" +
+        frame.map((line) => line + "\x1b[K").join("\n") +
+        "\x1b[?2026l"
+    );
+  }
+
+  const enter = () => stdout.write("\x1b[?1049h\x1b[?25l\x1b[H\x1b[2J");
+  const leave = () => stdout.write("\x1b[?25h\x1b[?1049l");
+
+  return new Promise((resolve) => {
+    let ticker = null;
+    let poller = null;
+    let finished = false;
+
+    function finish(result) {
+      if (finished) return;
+      finished = true;
+      done = result.ok;
+      cancelled = result.cancelled;
+      if (result.ok) {
+        status = "aprovado";
+        statusColor = chalk.green;
+        paint();
+      }
+      clearInterval(ticker);
+      clearInterval(poller);
+      stdin.removeListener("data", onData);
+      stdin.removeListener("end", onCancel);
+      try {
+        stdin.setRawMode(false);
+      } catch {}
+      stdin.pause();
+
+      setTimeout(() => {
+        leave();
+        resolve(result);
+      }, result.ok ? 450 : 0);
+    }
+
+    function onCancel() {
+      controller.abort();
+      finish({ ok: false, cancelled: true, error: "login cancelado" });
+    }
+
+    function onData(chunk) {
+      const text = String(chunk);
+      // Ctrl+C ou Esc solto cancelam (setas tambem comecam com ESC, entao so
+      // um chunk que e exatamente o Esc conta).
+      if (text.includes("\x03") || text === "\x1b") return onCancel();
+    }
+
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.setEncoding("utf8");
+    stdin.resume();
+    stdin.on("data", onData);
+    stdin.on("end", onCancel);
+
+    enter();
+    paint();
+
+    ticker = setInterval(() => {
+      dots += 1;
+      if (Date.now() > deadline) {
+        status = "codigo expirado";
+        statusColor = chalk.red;
+        paint();
+        return finish({ ok: false, error: "codigo expirado" });
+      }
+      if (typeof stdout.rows === "number") paint();
+    }, 140);
+
+    async function check() {
+      if (finished) return;
+      try {
+        const result = await poll(controller.signal);
+        if (finished) return;
+        if (result?.ok) return finish({ ok: true, session: result.session });
+        if (result?.cancelled) return finish(result);
+        if (result?.error) {
+          status = result.error;
+          statusColor = chalk.yellow;
+          paint();
+        }
+      } catch {
+        // erro passageiro: continua tentando ate expirar
+      }
+    }
+
+    poller = setInterval(check, Math.max(1, Number(interval) || 3) * 1000);
+    check();
+  });
+}
+
+module.exports = { runLoginScreen };

package/src/logo.js

@@ -0,0 +1,108 @@
+/**
+ * Logo do kafox: a arte "KAFOX" em blocos (fundo azul), adaptada por tema.
+ *
+ * A arte original vem com codigos ANSI por trecho; aqui ela e decodificada em
+ * segmentos {fg, bg, texto} e repintada com chalk, para que o fundo do tema
+ * entre nos espacos transparentes e o texto continue legivel no tema claro.
+ */
+const chalk = require("chalk");
+const { themeColors } = require("./theme");
+
+const SGR = /\x1b\[([0-9;]*)m/g;
+
+// Paleta da arte. 97 = tinta clara, 94 = azul, 34 = azul fundo, 37 = neutro,
+// 44 = fundo azul (aplicado junto de 94).
+const PALETTES = {
+  dark: { ink: "#ffffff", gray: "#c8c8c8", blue: "#3f6ef0", deep: "#1c2fc4", fill: "#1c2fc4" },
+  light: { ink: "#2323b8", gray: "#6f6f6f", blue: "#4b52e8", deep: "#2a2ab0", fill: "#c7cfff" },
+};
+
+const STYLE_KEYS = {
+  37: { fg: "gray" },
+  34: { fg: "deep" },
+  94: { fg: "blue" },
+  97: { fg: "ink" },
+  44: { bg: "fill" },
+};
+
+const RAW_LOGO = [
+  "\x1b[0;97m█\x1b[0;94m█\x1b[0;94;44m▓▓\x1b[0;37m  \x1b[0;94;44m█▓▒░\x1b[0;37m \x1b[0;97m▄\x1b[0;94m█\x1b[0;94;44m▓▓▒░\x1b[0;34m███▄\x1b[0;37m \x1b[0;97m▄\x1b[0;94m█\x1b[0;94;44m▓▓▒░\x1b[0;34m████\x1b[0;37m \x1b[0;97m▄\x1b[0;94m█\x1b[0;94;44m▓▓▒░\x1b[0;34m███▄\x1b[0;37m \x1b[0;97m█\x1b[0;94m█\x1b[0;94;44m▓▓\x1b[0;37m  \x1b[0;94;44m▓▒░\x1b[0;34m█\x1b[0m",
+  "\x1b[0;94;44m▓▓▒▒\x1b[0;37m  \x1b[0;94;44m▓▒░\x1b[0;34m█\x1b[0;37m \x1b[0;94;44m▓▓▒▒\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m \x1b[0;34m██\x1b[0;37m \x1b[0;94;44m▓▓▒▒\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m▓▓\x1b[0;34m█\x1b[0;37m \x1b[0;94;44m▓▓▒▒\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m░░\x1b[0;34m█\x1b[0;37m \x1b[0;94;44m▓▓▒▒\x1b[0;37m  \x1b[0;94;44m▒░░\x1b[0;34m█\x1b[0m",
+  "\x1b[0;94;44m▒▒░░\x1b[0;34m█\x1b[0;94;44m░▒░▒\x1b[0;34m▄\x1b[0;37m \x1b[0;94;44m▒▒░░\x1b[0;34m██████\x1b[0;37m \x1b[0;94;44m▒▒░░\x1b[0;34m█\x1b[0;37m      \x1b[0;94;44m▒▒░░\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m▒▒\x1b[0;34m█\x1b[0;37m \x1b[0;94m▀\x1b[0;94;44m▒░░\x1b[0;34m██\x1b[0;94;44m░▒▒\x1b[0;94m▀\x1b[0m",
+  "\x1b[0;94;44m░░\x1b[0;34m██\x1b[0;37m  \x1b[0;94;44m░▓▓ \x1b[0;37m \x1b[0;94;44m░░\x1b[0;34m██\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m▓▓\x1b[0;34m█\x1b[0;37m \x1b[0;94;44m░░\x1b[0;34m██\x1b[0;37m       \x1b[0;94;44m░░\x1b[0;34m██\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m▓▓ \x1b[0;37m \x1b[0;94;44m░░\x1b[0;34m██\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m▓▓ \x1b[0m",
+  "\x1b[0;34m████\x1b[0;37m  \x1b[0;34m████\x1b[0;37m \x1b[0;34m████\x1b[0;37m  \x1b[0;34m████\x1b[0;37m \x1b[0;34m████\x1b[0;37m       \x1b[0;34m▀████████▀\x1b[0;37m \x1b[0;34m████\x1b[0;37m  \x1b[0;34m████\x1b[0m",
+];
+
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+/** Decodifica uma linha crua em segmentos com estilo e texto. */
+function parseLine(raw) {
+  const segments = [];
+  let style = { fg: null, bg: null };
+  let last = 0;
+  let match;
+  SGR.lastIndex = 0;
+
+  while ((match = SGR.exec(raw)) !== null) {
+    if (match.index > last) {
+      segments.push({ ...style, text: raw.slice(last, match.index) });
+    }
+    const codes = match[1].split(";").filter(Boolean).map(Number);
+    for (const code of codes) {
+      if (code === 0) style = { fg: null, bg: null };
+      else if (STYLE_KEYS[code]) Object.assign(style, STYLE_KEYS[code]);
+    }
+    last = match.index + match[0].length;
+  }
+  if (last < raw.length) segments.push({ ...style, text: raw.slice(last) });
+  return segments;
+}
+
+const SEGMENTS = RAW_LOGO.map(parseLine);
+
+const LOGO_TEXT = SEGMENTS.map((line) => line.map((part) => part.text).join(""));
+const LOGO_WIDTH = Math.max(...LOGO_TEXT.map((line) => line.length));
+const LOGO_HEIGHT = LOGO_TEXT.length;
+
+/** Temas de fundo claro precisam de tinta escura para o desenho nao sumir. */
+function paletteFor(theme) {
+  const { bg } = themeColors(theme);
+  if (!bg) return PALETTES.dark;
+  const [r, g, b] = [1, 3, 5].map((index) => parseInt(bg.slice(index, index + 2), 16));
+  const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+  return luminance > 0.6 ? PALETTES.light : PALETTES.dark;
+}
+
+function paintSegment(text, style, palette) {
+  if (!text) return "";
+  const fg = style.fg ? palette[style.fg] : null;
+  const bg = style.bg ? palette[style.bg] : null;
+  if (fg && bg) return chalk.bgHex(bg).hex(fg)(text);
+  if (bg) return chalk.bgHex(bg)(text);
+  if (fg) return chalk.hex(fg)(text);
+  return text;
+}
+
+/** Linhas da arte ja coloridas (sem a cor de fundo da tela). */
+function logoLines(theme = "default") {
+  const palette = paletteFor(theme);
+  return SEGMENTS.map((segments) =>
+    segments.map((part) => paintSegment(part.text, part, palette)).join("")
+  );
+}
+
+/** Versao em texto puro (sem cor), para saidas nao-TTY e testes. */
+function logoText() {
+  return LOGO_TEXT.join("\n");
+}
+
+module.exports = {
+  logoLines,
+  logoText,
+  parseLine,
+  LOGO_WIDTH,
+  LOGO_HEIGHT,
+  PALETTES,
+  paletteFor,
+  stripAnsi: (value) => String(value).replace(ANSI_RE, ""),
+};

package/src/mascot.js

@@ -1,32 +1,4 @@
-// Kafox mascot art (ASCII only, no accents).
-const MASCOT = [
-  "████                      ████",
-  "  ▒▒░░░░▓▓                  ▓▓░░░░▒▒",
-  "  ██░░▒▒░░██              ██░░▒▒░░██",
-  "  ██░░▓▓▒▒░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░▒▒▓▓░░██",
-  "  ██░░▓▓▓▓▒▒▓▓          ▓▓▒▒▓▓▓▓░░██",
-  "  ██░░▒▒▒▒▓▓░░░░░░░░░░░░░░▓▓▒▒▒▒░░██",
-  "  ██▒▒▓▓▓▓░░░░░░░░░░░░░░░░░░▓▓▓▓▒▒██",
-  "▒▒  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  ▓▓",
-  "██  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  ██",
-  "██  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  ██",
-  "██  ░░▓▓▓▓░░░░░░░░░░░░░░░░░░▓▓▓▓░░  ██",
-  "██  ░░░░░░▓▓░░░░░░▒▒░░░░░░▓▓░░░░░░  ██",
-  "██░░░░░░░░░░▓▓░░▒▒▒▒▒▒░░▓▓░░░░░░░░░░██",
-  "██░░        ░░░░░░░░░░░░░░        ░░██    ▒▒▓▓",
-  "  ██            ▓▓▓▓▓▓            ██    ██  ██",
-  "    ▓▓            ▓▓            ▓▓  ▓▓▒▒    ██",
-  "      ██        ▓▓  ▓▓        ██  ██        ██",
-  "        ▓▓▓▓              ▓▓▓▓  ▓▓░░░░      ██",
-  "      ██▒▒░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░▒▒██░░▒▒▒▒░░░░░░██",
-  "      ██░░░░              ░░░░▓▓▒▒▒▒▒▒▒▒░░░░██",
-  "    ██░░░░░░              ░░░░░░▓▓▒▒▒▒▒▒░░██",
-  "    ██░░░░  ▒▒          ▒▒  ░░░░▓▓▒▒▒▒▒▒▓▓",
-  "    ██░░░░  ▒▒          ▒▒  ░░░░▓▓▒▒████",
-  "    ██▒▒░░  ▓▓    ▒▒    ▓▓  ░░▒▒██▓▓",
-  "      ████  ▓▓    ▓▓    ▓▓  ████",
-  "          ▒▒██▓▓  ▓▓  ▓▓██▒▒",
-  "              ██████████",
-].join("\n");
+// Compatibilidade: o "mascote" agora e o logo KAFOX em blocos (logo.js).
+const { logoText, logoLines } = require("./logo");
 
-module.exports = { mascot: MASCOT };
+module.exports = { mascot: logoText(), logoLines };