kafox-cli 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,57 @@
-# Temporary Holding Version
+# kafox
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+CLI oficial do Kafox no estilo opencode: login por device code (SSO), modelos,
+saldo em reais, temas e conversa pelo gateway.
+
+## Instalar
+
+```bash
+npm install -g kafox-cli
+```
+
+O comando instalado e `kafox`. Alternativa sem npm:
+
+```bash
+npm install -g https://kafox.pypag.com/static/downloads/kafox-cli-0.2.0.tgz
+```
+
+Requisito: Node.js 22.5+.
+
+## Login
+
+```bash
+kafox login
+```
+
+A CLI mostra um codigo e a URL `https://kafox.pypag.com/cli?code=...`. Abra no
+navegador, entre na sua conta e clique em **Autorizar**. A sessao fica em
+`~/.kafox/token.json` (permissao 600).
+
+## Comandos
+
+| Comando | O que faz |
+| --- | --- |
+| `kafox` | abre o REPL |
+| `kafox login` / `logout` / `whoami` | sessao da conta |
+| `kafox models` | lista modelos e precos por 1M de tokens |
+| `kafox pricing` | pacotes de recarga |
+| `kafox balance` | saldo atual |
+| `kafox key` | cria uma API key |
+| `kafox ask "pergunta" [-m modelo]` | pergunta ao gateway |
+| `kafox status` | conta, saldo e gateway |
+| `kafox theme` | seletor de tema |
+| `kafox background [url]` | imagem de fundo do terminal |
+| `kafox compact` / `clear` | compacta / limpa o contexto do REPL |
+
+Dentro do REPL: `/help`, `/models`, `/model <id>`, `/balance`, `/pricing`,
+`/key`, `/login`, `/logout`, `/whoami`, `/theme`, `/background`, `/clear`,
+`/compact`, `/status`, `/exit`.
+
+## Configuracao
+
+- `KAFOX_API_URL` ou `~/.kafox/config.json` (`api_url`) troca a API.
+- `~/.kafox/config.json` guarda `model`, `theme`, `background` e a API key criada
+  automaticamente no primeiro `ask`.
+
+A CLI so responde se a conta tiver saldo; sem credito ela avisa e nao chama o
+gateway.

package/bin/kafox.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+const { Command } = require("commander");
+const { runREPL, compact, clearContext, showStatus } = require("../src/cli");
+const { login, logout, whoami, createKey } = require("../src/auth");
+const { listModels, showBalance, showPricing } = require("../src/models");
+const { ask } = require("../src/gateway");
+const { runTheme, setContentBackground } = require("../src/theme");
+
+const program = new Command();
+
+program
+  .name("kafox")
+  .description("Kafox CLI in opencode style: REPL, account login, models, balance, themes")
+  .version("0.1.0");
+
+program.command("login").description("Login with your Kafox account (device code SSO)").action(login);
+program.command("logout").description("End the CLI session").action(logout);
+program.command("whoami").description("Show the account linked to this CLI").action(whoami);
+program.command("models").description("List available models and prices").action(listModels);
+program.command("balance").description("Show current balance").action(showBalance);
+program.command("pricing").description("Show recharge packages").action(showPricing);
+program.command("key").description("Create an API key for this CLI").action(createKey);
+program.command("ask").argument("[question...]", "Question").option("-m, --model <id>", "Model").action(ask);
+program.command("theme").description("Open the theme selector").action(runTheme);
+program.command("background").description("Set terminal background image (URL)").argument("[url]", "Image URL").action(setContentBackground);
+program.command("compact").description("Compact the current conversation context").action(compact);
+program.command("clear").description("Clear the conversation context").action(clearContext);
+program.command("status").description("Show account, balance and gateway status").action(showStatus);
+
+program.action(runREPL);
+program.parse();

package/package.json

@@ -1,6 +1,25 @@
 {
   "name": "kafox-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Kafox CLI in opencode style: full-screen terminal UI, device login, models, balance, themes",
+  "bin": {
+    "kafox": "bin/kafox.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=22.5"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "4.1.2",
+    "commander": "12.1.0",
+    "inquirer": "8.2.6"
+  },
+  "scripts": {
+    "test": "node --test \"test/*.test.js\""
+  }
+}

package/src/auth.js

