kafox-cli 0.0.0-stage → 0.1.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-0.1.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,22 @@
 {
   "name": "kafox-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Kafox CLI in opencode style: REPL, account 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"
+  }
 }

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,243 @@
+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 { runTheme, setContentBackground, paint } = require("./theme");
+const { mascot } = require("./mascot");
+
+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 [k, v] of Object.entries(COMMANDS)) {
+        console.log(`  ${chalk.bold(k)}  ${chalk.dim(v)}`);
+      }
+      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}`);
+}
+
+async function runREPL() {
+  const cfg = storage.getConfig();
+  const theme = cfg.theme || "default";
+
+  console.log(paint(theme, mascot));
+  console.log(paint(theme, "\n  Kafox CLI  v0.1.0  -  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);
+        process.stdout.write(chalk.dim("thinking..."));
+        await ask(line, { model: modelOverride || storage.getConfig().model });
+        pushHistory("assistant", "(answer above)");
+        process.stdout.write("\r");
+      }
+    } catch (err) {
+      console.log(chalk.red(`\nError: ${err.message}`));
+    }
+    rl.prompt();
+  });
+
+  rl.on("close", () => {
+    console.log(chalk.dim("\nSee you."));
+    process.exit(0);
+  });
+}
+
+module.exports = {
+  runREPL,
+  compact,
+  clearContext,
+  showStatus,
+  handleCommand,
+  COMMANDS,
+};

package/src/gateway.js

@@ -0,0 +1,102 @@
+const chalk = require("chalk");
+const storage = require("./storage");
+const { ensureSession, fetchApi } = require("./auth");
+
+async function ask(question, options = {}) {
+  const text = typeof question === "string" ? question : (question || []).join(" ");
+  if (!text.trim()) {
+    console.log(chalk.dim('Usage: kafox ask "your question" [-m model]'));
+    return;
+  }
+
+  const token = await ensureSession();
+  if (!token) {
+    console.log(chalk.yellow("Login first: `kafox login`"));
+    return;
+  }
+
+  // Saldo decide se a CLI responde: sem credito, nem chega no gateway.
+  const boot = await fetchApi("/api/bootstrap");
+  if (!boot.ok) {
+    console.log(chalk.red("Session invalid. Run `kafox login`"));
+    return;
+  }
+  const account = await boot.json();
+  const balance = Number(account?.user?.balance_micros || 0);
+  if (balance <= 0) {
+    console.log(
+      chalk.red("\nSem saldo para responder. Recarregue em https://kafox.pypag.com/dashboard")
+    );
+    return;
+  }
+
+  let model = options.model || storage.getConfig().model;
+  if (!model) {
+    const pricing = await fetchApi("/api/public/pricing")
+      .then((r) => r.json())
+      .catch(() => null);
+    model = pricing?.pricing?.[0]?.model;
+    if (!model) {
+      console.log(chalk.red("Could not load model catalog."));
+      return;
+    }
+  }
+
+  let apiKey = storage.getConfig().api_key;
+  if (!apiKey) {
+    const kr = await fetchApi("/api/keys", {
+      method: "POST",
+      body: JSON.stringify({ name: "kafox-cli" }),
+    });
+    const kd = await kr.json().catch(() => ({}));
+    if (!kr.ok) {
+      console.log(chalk.red(`Failed to create key: ${kd.error || "error"}`));
+      return;
+    }
+    apiKey = kd.secret;
+    storage.setConfig({ api_key: apiKey });
+    console.log(chalk.dim("(key created and saved to ~/.kafox/config.json)"));
+  }
+
+  console.log(chalk.dim(`Model: ${model}`));
+  const res = await fetchApi("/api/public/playground", {
+    method: "POST",
+    body: JSON.stringify({ api_key: apiKey, model, message: text }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    if (res.status === 402) {
+      console.log(
+        chalk.red("\nNo balance! Recharge at https://kafox.pypag.com/dashboard")
+      );
+    } else {
+      console.log(chalk.red(`\nFailed: ${data.error || "gateway error"}`));
+    }
+    return;
+  }
+  // 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) {
+      console.log(
+        chalk.red("\nNo balance! Recharge at https://kafox.pypag.com/dashboard")
+      );
+    } else {
+      console.log(chalk.red(`\nFailed (${data.status}): ${detail}`));
+    }
+    return;
+  }
+  const body = data.body;
+  const out =
+    typeof body === "string"
+      ? body
+      : body?.choices?.[0]?.message?.content
+      || body?.choices?.[0]?.text
+      || JSON.stringify(body, null, 2);
+  console.log(chalk.green("\nAnswer:"));
+  console.log(out);
+  if (data.ms) console.log(chalk.dim(`\n(${data.ms}ms  provider ${data.provider || "?"})`));
+}
+
+module.exports = { ask };

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 };