kafox-cli 0.6.0 → 0.7.0

package/src/cli.js

@@ -16,8 +16,8 @@ const { version: VERSION } = require("../package.json");
 
 const COMMANDS = {
   "/help": "show this help",
-  "/models": "list models and prices",
-  "/model": "choose the default model (picker)",
+  "/models": "escolhe o modelo (setas, mouse ou Enter)",
+  "/model": "escolhe o modelo no seletor, ou direto com /model <id>",
   "/balance": "show balance",
   "/pricing": "show recharge packages",
   "/key": "create an API key",
@@ -25,6 +25,7 @@ const COMMANDS = {
   "/logout": "end the session",
   "/whoami": "show the linked account",
   "/theme": "open theme selector",
+  "/agents": "lista os subagentes desta sessao (objetivo, ferramentas, tempo)",
   "/mcp": "list MCP servers and tools (/mcp reload reconecta)",
   "/allow": "aprovacao automatica nesta sessao (/allow off volta a perguntar)",
   "/background": "set background image (modal asks for URL)",
@@ -116,6 +117,33 @@ async function handleCommand(line) {
       );
       return true;
     }
+    case "/agents": {
+      const { listRuns } = require("./subagents");
+      const runs = listRuns();
+      if (!runs.length) {
+        console.log(chalk.dim("\nNenhum subagente nesta sessao."));
+        console.log(
+          chalk.dim(
+            "O agente abre subagentes sozinho quando dividir ajuda: objetivo proprio,\n" +
+              "ate 3 em paralelo, cada um em contexto separado. Para pedir na mao:\n" +
+              '  "lanca dois subagentes: um revisa src/agent.js e outro roda os testes do backend"'
+          )
+        );
+        return true;
+      }
+      console.log(chalk.cyan(`\nSubagentes desta sessao (${runs.length}):\n`));
+      for (const run of runs) {
+        const status = run.ok ? chalk.green("ok") : chalk.red("falhou");
+        console.log(`  ${status} ${chalk.bold(run.objective.slice(0, 90))}`);
+        console.log(
+          chalk.dim(
+            `       ${run.tools.join(", ") || "read_file"} · ${run.steps} passo(s) · ${Math.round(run.ms / 1000)}s`
+          )
+        );
+      }
+      console.log("");
+      return true;
+    }
     case "/mcp": {
       const { McpHub } = require("./mcp");
       const hub = new McpHub({ cwd: process.cwd() });
@@ -290,6 +318,8 @@ async function runREPL(options = {}) {
     // /theme roda dentro da TUI (modal com preview); os demais abrem prompt no terminal.
     interactiveCommands: new Set(["/login", "/key", "/background"]),
     autoApprove: Boolean(options?.allowAll),
+    // kafox --resume <codigo> volta para a conversa salva em ~/.kafox/chats.
+    resume: options?.resume || null,
   });
 }
 

package/src/gateway.js

@@ -70,6 +70,46 @@ function mergeToolCalls(target, deltas) {
   }
 }
 
+/* ---------------------------------------------------------------- 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 });
+  });
+}
+
 function errorFrom(data, status) {
   const message =
     data?.error?.message || data?.error || data?.body?.error?.message || `gateway error (${status})`;
@@ -81,10 +121,10 @@ function errorFrom(data, status) {
 }
 
 /**
- * Chat completions com stream (SSE) via /api/chat.
- * onDelta/onReasoning recebem o texto conforme chega; no fim devolve tudo junto.
+ * Uma tentativa: request + leitura do stream.
+ * Devolve `retryable` quando o erro foi de rede/servidor e ainda nao veio texto.
  */