@@ -0,0 +1,128 @@
+const chalk = require("chalk");
+const inquirer = require("inquirer");
+const storage = require("./storage");
+const { mascot } = require("./mascot");
+
+const MASCOT = mascot;
+
+async function fetchApi(pathname, options = {}) {
+  const url = `${storage.getApiUrl()}${pathname}`;
+  const res = await fetch(url, {
+    ...options,
+    headers: { ...storage.getAuthHeaders(options.headers), ...options.headers },
+  });
+  return res;
+}
+
+async function ensureSession() {
+  const token = storage.getToken();
+  if (token?.session) return token;
+  return null;
+}
+
+async function login() {
+  console.log(MASCOT);
+  console.log(
+    chalk.cyan("  Kafox CLI - login by device code (SSO)\n")
+  );
+
+  const res = await fetchApi("/api/cli/device", {
+    method: "POST",
+    body: "{}",
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    console.log(chalk.red(`  Failed to create device code: ${data.error || "error"}`));
+    return;
+  }
+
+  console.log(
+    chalk.bold("\n  Open this URL in your browser to approve:\n") +
+    chalk.cyan(`    ${storage.getApiUrl()}/cli?code=${data.user_code}\n`)
+  );
+  console.log(`  Code: ${chalk.bold(data.user_code)}  (expires in ${data.expires_in}s)\n`);
+
+  const interval = Math.max(1, data.interval) * 1000;
+  const deadline = Date.now() + data.expires_in * 1000;
+  let dots = 0;
+
+  while (Date.now() < deadline) {
+    process.stdout.write(`\r  Waiting for approval${".".repeat(dots % 4)}   `);
+    dots += 1;
+    await new Promise((r) => setTimeout(r, interval));
+    try {
+      const poll = await fetchApi(`/api/cli/poll/${encodeURIComponent(data.device_code)}`);
+      const pd = await poll.json().catch(() => ({}));
+      if (poll.status === 200 && pd.status === "approved") {
+        const previous = storage.getToken() || {};
+        storage.setToken({ session: pd.session, csrf: previous.csrf });
+        console.log(
+          chalk.green("\n  Approved! Session saved to ~/.kafox/token.json")
+        );
+        return;
+      }
+      if (pd.status === "denied" || poll.status === 403) {
+        console.log(chalk.red("\n  Login denied."));
+        return;
+      }
+      if (poll.status === 404 || poll.status === 410) {
+        console.log(chalk.red("\n  Device code expired. Run `kafox login` again."));
+        return;
+      }
+    } catch {
+      // ignore transient errors, keep polling
+    }
+  }
+  console.log(chalk.red("\n  Device code expired. Run `kafox login` again."));
+}
+
+async function logout() {
+  storage.clearToken();
+  console.log(chalk.green("  Session ended."));
+}
+
+async function whoami() {
+  const token = await ensureSession();
+  if (!token) {
+    console.log(chalk.yellow("  Not logged in. Run `kafox login`."));
+    return;
+  }
+  const res = await fetchApi("/api/auth/me");
+  const data = await res.json().catch(() => ({}));
+  if (res.status === 200) {
+    console.log(chalk.cyan("  Account: ") + chalk.bold(data.user?.email));
+    console.log(`  Name: ${data.user?.name}`);
+    console.log(
+      `  Balance: ${chalk.green((data.user?.balance_micros / 1_000_000).toFixed(2) + " R$")}`
+    );
+  } else {
+    console.log(chalk.red("  Session invalid. Run `kafox login`."));
+  }
+}
+
+async function createKey() {
+  const token = await ensureSession();
+  if (!token) {
+    console.log(chalk.yellow("  Login first: `kafox login`"));
+    return;
+  }
+  const answers = await inquirer.prompt([
+    { type: "input", name: "name", message: "Key name:", default: "CLI" },
+  ]);
+  const res = await fetchApi("/api/keys", {
+    method: "POST",
+    body: JSON.stringify({ name: answers.name }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (res.status === 201) {
+    console.log(chalk.green("\n  Key created:"));
+    console.log(`  ${data.secret}`);
+    console.log(
+      chalk.dim("  Copy it now - it will not be shown again.")
+    );
+  } else {
+    console.log(chalk.red(`\n  Failed: ${data.error || "error"}`));
+  }
+}
+
+module.exports = { login, logout, whoami, createKey, ensureSession, fetchApi };

package/src/cli.js

@@ -0,0 +1,260 @@
+const readline = require("readline");
+const inquirer = require("inquirer");
+const chalk = require("chalk");
+const storage = require("./storage");
+const { ensureSession, fetchApi } = require("./auth");
+const { ask } = require("./gateway");
+const { runTUI } = require("./tui");
+const { runTheme, setContentBackground, paint } = require("./theme");
+const { mascot } = require("./mascot");
+
+const VERSION = "0.2.0";
+
+const COMMANDS = {
+  "/help": "show this help",
+  "/models": "list models and prices",
+  "/model <id>": "set default model",
+  "/balance": "show balance",
+  "/pricing": "show recharge packages",
+  "/key": "create an API key",
+  "/login": "login (device code SSO)",
+  "/logout": "end the session",
+  "/whoami": "show the linked account",
+  "/theme": "open theme selector",
+  "/background [url]": "set background image (modal asks for URL)",
+  "/clear": "clear conversation context",
+  "/compact": "compact conversation context",
+  "/status": "show account, balance and gateway status",
+  "/exit": "exit the CLI",
+};
+
+let history = [];
+let modelOverride = null;
+
+function pushHistory(role, content) {
+  history.push({ role, content, at: new Date().toISOString() });
+  if (history.length > 200) history = history.slice(-200);
+}
+
+async function handleCommand(line) {
+  const [cmd, ...rest] = line.trim().split(/\s+/);
+  const arg = rest.join(" ");
+  switch (cmd) {
+    case "/help":
+      console.log(chalk.cyan("\nCommands:\n"));
+      for (const [key, value] of Object.entries(COMMANDS)) {
+        console.log(`  ${chalk.bold(key)}  ${chalk.dim(value)}`);
+      }
+      console.log("");
+      return true;
+    case "/models": {
+      const { listModels } = require("./models");
+      await listModels();
+      return true;
+    }
+    case "/model":
+      if (!arg) {
+        console.log(chalk.dim("Usage: /model <id>  (see /models)"));
+        return true;
+      }
+      modelOverride = arg;
+      storage.setConfig({ model: arg });
+      console.log(chalk.green(`Default model: ${arg}`));
+      return true;
+    case "/balance": {
+      const { showBalance } = require("./models");
+      await showBalance();
+      return true;
+    }
+    case "/pricing": {
+      const { showPricing } = require("./models");
+      await showPricing();
+      return true;
+    }
+    case "/key": {
+      const { createKey } = require("./auth");
+      await createKey();
+      return true;
+    }
+    case "/login": {
+      const { login } = require("./auth");
+      await login();
+      return true;
+    }
+    case "/logout": {
+      const { logout } = require("./auth");
+      await logout();
+      return true;
+    }
+    case "/whoami": {
+      const { whoami } = require("./auth");
+      await whoami();
+      return true;
+    }
+    case "/theme":
+      await runTheme();
+      return true;
+    case "/background":
+      await setContentBackground(arg || null);
+      return true;
+    case "/clear":
+      await clearContext();
+      return true;
+    case "/compact":
+      await compact();
+      return true;
+    case "/status":
+      await showStatus();
+      return true;
+    case "/exit":
+    case "/quit":
+      process.exit(0);
+    default:
+      console.log(chalk.dim(`Unknown command: ${cmd}. Type /help`));
+      return true;
+  }
+}
+
+async function clearContext() {
+  history = [];
+  console.log(chalk.green("Context cleared."));
+}
+
+async function compact() {
+  if (!history.length) {
+    console.log(chalk.dim("Nothing to compact."));
+    return;
+  }
+  const turns = history.length;
+  const last = history.slice(-6);
+  history = [
+    {
+      role: "system",
+      content: `(context compacted: ${turns} messages summarized)`,
+      at: new Date().toISOString(),
+    },
+    ...last,
+  ];
+  console.log(
+    chalk.green(`Context compacted: ${turns} -> ${history.length} messages (auto summary).`)
+  );
+}
+
+async function showStatus() {
+  const token = await ensureSession();
+  if (!token) {
+    console.log(chalk.yellow("Not logged in. Run /login"));
+    return;
+  }
+  const res = await fetchApi("/api/bootstrap");
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    console.log(chalk.red("Session invalid. Run /login"));
+    return;
+  }
+  const cfg = storage.getConfig();
+  console.log(chalk.cyan("\nKafox status\n"));
+  console.log(`  Account: ${data.user.email} (${data.user.name})`);
+  console.log(
+    `  Balance: ${chalk.green((data.user.balance_micros / 1_000_000).toFixed(2) + " R$")}`
+  );
+  console.log(`  Model: ${modelOverride || cfg.model || "(auto)"}`);
+  console.log(`  Keys: ${data.keys.active}/${data.max_active_keys} active`);
+  console.log(`  Gateway: ${data.gateway_url}`);
+}
+
+/** Modo simples: sem TTY (scripts, pipes) ou apos o login. */
+async function runPlainREPL() {
+  const cfg = storage.getConfig();
+  const theme = cfg.theme || "default";
+
+  console.log(paint(theme, mascot));
+  console.log(paint(theme, `\n  Kafox CLI  v${VERSION}  -  opencode style`));
+  console.log(chalk.dim("  Type /help for commands. Ctrl+C to exit.\n"));
+
+  const token = await ensureSession().catch(() => null);
+  if (!token) {
+    console.log(chalk.yellow("  You are not logged in."));
+    const { doLogin } = await inquirer.prompt([
+      { type: "confirm", name: "doLogin", message: "Login now?", default: true },
+    ]);
+    if (doLogin) {
+      const { login } = require("./auth");
+      await login();
+    }
+  } else {
+    const res = await fetchApi("/api/bootstrap").catch(() => null);
+    const data = res && res.ok ? await res.json().catch(() => null) : null;
+    if (data?.user) {
+      console.log(
+        chalk.dim(
+          `  Logged in as ${data.user.email} - balance ${(data.user.balance_micros / 1_000_000).toFixed(2)} R$`
+        )
+      );
+    }
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: chalk.cyan("kafox> "),
+  });
+
+  rl.prompt();
+  rl.on("line", async (raw) => {
+    const line = raw.trim();
+    if (!line) return rl.prompt();
+    try {
+      if (line.startsWith("/")) {
+        await handleCommand(line);
+      } else {
+        pushHistory("user", line);
+        await ask(line, { model: modelOverride || storage.getConfig().model });
+        pushHistory("assistant", "(answer above)");
+      }
+    } catch (err) {
+      console.log(chalk.red(`\nError: ${err.message}`));
+    }
+    rl.prompt();
+  });
+
+  rl.on("close", () => {
+    console.log(chalk.dim("\nSee you."));
+    process.exit(0);
+  });
+}
+
+async function runREPL() {
+  // Sem TTY (pipe/CI), mantem o REPL linha a linha.
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return runPlainREPL();
+
+  const cfg = storage.getConfig();
+  const token = await ensureSession().catch(() => null);
+
+  if (!token) {
+    console.log(paint(cfg.theme || "default", mascot));
+    console.log(paint(cfg.theme || "default", `\n  Kafox CLI  v${VERSION}`));
+    console.log(chalk.yellow("  You are not logged in."));
+    const { doLogin } = await inquirer.prompt([
+      { type: "confirm", name: "doLogin", message: "Login now?", default: true },
+    ]);
+    if (!doLogin) return;
+    const { login } = require("./auth");
+    await login();
+  }
+
+  return runTUI({
+    commands: COMMANDS,
+    onCommand: handleCommand,
+    interactiveCommands: new Set(["/login", "/theme", "/key", "/background"]),
+  });
+}
+
+module.exports = {
+  runREPL,
+  compact,
+  clearContext,
+  showStatus,
+  handleCommand,
+  COMMANDS,
+};

package/src/gateway.js

@@ -0,0 +1,127 @@
+const chalk = require("chalk");
+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.
+ */
+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 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 balance = Number(account?.user?.balance_micros || 0);
+  if (balance <= 0) {
+    return {
+      ok: false,
+      code: "no_balance",
+      error: "Sem saldo para responder. Recarregue em https://kafox.pypag.com/dashboard",
+    };
+  }
+
+  let model = options.model || storage.getConfig().model;
+  if (!model) {
+    const pricing = await fetchApi("/api/public/pricing")
+      .then((response) => response.json())
+      .catch(() => null);
+    model = pricing?.pricing?.[0]?.model;
+    if (!model) {
+      return { ok: false, error: "Could not load model catalog." };
+    }
+  }
+
+  let keyCreated = false;
+  let apiKey = storage.getConfig().api_key;
+  if (!apiKey) {
+    const keyResponse = await fetchApi("/api/keys", {
+      method: "POST",
+      body: JSON.stringify({ name: "kafox-cli" }),
+    });
+    const keyData = await keyResponse.json().catch(() => ({}));
+    if (!keyResponse.ok) {
+      return { ok: false, error: `Failed to create key: ${keyData.error || "error"}` };
+    }
+    apiKey = keyData.secret;
+    storage.setConfig({ api_key: apiKey });
+    keyCreated = true;
+  }
+
+  const response = await fetchApi("/api/public/playground", {
+    method: "POST",
+    body: JSON.stringify({ api_key: apiKey, model, message: text }),
+  });
+  const data = await response.json().catch(() => ({}));
+
+  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"}` };
+  }
+
+  // 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",
+      };
+    }
+    return { ok: false, error: `Failed (${data.status}): ${detail}` };
+  }
+
+  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 {
+    ok: true,
+    text: String(output || "").trim() || "(resposta vazia)",
+    ms: data.ms,
+    provider: data.provider,
+    model,
+    keyCreated,
+  };
+}
+
+async function ask(question, options = {}) {
+  const result = await askModel(question, options);
+  if (!result.ok) {
+    console.log(chalk.red(`\n${result.error}`));
+    return;
+  }
+  if (result.keyCreated) {
+    console.log(chalk.dim("(key created and saved to ~/.kafox/config.json)"));
+  }
+  console.log(chalk.dim(`Model: ${result.model}`));
+  console.log(chalk.green("\nAnswer:"));
+  console.log(result.text);
+  if (result.ms) {
+    console.log(chalk.dim(`\n(${result.ms}ms  provider ${result.provider || "?"})`));
+  }
+}
+
+module.exports = { ask, askModel };

package/src/mascot.js

@@ -0,0 +1,32 @@
+// Kafox mascot art (ASCII only, no accents).
+const MASCOT = [
+  "████                      ████",
+  "  ▒▒░░░░▓▓                  ▓▓░░░░▒▒",
+  "  ██░░▒▒░░██              ██░░▒▒░░██",
+  "  ██░░▓▓▒▒░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░▒▒▓▓░░██",
+  "  ██░░▓▓▓▓▒▒▓▓          ▓▓▒▒▓▓▓▓░░██",
+  "  ██░░▒▒▒▒▓▓░░░░░░░░░░░░░░▓▓▒▒▒▒░░██",
+  "  ██▒▒▓▓▓▓░░░░░░░░░░░░░░░░░░▓▓▓▓▒▒██",
+  "▒▒  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  ▓▓",
+  "██  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  ██",
+  "██  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  ██",
+  "██  ░░▓▓▓▓░░░░░░░░░░░░░░░░░░▓▓▓▓░░  ██",
+  "██  ░░░░░░▓▓░░░░░░▒▒░░░░░░▓▓░░░░░░  ██",
+  "██░░░░░░░░░░▓▓░░▒▒▒▒▒▒░░▓▓░░░░░░░░░░██",
+  "██░░        ░░░░░░░░░░░░░░        ░░██    ▒▒▓▓",
+  "  ██            ▓▓▓▓▓▓            ██    ██  ██",
+  "    ▓▓            ▓▓            ▓▓  ▓▓▒▒    ██",
+  "      ██        ▓▓  ▓▓        ██  ██        ██",
+  "        ▓▓▓▓              ▓▓▓▓  ▓▓░░░░      ██",
+  "      ██▒▒░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░▒▒██░░▒▒▒▒░░░░░░██",
+  "      ██░░░░              ░░░░▓▓▒▒▒▒▒▒▒▒░░░░██",
+  "    ██░░░░░░              ░░░░░░▓▓▒▒▒▒▒▒░░██",
+  "    ██░░░░  ▒▒          ▒▒  ░░░░▓▓▒▒▒▒▒▒▓▓",
+  "    ██░░░░  ▒▒          ▒▒  ░░░░▓▓▒▒████",
+  "    ██▒▒░░  ▓▓    ▒▒    ▓▓  ░░▒▒██▓▓",
+  "      ████  ▓▓    ▓▓    ▓▓  ████",
+  "          ▒▒██▓▓  ▓▓  ▓▓██▒▒",
+  "              ██████████",
+].join("\n");
+
+module.exports = { mascot: MASCOT };