-async function chat({ messages, model, tools, onDelta, onReasoning, signal } = {}) {
+async function attemptChat({ messages, model, tools, onDelta, onReasoning, signal } = {}) {
   const ready = await ensureReady({ model });
   if (!ready.ok) return ready;
 
@@ -105,12 +145,22 @@ async function chat({ messages, model, tools, onDelta, onReasoning, signal } = {
     });
   } catch (error) {
     if (error?.name === "AbortError") return { ok: false, code: "aborted", error: "Cancelado." };
-    return { ok: false, error: `Falha de rede: ${error.message}` };
+    return {
+      ok: false,
+      error: `Falha de rede: ${error.message}`,
+      retryable: retryableMessage(error.message),
+      keyCreated: ready.keyCreated,
+    };
   }
 
   if (!response.ok) {
     const data = await response.json().catch(() => ({}));
-    return { ...errorFrom(data, response.status), status: response.status, keyCreated: ready.keyCreated };
+    return {
+      ...errorFrom(data, response.status),
+      status: response.status,
+      keyCreated: ready.keyCreated,
+      retryable: RETRYABLE_STATUS.has(response.status),
+    };
   }
 
   const decoder = new TextDecoder();
@@ -131,7 +181,8 @@ async function chat({ messages, model, tools, onDelta, onReasoning, signal } = {
       return null;
     }
     if (event?.error) {
-      return { error: event.error.message || String(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;
@@ -158,7 +209,7 @@ async function chat({ messages, model, tools, onDelta, onReasoning, signal } = {
         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 };
+        if (failure) return { ok: false, error: failure.error, retryable: failure.retryable };
         index = buffer.indexOf("\n");
       }
     }
@@ -167,7 +218,12 @@ async function chat({ messages, model, tools, onDelta, onReasoning, signal } = {
     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 };
+    return {
+      ok: false,
+      error: `Stream interrompido: ${error.message}`,
+      text,
+      retryable: retryableMessage(error.message),
+    };
   }
 
   return {
@@ -183,6 +239,35 @@ async function chat({ messages, model, tools, onDelta, onReasoning, signal } = {
   };
 }
 
+/**
+ * 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 };
+  }
+
+  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(" ");
@@ -217,4 +302,13 @@ async function ask(question, options = {}) {
   }
 }
 
-module.exports = { ask, askModel, chat, ensureReady, mergeToolCalls };
+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/models.js

@@ -16,12 +16,9 @@ async function listModels() {
   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)}`);
+  console.log(chalk.dim(`\nGateway: ${data.gateway_url}`));
 }
 
 async function showBalance() {

package/src/runner.js

@@ -0,0 +1,98 @@
+const chalk = require("chalk");
+const { runAgent } = require("./agent");
+
+/**
+ * Roda o agente sem TUI: serve para script, CI e para usar o kafox como
+ * "agente auditor" de outro processo.
+ *
+ *   kafox agent "revise src/x.js e aponte bugs" [-m modelo] [-y] [--max-steps 12]
+ *
+ * Sem --max-steps o agente roda ate terminar (Ctrl+C aborta).
+ */
+async function runHeadless({
+  prompt,
+  model,
+  allowAll = false,
+  maxSteps = Infinity,
+  cwd = process.cwd(),
+  quiet = false,
+  json = false,
+} = {}) {
+  if (!prompt || !String(prompt).trim()) {
+    throw new Error("informe o objetivo do agente");
+  }
+
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  process.once("SIGINT", abort);
+  process.once("SIGTERM", abort);
+
+  const log = (line) => {
+    if (!quiet && !json) process.stderr.write(`${line}\n`);
+  };
+
+  const events = [];
+  const denied = [];
+  const subagents = [];
+
+  const result = await runAgent({
+    messages: [{ role: "user", content: String(prompt) }],
+    model,
+    cwd,
+    maxSteps,
+    signal: controller.signal,
+    autoApprove: () => allowAll,
+    approve: async (name, args, context) => {
+      if (allowAll) return true;
+      denied.push(name);
+      log(chalk.dim(`[${name}] negado (use --allow-all para liberar)`));
+      return false;
+    },
+    onText: (chunk) => {
+      if (!json) process.stdout.write(chunk);
+    },
+    onToolStart: ({ name, label, subagent }) => {
+      events.push({ type: "tool-start", name, label });
+      log(
+        chalk.dim(
+          `[${name}] ${String(label || "").slice(0, 140)}${
+            subagent ? ` (${subagent.count} subagente(s))` : ""
+          }`
+        )
+      );
+    },
+    onToolResult: ({ name, ok, ms, summary }) => {
+      events.push({ type: "tool-result", name, ok, ms });
+      log(chalk.dim(`[${name}] ${ok ? "ok" : "falhou"} · ${ms}ms · ${String(summary || "").slice(0, 120)}`));
+    },
+    onSubagentEvent: (event) => {
+      if (event.phase === "start") {
+        subagents.push({ objective: event.objective, tools: event.tools });
+        log(chalk.dim(`[subagente ${event.index}/${event.total}] ${event.objective}`));
+      } else if (event.phase === "tool") {
+        log(chalk.dim(`[subagente ${event.index}/${event.total}] ${event.tool}: ${String(event.text || "").slice(0, 100)}`));
+      } else if (event.phase === "done") {
+        log(chalk.dim(`[subagente ${event.index}/${event.total}] ${event.ok ? "concluído" : "falhou"} em ${event.ms}ms`));
+      }
+    },
+  });
+
+  if (!json && !quiet && result.text) process.stdout.write("\n");
+
+  const payload = {
+    ok: Boolean(result.ok),
+    text: result.text || "",
+    steps: result.steps || 0,
+    ms: result.ms || 0,
+    error: result.error || null,
+    aborted: Boolean(result.aborted),
+    tools: events,
+    subagents,
+    denied,
+  };
+  if (json) process.stdout.write(`${JSON.stringify(payload)}\n`);
+
+  return payload;
+}
+
+module.exports = { runHeadless };

package/src/sessions.js

@@ -0,0 +1,138 @@
+/**
+ * Historico de conversas do CLI.
+ *
+ * Cada sessao vira um arquivo em ~/.kafox/chats/<codigo>.json e o codigo curto
+ * e o que aparece no `kafox resume <codigo>` (e no `kafox history`).
+ */
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const storage = require("./storage");
+
+// Poda: com muitos arquivos a pasta vira lixo e o `history` precisa listar rapido.
+const MAX_SESSIONS = 60;
+const TITLE_MAX = 60;
+
+const FALLBACK_DIR = process.env.KAFOX_HOME
+  ? path.resolve(process.env.KAFOX_HOME)
+  : path.join(os.homedir(), ".kafox");
+
+// storage.DIR vem do modulo real; em teste ele pode ser stub, entao nunca
+// confiar cegamente (path.join(undefined) estoura).
+function baseDir() {
+  return storage.DIR || FALLBACK_DIR;
+}
+
+function chatsDir() {
+  return path.join(baseDir(), "chats");
+}
+
+function ensureDir() {
+  fs.mkdirSync(chatsDir(), { recursive: true, mode: 0o700 });
+}
+
+function newId() {
+  return crypto.randomBytes(4).toString("hex");
+}
+
+function fileFor(id) {
+  return path.join(chatsDir(), `${id}.json`);
+}
+
+/** Titulo curto: primeira mensagem do usuario, em uma linha. */
+function titleFrom(messages, fallback = "") {
+  const first = (messages || []).find(
+    (message) => message?.role === "user" && String(message.text || "").trim()
+  );
+  const text = String(first?.text || fallback || "")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (!text) return "conversa sem titulo";
+  return text.length > TITLE_MAX ? `${text.slice(0, TITLE_MAX - 1).trimEnd()}…` : text;
+}
+
+function save({ id, cwd, model, theme, messages, context, startedAt, title }) {
+  if (!id) return null;
+  ensureDir();
+  const now = new Date().toISOString();
+  const list = Array.isArray(messages) ? messages : [];
+  const data = {
+    id,
+    title: title || titleFrom(list),
+    cwd: cwd || process.cwd(),
+    model: model || null,
+    theme: theme || null,
+    startedAt: startedAt || now,
+    updatedAt: now,
+    messages: list,
+    context: Array.isArray(context) ? context : [],
+  };
+  const tmp = `${fileFor(id)}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(data), { mode: 0o600 });
+  fs.renameSync(tmp, fileFor(id));
+  prune();
+  return data;
+}
+
+function load(id) {
+  if (!id) return null;
+  try {
+    const data = JSON.parse(fs.readFileSync(fileFor(id), "utf8"));
+    if (!data || typeof data !== "object") return null;
+    // Arquivo antigo pode nao ter titulo: deriva das mensagens.
+    if (!data.title) data.title = titleFrom(data.messages);
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+function list() {
+  let names = [];
+  try {
+    names = fs.readdirSync(chatsDir()).filter((name) => name.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const chats = [];
+  for (const name of names) {
+    const id = name.replace(/\.json$/, "");
+    const data = load(id);
+    if (!data) continue;
+    chats.push({
+      id,
+      title: data.title || titleFrom(data.messages),
+      cwd: data.cwd,
+      model: data.model,
+      updatedAt: data.updatedAt,
+      messages: (data.messages || []).length,
+    });
+  }
+  return chats.sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)));
+}
+
+function latest() {
+  return list()[0] || null;
+}
+
+function prune() {
+  for (const chat of list().slice(MAX_SESSIONS)) {
+    try {
+      fs.unlinkSync(fileFor(chat.id));
+    } catch {}
+  }
+}
+
+module.exports = {
+  MAX_SESSIONS,
+  TITLE_MAX,
+  chatsDir,
+  newId,
+  titleFrom,
+  save,
+  load,
+  list,
+  latest,
+  prune,
+};

package/src/storage.js

@@ -4,7 +4,8 @@ const path = require("path");
 const os = require("os");
 
 const HOME = os.homedir();
-const DIR = path.join(HOME, ".kafox");
+// KAFOX_HOME aponta a pasta de configuracao direto (testes e uso portatil).
+const DIR = process.env.KAFOX_HOME ? path.resolve(process.env.KAFOX_HOME) : path.join(HOME, ".kafox");
 const TOKEN_FILE = path.join(DIR, "token.json");
 const CONFIG_FILE = path.join(DIR, "config.json");