package/src/models.js

@@ -0,0 +1,61 @@
+const chalk = require("chalk");
+const storage = require("./storage");
+const { ensureSession, fetchApi } = require("./auth");
+
+function fmtBRL(micros) {
+  return `${(micros / 1_000_000).toFixed(2)} R$`;
+}
+
+async function listModels() {
+  const res = await fetchApi("/api/public/pricing");
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    console.log(chalk.red(`Failed: ${err.error || "error"}`));
+    return;
+  }
+  const data = await res.json();
+  console.log(chalk.cyan("\nKafox models:\n"));
+  for (const p of data.pricing) {
+    const inp = (p.input_micros_per_1m / 1_000_000).toFixed(2);
+    const out = (p.output_micros_per_1m / 1_000_000).toFixed(2);
+    console.log(`  ${chalk.bold(p.model)}`);
+    console.log(`    in: ${inp} R$/1M  out: ${out} R$/1M`);
+  }
+  console.log(`\nGateway: ${chalk.dim(data.gateway_url)}`);
+}
+
+async function showBalance() {
+  const token = await ensureSession();
+  if (!token) {
+    console.log(chalk.yellow("Login first: `kafox login`"));
+    return;
+  }
+  const res = await fetchApi("/api/bootstrap");
+  if (!res.ok) {
+    console.log(chalk.red("Session invalid. Run `kafox login`."));
+    return;
+  }
+  const data = await res.json();
+  console.log(
+    chalk.cyan("\nBalance: ") +
+    chalk.bold.green(fmtBRL(data.user.balance_micros))
+  );
+  console.log(`  Account: ${data.user.email} (${data.user.name})`);
+  console.log(`  Keys: ${data.keys.active}/${data.max_active_keys} active`);
+}
+
+async function showPricing() {
+  const res = await fetchApi("/api/public/pricing");
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    console.log(chalk.red(`Failed: ${data.error || "error"}`));
+    return;
+  }
+  for (const pack of data.packages) {
+    console.log(
+      `  ${pack.id}: ${pack.label} -> ${fmtBRL(pack.credits_micros)} credits`
+    );
+  }
+}
+
+module.exports = { listModels, showBalance, showPricing, fmtBRL };

package/src/storage.js

@@ -0,0 +1,91 @@
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const HOME = os.homedir();
+const DIR = path.join(HOME, ".kafox");
+const TOKEN_FILE = path.join(DIR, "token.json");
+const CONFIG_FILE = path.join(DIR, "config.json");
+
+function ensureDir() {
+  if (!fs.existsSync(DIR)) fs.mkdirSync(DIR, { recursive: true, mode: 0o700 });
+}
+
+function readJSON(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJSON(file, data) {
+  ensureDir();
+  fs.writeFileSync(file, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+
+function getApiUrl() {
+  const cfg = readJSON(CONFIG_FILE, {});
+  return cfg.api_url || process.env.KAFOX_API_URL || "https://kafox.pypag.com";
+}
+
+function getToken() {
+  return readJSON(TOKEN_FILE, null);
+}
+function setToken(data) {
+  writeJSON(TOKEN_FILE, data);
+}
+function clearToken() {
+  try { fs.unlinkSync(TOKEN_FILE); } catch {}
+}
+
+function getConfig() {
+  return readJSON(CONFIG_FILE, {});
+}
+function setConfig(data) {
+  const cfg = { ...getConfig(), ...data };
+  writeJSON(CONFIG_FILE, cfg);
+}
+
+function ensureCsrf() {
+  const token = getToken() || {};
+  if (token.csrf) return token.csrf;
+  // Double-submit: o backend so compara o cookie pf_csrf com o header
+  // x-csrf-token, entao a CLI pode gerar o proprio par.
+  const csrf = crypto.randomBytes(24).toString("hex");
+  setToken({ ...token, csrf });
+  return csrf;
+}
+
+function getAuthHeaders(extra = {}) {
+  const token = getToken();
+  const headers = { "content-type": "application/json", ...extra };
+  if (token?.session) {
+    const csrf = token.csrf || ensureCsrf();
+    headers.cookie = `pf_session=${token.session}; pf_csrf=${csrf}`;
+    headers["x-csrf-token"] = csrf;
+  }
+  return headers;
+}
+
+function parseCookies(headers) {
+  const list = headers["set-cookie"] || [];
+  const result = {};
+  for (const raw of list) {
+    const first = raw.split(";")[0];
+    const idx = first.indexOf("=");
+    if (idx === -1) continue;
+    const name = first.slice(0, idx).trim();
+    const value = first.slice(idx + 1).trim();
+    if (name) result[name] = value;
+  }
+  return result;
+}
+
+module.exports = {
+  DIR, TOKEN_FILE, CONFIG_FILE,
+  ensureDir, readJSON, writeJSON,
+  getApiUrl, getToken, setToken, clearToken,
+  getConfig, setConfig, getAuthHeaders, parseCookies,
+};

package/src/theme.js

@@ -0,0 +1,64 @@
+const inquirer = require("inquirer");
+const chalk = require("chalk");
+const storage = require("./storage");
+
+const THEMES = ["default", "dark", "light", "brutalist", "neon", "paper"];
+
+function paint(theme, text) {
+  switch (theme) {
+    case "neon":
+      return chalk.magentaBright(text);
+    case "brutalist":
+      return chalk.bold.bgYellow.black(text);
+    case "paper":
+      return chalk.white(text);
+    case "light":
+      return chalk.black(text);
+    case "dark":
+      return chalk.cyan(text);
+    default:
+      return chalk.green(text);
+  }
+}
+
+async function runTheme() {
+  const cfg = storage.getConfig();
+  const { theme } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "theme",
+      message: "Choose theme:",
+      choices: THEMES,
+      default: cfg.theme || "default",
+    },
+  ]);
+  storage.setConfig({ theme });
+  console.log(chalk.green(`Theme set: ${theme}`));
+  console.log(paint(theme, "Kafox CLI - theme preview"));
+}
+
+async function setContentBackground(url) {
+  let bg = url;
+  if (!bg) {
+    const answer = await inquirer.prompt([
+      {
+        type: "input",
+        name: "url",
+        message: "Background image URL (PNG/JPG):",
+        validate: (v) =>
+          /^https?:\/\/.+\.(png|jpg|jpeg|gif|webp)(\?.*)?$/i.test(v.trim()) ||
+          "Enter a valid image URL (http/https)",
+      },
+    ]);
+    bg = answer.url.trim();
+  }
+  storage.setConfig({ background: bg });
+  console.log(chalk.green(`Background set: ${bg}`));
+  console.log(
+    chalk.dim(
+      "Tip: terminals like Windows Terminal / iTerm2 support image backgrounds. Use `kafox background` to open the modal."
+    )
+  );
+}
+
+module.exports = { runTheme, setContentBackground, THEMES, paint };

package/src/tui.js

@@ -0,0 +1,453 @@
+/**
+ * Interface de terminal do kafox, no estilo opencode:
+ * tela cheia, mascote, menu de comandos "/", caixa de input e rodape.
+ *
+ * Tudo e desenhado a mao (sem dependencia de TUI) para manter o pacote leve e
+ * funcionar no Windows Terminal. Sem TTY, o cli.js usa o REPL simples.
+ */
+const readline = require("readline");
+const chalk = require("chalk");
+const storage = require("./storage");
+const { mascot } = require("./mascot");
+const { paint } = require("./theme");
+const { ensureSession, fetchApi } = require("./auth");
+const { askModel } = require("./gateway");
+
+const ANSI = /\x1b\[[0-9;]*m/g;
+const stripAnsi = (value) => String(value).replace(ANSI, "");
+const visible = (value) => stripAnsi(value).length;
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+
+function wrap(text, width) {
+  const max = Math.max(10, width);
+  const lines = [];
+  for (const paragraph of String(text).replace(/\r/g, "").split("\n")) {
+    if (!paragraph.length) {
+      lines.push("");
+      continue;
+    }
+    let line = "";
+    for (const word of paragraph.split(/\s+/)) {
+      if (!line) line = word;
+      else if (line.length + 1 + word.length <= max) line += " " + word;
+      else {
+        lines.push(line);
+        line = word;
+      }
+      while (line.length > max) {
+        lines.push(line.slice(0, max));
+        line = line.slice(max);
+      }
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+
+function truncate(text, width) {
+  const plain = stripAnsi(text);
+  if (plain.length <= width) return text;
+  if (width <= 3) return plain.slice(0, width);
+  return plain.slice(0, width - 3) + "...";
+}
+
+function center(text, width) {
+  const pad = Math.max(0, Math.floor((width - visible(text)) / 2));
+  return " ".repeat(pad) + text;
+}
+
+function padRight(text, width) {
+  const missing = width - visible(text);
+  return missing > 0 ? text + " ".repeat(missing) : truncate(text, width);
+}
+
+function initialState() {
+  const cfg = storage.getConfig();
+  return {
+    input: "",
+    cursor: 0,
+    history: [],
+    historyIndex: -1,
+    messages: [],
+    busy: false,
+    frame: 0,
+    menuIndex: 0,
+    balance: null,
+    model: cfg.model || null,
+    theme: cfg.theme || "default",
+    suspended: false,
+    version: "0.2.0",
+  };
+}
+
+/* ------------------------------------------------------------------ layout */
+
+function headerLines(state, width, rows) {
+  if (state.messages.length) return [];
+  const art = mascot.split("\n");
+  const visibleArt = rows >= 46 ? art : art.slice(0, 9);
+  const lines = visibleArt.map((line) => center(paint(state.theme, line), width));
+  lines.push("");
+  lines.push(center(chalk.bold("O que voce quer fazer?"), width));
+  lines.push(
+    center(chalk.dim("Use / para comandos  |  Enter envia  |  Ctrl+C sai"), width)
+  );
+  lines.push("");
+  return lines;
+}
+
+function messageLines(state, width) {
+  const lines = [];
+  for (const message of state.messages) {
+    if (message.role === "user") {
+      lines.push("");
+      const body = wrap(message.text, width - 2);
+      lines.push(chalk.cyan("> ") + chalk.bold(body[0] || ""));
+      for (let index = 1; index < body.length; index += 1) {
+        lines.push("  " + chalk.bold(body[index]));
+      }
+    } else if (message.role === "assistant") {
+      lines.push("");
+      for (const line of wrap(message.text, width - 2)) lines.push("  " + line);
+      const meta = [
+        message.ms ? `${(message.ms / 1000).toFixed(1)}s` : null,
+        message.provider,
+      ]
+        .filter(Boolean)
+        .join(" | ");
+      if (meta) lines.push(chalk.dim("  " + meta));
+    } else {
+      lines.push("");
+      const color = message.error ? chalk.red : chalk.dim;
+      for (const line of wrap(message.text, width - 2)) lines.push(color("  " + line));
+    }
+  }
+  if (state.busy) {
+    lines.push("");
+    lines.push(chalk.dim(`  pensando${".".repeat(state.frame % 4)}`));
+  }
+  return lines;
+}
+
+function filteredCommands(state, commands) {
+  if (!state.input.startsWith("/") || state.input.includes(" ")) return [];
+  const query = state.input.toLowerCase();
+  return Object.entries(commands).filter(([name]) =>
+    name.toLowerCase().startsWith(query)
+  );
+}
+
+function menuLines(state, commands, width) {
+  const items = filteredCommands(state, commands).slice(0, 8);
+  if (!items.length) return [];
+  return items.map(([name, description], index) => {
+    const selected = index === state.menuIndex % items.length;
+    const text = truncate(` ${name}`.padEnd(24) + description, width);
+    return selected ? chalk.inverse(padRight(text, width)) : chalk.dim(text);
+  });
+}
+
+function footerLines(state, width) {
+  const name = state.version ? `kafox ${state.version}` : "kafox";
+  const left = chalk.dim(truncate(`${name}  |  ${state.model || "auto"}`, width - 16));
+  const right = chalk.green(
+    state.balance == null ? "saldo --" : `R$ ${(state.balance / 1_000_000).toFixed(2)}`
+  );
+  const gap = " ".repeat(Math.max(1, width - visible(left) - visible(right)));
+  return [
+    left + gap + right,
+    chalk.dim(truncate(process.cwd(), width)),
+    chalk.dim(truncate("Enter envia  |  / comandos  |  Ctrl+C sai", width)),
+  ];
+}
+
+function buildFrame(state, cols, rows, commands) {
+  const width = Math.min(cols - 2, 108);
+  const margin = Math.floor((cols - width) / 2);
+  const gutter = " ".repeat(Math.max(0, margin));
+
+  const header = headerLines(state, width, rows);
+  const menu = menuLines(state, commands, width);
+  const footer = footerLines(state, width);
+
+  const inputWidth = width - 2;
+  const start = state.input.length > inputWidth
+    ? clamp(state.cursor - (inputWidth - 2), 0, Math.max(0, state.input.length - inputWidth))
+    : 0;
+  const shown = state.input.slice(start, start + inputWidth);
+  const inputLine = state.input
+    ? chalk.cyan("> ") + shown
+    : chalk.cyan("> ") + chalk.dim(truncate("Pergunte alguma coisa...", inputWidth));
+  const rule = chalk.dim("-".repeat(width));
+
+  const reserved = footer.length + menu.length + 3;
+  const available = Math.max(1, rows - header.length - reserved);
+  let body = messageLines(state, width);
+  if (body.length > available) body = body.slice(body.length - available);
+  while (body.length < available) body.unshift("");
+
+  const raw = [...header, ...body, "", ...menu, inputLine, rule, ...footer];
+  while (raw.length < rows) raw.push("");
+  const lines = raw.slice(0, rows).map((line) => gutter + padRight(line, width));
+
+  const inputRow = header.length + available + 1 + menu.length + 1;
+  const cursorCol = Math.max(1, margin + 2 + (state.cursor - start) + 1);
+  return { lines, cursorRow: Math.min(rows, inputRow), cursorCol };
+}
+
+/* --------------------------------------------------------------------- app */
+
+async function runTUI({ commands = {}, onCommand, interactiveCommands = new Set() } = {}) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const state = initialState();
+  let spinner = null;
+  let closed = false;
+
+  const write = (value) => stdout.write(value);
+  const enterScreen = () => write("\x1b[?1049h\x1b[?25l\x1b[H\x1b[2J");
+  const leaveScreen = () => write("\x1b[?25h\x1b[?1049l");
+
+  async function refreshAccount() {
+    const token = await ensureSession();
+    if (!token) return;
+    const response = await fetchApi("/api/bootstrap").catch(() => null);
+    if (!response || !response.ok) return;
+    const data = await response.json().catch(() => null);
+    if (data?.user) state.balance = data.user.balance_micros;
+
+    if (!state.model) {
+      const pricing = await fetchApi("/api/public/pricing")
+        .then((res) => res.json())
+        .catch(() => null);
+      state.model = pricing?.pricing?.[0]?.model || null;
+    }
+  }
+
+  function render() {
+    if (closed || state.suspended) return;
+    const cols = Math.max(40, stdout.columns || 80);
+    const rows = Math.max(16, stdout.rows || 24);
+    const frame = buildFrame(state, cols, rows, commands);
+    write("\x1b[?25l\x1b[H" + frame.lines.join("\r\n"));
+    write(`\x1b[${frame.cursorRow};${frame.cursorCol}H\x1b[?25h`);
+  }
+
+  async function capture(fn) {
+    const original = console.log;
+    const collected = [];
+    console.log = (...args) => collected.push(args.map((item) => String(item)).join(" "));
+    try {
+      await fn();
+    } catch (error) {
+      collected.push(`Erro: ${error.message}`);
+    } finally {
+      console.log = original;
+    }
+    return collected.join("\n");
+  }
+
+  async function runOutside(line) {
+    state.suspended = true;
+    leaveScreen();
+    stdin.setRawMode(false);
+    stdin.pause();
+    try {
+      await onCommand(line);
+    } finally {
+      stdin.resume();
+      stdin.setRawMode(true);
+      state.suspended = false;
+      enterScreen();
+      await refreshAccount();
+      render();
+    }
+  }
+
+  async function runCommand(line) {
+    const name = line.split(/\s+/)[0];
+    if (name === "/exit" || name === "/quit") return quit();
+
+    if (name === "/clear") {
+      state.messages = [];
+      state.status = "";
+      return render();
+    }
+    if (name === "/compact") {
+      if (!state.messages.length) {
+        state.messages.push({ role: "system", text: "Nada para compactar." });
+      } else {
+        const total = state.messages.length;
+        state.messages = [
+          {
+            role: "system",
+            text: `Contexto compactado: ${total} mensagens resumidas.`,
+          },
+          ...state.messages.slice(-6),
+        ];
+      }
+      return render();
+    }
+
+    if (interactiveCommands.has(name)) return runOutside(line);
+
+    const before = state.messages.length;
+    const output = (await capture(() => onCommand(line))).trim();
+    if (output) state.messages.push({ role: "system", text: output });
+    else if (state.messages.length === before) {
+      state.messages.push({ role: "system", text: `${name}: sem saida.` });
+    }
+    state.model = storage.getConfig().model || state.model;
+    render();
+    await refreshAccount();
+    render();
+  }
+
+  async function submit() {
+    const line = state.input.trim();
+    if (!line || state.busy) return;
+    state.history.push(line);
+    state.historyIndex = state.history.length;
+    state.input = "";
+    state.cursor = 0;
+    state.menuIndex = 0;
+
+    if (line.startsWith("/")) return runCommand(line);
+
+    state.messages.push({ role: "user", text: line });
+    state.busy = true;
+    render();
+
+    const result = await askModel(line, { model: state.model });
+    state.busy = false;
+    if (result.ok) {
+      state.messages.push({
+        role: "assistant",
+        text: result.text,
+        ms: result.ms,
+        provider: result.provider,
+      });
+    } else {
+      state.messages.push({ role: "system", text: result.error || "Falha ao responder.", error: true });
+    }
+    render();
+    await refreshAccount();
+    render();
+  }
+
+  function setInput(value, cursor) {
+    state.input = value;
+    state.cursor = cursor == null ? value.length : clamp(cursor, 0, value.length);
+    state.menuIndex = 0;
+    render();
+  }
+
+  function onKey(str, key = {}) {
+    if (state.suspended) return;
+    if (key.ctrl && key.name === "c") return quit();
+
+    const items = filteredCommands(state, commands);
+    const menuOpen = items.length > 0;
+
+    if (key.name === "return") return submit();
+    if (key.name === "tab") {
+      if (menuOpen) {
+        const selected = items[state.menuIndex % items.length];
+        return setInput(selected[0] + " ");
+      }
+      return;
+    }
+    if (key.name === "escape") {
+      if (menuOpen) return setInput("");
+      return;
+    }
+    if (key.name === "up" || key.name === "down") {
+      if (menuOpen) {
+        const delta = key.name === "up" ? -1 : 1;
+        state.menuIndex = (state.menuIndex + delta + items.length) % items.length;
+        return render();
+      }
+      if (!state.history.length) return;
+      const delta = key.name === "up" ? -1 : 1;
+      const next = clamp(state.historyIndex + delta, 0, state.history.length);
+      state.historyIndex = next;
+      if (next === state.history.length) return setInput("");
+      return setInput(state.history[next]);
+    }
+    if (key.name === "left") {
+      return setInput(state.input, state.cursor - 1);
+    }
+    if (key.name === "right") {
+      return setInput(state.input, state.cursor + 1);
+    }
+    if (key.name === "home") return setInput(state.input, 0);
+    if (key.name === "end") return setInput(state.input, state.input.length);
+    if (key.name === "backspace") {
+      if (!state.cursor) return;
+      return setInput(
+        state.input.slice(0, state.cursor - 1) + state.input.slice(state.cursor),
+        state.cursor - 1
+      );
+    }
+    if (key.name === "delete") {
+      if (state.cursor >= state.input.length) return;
+      return setInput(
+        state.input.slice(0, state.cursor) + state.input.slice(state.cursor + 1),
+        state.cursor
+      );
+    }
+    if (key.ctrl && key.name === "u") return setInput("");
+    if (key.ctrl && key.name === "w") {
+      const before = state.input.slice(0, state.cursor).replace(/\s*\S*$/, "");
+      return setInput(before + state.input.slice(state.cursor), before.length);
+    }
+    if (key.ctrl && key.name === "l") {
+      write("\x1b[H\x1b[2J");
+      return render();
+    }
+
+    if (str && !key.ctrl && !key.meta) {
+      const text = str.replace(/[\x00-\x1f\x7f]/g, "");
+      if (!text) return;
+      setInput(
+        state.input.slice(0, state.cursor) + text + state.input.slice(state.cursor),
+        state.cursor + text.length
+      );
+    }
+  }
+
+  function quit() {
+    if (closed) return;
+    closed = true;
+    if (spinner) clearInterval(spinner);
+    stdin.removeListener("keypress", onKey);
+    stdout.removeListener("resize", render);
+    try {
+      stdin.setRawMode(false);
+    } catch {}
+    leaveScreen();
+    write("\n");
+    process.exit(0);
+  }
+
+  enterScreen();
+  if (stdin.isTTY) stdin.setRawMode(true);
+  stdin.resume();
+  readline.emitKeypressEvents(stdin);
+  stdin.on("keypress", onKey);
+  stdout.on("resize", render);
+
+  await refreshAccount();
+  render();
+
+  spinner = setInterval(() => {
+    if (!state.busy || closed) return;
+    state.frame += 1;
+    render();
+  }, 110);
+  spinner.unref?.();
+
+  return { state, quit, render, submit };
+}
+
+module.exports = { runTUI, buildFrame, wrap, initialState, filteredCommands };