kafox-cli 0.9.9 → 0.10.0

package/bin/kafox.js

@@ -63,6 +63,18 @@ program.command("models").description("List available models").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("provider")
+  .alias("provedor")
+  .description("Gerencia provedores alternativos (chaves de API externas)")
+  .argument("[provider]", "Provedor")
+  .argument("[chave]", "Chave de API do provedor")
+  .option("--off", "remove a chave salva do provedor")
+  .option("-l, --list", "lista os provedores e os modelos disponiveis")
+  .action(async (provider, chave, options) => {
+    const { runProvider } = require("../src/providers-cli");
+    await runProvider({ provider, chave, off: options.off, list: options.list });
+  });
 program.command("ask").argument("[question...]", "Question").option("-m, --model <id>", "Model").action(ask);
 program
   .command("agent")
@@ -106,6 +118,72 @@ program
   .alias("c")
   .description("Continua a conversa mais recente")
   .action(() => runREPL({ allowAll: Boolean(program.opts().allowAll), resume: "last" }));
+program
+  .command("mobile [acao] [alvo]")
+  .description("Usa o Kafox pelo celular via QR Code (mesma sessão da CLI)")
+  .option("--last", "usa a conversa mais recente sem perguntar")
+  .option("-n, --new", "começa uma conversa nova, sem abrir o seletor")
+  .option("-p, --port <n>", "porta local (padrao: 7788, com fallback se ocupada)")
+  .option("--lan", "expoe na rede local (0.0.0.0) e usa o IP da maquina no QR")
+  .option("--public-url <url>", "URL publica que vai no QR (ex.: https://web.kafox.dev/)")
+  .option("--readonly", "celular só acompanha: não digita nem aprova")
+  .option("-d, --daemon", "roda em background (terminal livre); use `kafox mobile log <id>` para rever o QR")
+  .option("--revoke", "revoga todos os pareamentos do celular e sai")
+  .action(async (acao, alvo, options) => {
+    const mobile = require("../src/mobile");
+    const auth = require("../src/mobile/auth");
+
+    // O commander muda o "shape" dos argumentos conforme a aridade:
+    //   `kafox mobile`              -> action(options)
+    //   `kafox mobile list`         -> action(acao, options)
+    //   `kafox mobile kill all`     -> action(acao, alvo, options)
+    // Aqui a gente normaliza: separa strings (posicionais) de objetos (options).
+    const positional = [acao, alvo].filter((v) => typeof v === "string");
+    const optsCandidates = [acao, alvo, options].filter((v) => v && typeof v === "object");
+    const opts = optsCandidates[optsCandidates.length - 1] || {};
+    const first = positional[0] || "";
+    const second = positional[1] || "";
+
+    // subcomandos: `kafox mobile list` / `kill` / `log`
+    if (first === "list" || first === "ls") {
+      return mobile.printMobileList();
+    }
+    if (first === "kill") {
+      return mobile.killMobileSessions(second || null);
+    }
+    if (first === "log" || first === "qr") {
+      return mobile.printMobileLog(second || null);
+    }
+
+    if (opts.revoke) {
+      const removed = auth.revoke({ all: true });
+      console.log(
+        removed
+          ? chalk.green(`Revogados ${removed} pareamento(s) do celular.`)
+          : chalk.dim("Nenhum celular pareado.")
+      );
+      return;
+    }
+
+    // Fluxo principal: HEADLESS (menu de conversas + QR), SEM abrir a TUI no PC.
+    // O celular vira o cliente da sessao via SessionBridge.
+    const code = opts.new ? null : opts.last ? "last" : first || null;
+    const common = {
+      code,
+      port: opts.port ? Number(opts.port) : undefined,
+      lan: Boolean(opts.lan),
+      publicUrl: opts.publicUrl,
+      readonly: Boolean(opts.readonly),
+      allowAll: Boolean(program.opts().allowAll),
+    };
+
+    // --daemon: destaca o processo (setsid) e devolve o terminal. O filho roda
+    // o fluxo normal e grava PID/porta no registro, entao `list/kill/log` acham.
+    if (opts.daemon) {
+      return mobile.spawnMobileDaemon(common);
+    }
+    return mobile.runMobile(common);
+  });
 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kafox-cli",
-  "version": "0.9.9",
+  "version": "0.10.0",
   "description": "Kafox CLI: TUI com streaming, thinking, edit com diff, agent tools (files/shell), MCP e temas",
   "repository": {
     "type": "git",

package/src/agent.js

@@ -1,4 +1,5 @@
 const { chat } = require("./gateway");
+const { compactIfNeeded, estimateTokens, DEFAULT_THRESHOLD_TOKENS } = require("./compact");
 const {
   TOOL_SPECS,
   APPROVAL_REQUIRED,
@@ -219,6 +220,11 @@ async function runAgent({
   onToolResult,
   onSubagentEvent,
   onRetry,
+  // Compactacao de contexto: `compact:false` desliga; o limiar e em tokens.
+  compact = true,
+  compactThreshold = DEFAULT_THRESHOLD_TOKENS,
+  compactSummarize = null,
+  onCompact,
 } = {}) {
   const conversation = messages.map((message) => ({ ...message }));
   if (!conversation.length || conversation[0].role !== "system") {
@@ -243,6 +249,24 @@ async function runAgent({
       return { ok: true, aborted: true, text: last.text, messages: conversation, steps: step };
     }
 
+    // Contexto grande e reenviado inteiro a cada passo e cobrado por token:
+    // passando do limiar, troca a parte antiga por um resumo. Nunca quebra o
+    // turno — se o resumo falhar, segue com o historico completo.
+    if (compact !== false && estimateTokens(conversation) > compactThreshold) {
+      const result = await compactIfNeeded(conversation, {
+        model,
+        thresholdTokens: compactThreshold,
+        signal,
+        summarize: compactSummarize,
+      });
+      if (result.compacted) {
+        // `conversation` e const: troca o conteudo, nao a referencia.
+        conversation.length = 0;
+        conversation.push(...result.messages);
+        onCompact?.({ before: result.before, after: result.after, summary: result.summary });
+      }
+    }
+
     const started = Date.now();
     const result = await chat({
       messages: conversation,

package/src/auth.js

@@ -6,12 +6,31 @@ 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;
+  const candidates = storage.apiUrlCandidates();
+  let lastError = null;
+  for (const base of candidates) {
+    const url = `${base}${pathname}`;
+    try {
+      return await fetch(url, {
+        ...options,
+        headers: { ...storage.getAuthHeaders(options.headers), ...options.headers },
+        // timeout por tentativa: nao deixa um host travado segurar o login.
+        signal: AbortSignal.timeout ? AbortSignal.timeout(12000) : undefined,
+      });
+    } catch (error) {
+      lastError = error;
+      // So faz fallback em erro de REDE (DNS/timeout/recusa), nunca em HTTP 4xx/5xx.
+      const netError =
+        error?.cause?.code === "UND_ERR_CONNECT_TIMEOUT" ||
+        error?.cause?.code === "ECONNREFUSED" ||
+        error?.cause?.code === "ENOTFOUND" ||
+        error?.name === "TimeoutError" ||
+        /fetch failed|Timeout/i.test(String(error?.message || ""));
+      if (!netError) throw error;
+      // tenta o proximo host; o ultimo erro sera lancado se todos falharem.
+    }
+  }
+  throw lastError;
 }
 
 async function ensureSession() {

package/src/cli.js

@@ -31,6 +31,7 @@ const COMMANDS = {
   "/background": "imagem de fundo (/background <arquivo|url>; off remove)",
   "/clear": "clear conversation context",
   "/compact": "compact conversation context",
+  "/queue": "mostra a fila; /queue clear descarta (atalho: ctrl+q)",
   "/status": "show account, balance and gateway status",
   "/exit": "exit the CLI",
 };
@@ -320,6 +321,8 @@ async function runREPL(options = {}) {
     autoApprove: Boolean(options?.allowAll),
     // kafox --resume <codigo> volta para a conversa salva em ~/.kafox/chats.
     resume: options?.resume || null,
+    // `kafox mobile` hospeda o servidor no navegador da mesma sessao.
+    mobile: options?.mobile || null,
   });
 }
 

package/src/compact.js

@@ -0,0 +1,346 @@
+const { chat } = require("./gateway");
+
+/**
+ * Compactacao de contexto.
+ *
+ * O CLI reenvia o historico inteiro a cada passo do loop de ferramentas. Numa
+ * sessao longa isso chega a 100k+ tokens de prompt, e como o provedor cobra o
+ * preco cheio por token de entrada, o custo de cada turno cresce junto. Este
+ * modulo corta o historico quando ele passa do limiar, trocando a parte antiga
+ * por um resumo curto.
+ *
+ * Duas regras que nao podem ser quebradas:
+ *
+ * 1. O provedor exige que toda mensagem `tool` venha logo depois do
+ *    `assistant` que declarou o `tool_call_id`. Cortar no meio desse par
+ *    devolve 400 e derruba o turno. Por isso o corte sempre cai numa
+ *    fronteira segura.
+ * 2. O `system` (indice 0) nunca e removido: e ele que carrega cwd, modelo e
+ *    as regras de ferramenta.
+ */
+
+/**
+ * Limiar padrao: 60k tokens.
+ *
+ * Medido no uso real: sem compactacao o prompt chegou a 160k tokens (o teto da
+ * janela do DeepSeek) e cada turno custava ~R$ 0,17. Em 60k cada turno fica na
+ * faixa de poucos centavos e ainda sobram ~240k caracteres de contexto — o
+ * suficiente para um CLI saber o que ja foi feito.
+ */
+const DEFAULT_THRESHOLD_TOKENS = 60_000;
+// Quantas mensagens recentes ficam intactas depois do resumo.
+const DEFAULT_KEEP_MESSAGES = 8;
+// Teto do resumo: o texto gerado vira contexto permanente, entao nao pode crescer.
+const MAX_SUMMARY_CHARS = 4_000;
+
+/** Estimativa de tokens sem dependencia externa: ~4 caracteres por token. */
+function estimateTokens(messages) {
+  let chars = 0;
+  for (const message of messages || []) {
+    chars += String(message?.content || "").length;
+    // `arguments` das tool calls tambem vai no payload e e cobrado.
+    if (Array.isArray(message?.tool_calls)) {
+      for (const call of message.tool_calls) {
+        chars += String(call?.function?.arguments || "").length;
+        chars += String(call?.function?.name || "").length;
+      }
+    }
+  }
+  return Math.round(chars / 4);
+}
+
+/**
+ * Encontra o indice a partir do qual o historico pode ser cortado sem quebrar
+ * um par assistant(tool_calls) + tool(resultado).
+ *
+ * Um corte em `index` mantem `messages.slice(index)`. Ele so e valido quando a
+ * mensagem em `index` nao e um `tool` orfao nem um `assistant` que ainda vai
+ * receber resultados.
+ */
+function safeCutIndex(messages, wantedIndex) {
+  if (wantedIndex <= 0) return messages.length;
+  let index = Math.min(wantedIndex, messages.length);
+
+  // Volta enquanto a mensagem no corte for um resultado de tool: ela precisa
+  // continuar junto do assistant que a pediu.
+  while (index > 0 && messages[index]?.role === "tool") index -= 1;
+  // Se caiu num assistant com tool_calls, inclui ele e todos os resultados
+  // seguintes (o par completo).
+  if (index > 0 && messages[index]?.role === "assistant" && Array.isArray(messages[index].tool_calls) && messages[index].tool_calls.length) {
+    index -= 1;
+  }
+  // Nunca cortar o system.
+  return Math.max(1, index);
+}
+
+/** Texto corrido do historico, para alimentar o resumo. */
+function transcript(messages, limitPerMessage = 1_500) {
+  return messages
+    .map((message) => {
+      const role = message?.role || "?";
+      let body = String(message?.content || "");
+      if (body.length > limitPerMessage) body = `${body.slice(0, limitPerMessage)}…[truncado]`;
+      if (Array.isArray(message?.tool_calls) && message.tool_calls.length) {
+        const calls = message.tool_calls
+          .map((call) => `${call?.function?.name}(${String(call?.function?.arguments || "").slice(0, 300)})`)
+          .join(", ");
+        body = `${body}\n[ferramentas chamadas: ${calls}]`.trim();
+      }
+      return `${role}: ${body}`;
+    })
+    .join("\n\n");
+}
+
+/**
+ * Instrucoes do resumo estruturado.
+ *
+ * O formato segue o do opencode: secoes fixas, sem prosa. Um resumo em
+ * paragrafos vira ruido no contexto; secoes nomeadas o modelo le e usa.
+ */
+const SUMMARY_SECTIONS = [
+  { key: "objective", title: "Objective", hint: "o que o usuario quer, em 1-3 linhas" },
+  { key: "details", title: "Important Details", hint: "decisoes, restricoes, preferencias ditas pelo usuario" },
+  { key: "completed", title: "Completed", hint: "o que ja foi feito e verificado (com arquivo quando houver)" },
+  { key: "active", title: "Active", hint: "o que estava em andamento no momento do corte" },
+  { key: "blocked", title: "Blocked", hint: "o que travou e por que (ou 'none')" },
+  { key: "next", title: "Next Move", hint: "os proximos passos concretos, numerados" },
+  { key: "files", title: "Relevant Files", hint: "caminhos tocados ou lidos, um por linha (ou 'none')" },
+];
+
+const SUMMARY_INSTRUCTIONS = [
+  "You compact conversation history for a terminal coding agent.",
+  "Write ONLY the fields below, using the exact headings, in this order:",
+  "",
+  ...SUMMARY_SECTIONS.map((section, index) => `${index + 1}. ${section.title}: ${section.hint}`),
+  "",
+  "Rules:",
+  "- Be terse. Bullets or short lines, never paragraphs of prose.",
+  "- Keep exact file paths, commands, identifiers and numbers. Never paraphrase them.",
+  "- Do not invent anything. If a section has nothing, write exactly: none",
+  "- No preamble, no closing remarks, no markdown fences.",
+  "- Write the content in the language the user was using.",
+].join("\n");
+
+/**
+ * Prompt de resumo (exportado: os testes travam o formato).
+ *
+ * `structured` liga o formato em secoes do opencode; sem ele sai um resumo
+ * corrido, util para modelos pequenos que ignoram instrucao longa.
+ */
+function summaryPrompt(messages, { structured = true } = {}) {
+  const system = structured
+    ? SUMMARY_INSTRUCTIONS
+    : "Voce resume historico de conversa entre um desenvolvedor e um agente de terminal. " +
+      "Preserve: objetivo pedido, arquivos tocados, decisoes tomadas, comandos executados e o " +
+      "estado atual do trabalho. Descarte conversa social e repeticoes. Responda em portugues, " +
+      "em no maximo 25 linhas, sem preambulo.";
+  return [
+    { role: "system", content: system },
+    { role: "user", content: transcript(messages) },
+  ];
+}
+
+/**
+ * Mensagem que substitui o historico antigo no contexto do modelo.
+ *
+ * As secoes ficam nomeadas porque o modelo precisa achar "Next Move" e
+ * "Relevant Files" rapido; um paragrafo corrido faz ele reler tudo.
+ */
+function buildCompactionNote(summaryText, messageCount) {
+  return [
+    `[Contexto compactado: ${messageCount} mensagens anteriores viraram este resumo.]`,
+    "",
+    summaryText,
+  ].join("\n");
+}
+
+/** Senhas e chaves nunca vao para o resumo: o texto vai para o provedor. */
+function scrubSecrets(text) {
+  return String(text || "")
+    .replace(/\b(kafox_live_|sk-|ghp_|cfat_|npm_)[A-Za-z0-9_\-]{8,}/g, "$1***")
+    .replace(/\b(Bearer\s+)[A-Za-z0-9._\-]{12,}/gi, "$1***");
+}
+
+/**
+ * Corta uma mensagem grande demais por conta própria.
+ *
+ * Uma única mensagem (saída de `run_command`, arquivo lido, relatório de
+ * subagente) pode sozinha passar do orçamento do contexto. O provedor cobra
+ * cada token dela em todo turno seguinte, então ela é podada na origem mesmo
+ * que o resto da conversa seja curto.
+ *
+ * Mantém o começo e o fim — o começo tem o contexto e o fim costuma ter o
+ * resultado/erro, que é o que importa. O meio vira uma marca explícita.
+ */
+function trimHugeMessage(message, maxChars) {
+  const content = String(message?.content || "");
+  if (content.length <= maxChars) return message;
+
+  const text = `[trecho omitido: ${(content.length - maxChars).toLocaleString("pt-BR")} caracteres]`;
+  // 40% no começo, 60% no fim: o final costuma trazer o resultado.
+  const room = maxChars - text.length - 4;
+  const headLen = Math.floor(room * 0.4);
+  const tailLen = room - headLen;
+  return {
+    ...message,
+    content: `${content.slice(0, headLen)}\n${text}\n${content.slice(content.length - tailLen)}`,
+    truncated: true,
+  };
+}
+
+/**
+ * Poda mensagens individuais que passam de `maxMessageChars`.
+ * Devolve `{ messages, changed }`.
+ */
+function trimHugeMessages(messages, maxMessageChars) {
+  let changed = false;
+  const next = messages.map((message) => {
+    // Tool results e saida de comando sao os casos que incham de verdade.
+    const trimmed = trimHugeMessage(message, maxMessageChars);
+    if (trimmed !== message) changed = true;
+    return trimmed;
+  });
+  return { messages: next, changed };
+}
+
+/**
+ * Compacta o historico quando ele passa do limiar.
+ *
+ * Retorna `{ messages, compacted, before, after, error }`. Quando nao ha nada a
+ * fazer devolve o proprio array (mesma referencia) para o chamador detectar.
+ *
+ * `summarize` existe para teste: por padrao usa o mesmo `chat()` do agente.
+ */
+async function compactIfNeeded(
+  messages,
+  {
+    model,
+    thresholdTokens = DEFAULT_THRESHOLD_TOKENS,
+    keepMessages = DEFAULT_KEEP_MESSAGES,
+    summarize,
+    signal,
+  } = {}
+) {
+  const list = Array.isArray(messages) ? messages : [];
+  let before = estimateTokens(list);
+
+  // 1) Mensagem unica gigante: podar resolve sem precisar de resumo (e sem
+  //    gastar uma chamada de modelo). Uma saida de comando de 500k chars
+  //    sozinha ja passaria do limiar e nunca dispararia o resumo por haver
+  //    poucas mensagens.
+  const perMessageBudget = Math.max(8_000, Math.floor(thresholdTokens * 0.6) * 4);
+  const trimmed = trimHugeMessages(list, perMessageBudget);
+  // Sem poda, mantem a referencia original: o chamador usa isso para saber
+  // que nada mudou.
+  let working = trimmed.changed ? trimmed.messages : list;
+  const antesPoda = estimateTokens(list);
+  if (trimmed.changed) before = estimateTokens(working);
+
+  const alreadyShrank = trimmed.changed;
+  if (before <= thresholdTokens) {
+    return {
+      messages: working,
+      compacted: alreadyShrank,
+      before: antesPoda,
+      after: before,
+      summary: alreadyShrank ? "(mensagens longas podadas)" : null,
+      error: null,
+    };
+  }
+
+  // 2) Muitas mensagens: troca a parte antiga por resumo.
+  if (working.length <= keepMessages + 1) {
+    return {
+      messages: working,
+      compacted: alreadyShrank,
+      before: antesPoda,
+      after: before,
+      summary: alreadyShrank ? "(mensagens longas podadas)" : null,
+      error: null,
+    };
+  }
+
+  const head = working[0]?.role === "system" ? working[0] : null;
+  const body = head ? working.slice(1) : working;
+  const cut = safeCutIndex(body, body.length - keepMessages);
+  const oldPart = body.slice(0, cut);
+  const recent = body.slice(cut);
+
+  if (!oldPart.length) {
+    return {
+      messages: working,
+      compacted: alreadyShrank,
+      before: estimateTokens(list),
+      after: before,
+      summary: alreadyShrank ? "(mensagens longas podadas)" : null,
+      error: null,
+    };
+  }
+
+  let summaryText = "";
+  try {
+    const runner =
+      summarize ||
+      (async (msgs) => {
+        const result = await chat({ messages: msgs, model, signal });
+        if (!result.ok) throw new Error(result.error || "resumo falhou");
+        return result.text;
+      });
+    summaryText = scrubSecrets(String((await runner(summaryPrompt(oldPart))) || "").trim());
+  } catch (error) {
+    // Sem resumo nao ha compactacao: seguir com o historico inteiro e melhor
+    // do que perder contexto ou quebrar o turno no meio.
+    // Falhou o resumo, mas a poda das mensagens enormes ja vale: nao perde
+    // contexto, so corta o excesso.
+    return {
+      messages: working,
+      compacted: alreadyShrank,
+      before: antesPoda,
+      after: before,
+      summary: alreadyShrank ? "(mensagens longas podadas)" : null,
+      error: error?.message || "resumo falhou",
+    };
+  }
+
+  if (!summaryText) {
+    return {
+      messages: working,
+      compacted: alreadyShrank,
+      before: antesPoda,
+      after: before,
+      summary: alreadyShrank ? "(mensagens longas podadas)" : null,
+      error: "resumo vazio",
+    };
+  }
+  if (summaryText.length > MAX_SUMMARY_CHARS) summaryText = `${summaryText.slice(0, MAX_SUMMARY_CHARS)}…`;
+
+  const note = {
+    role: "system",
+    content: buildCompactionNote(summaryText, oldPart.length),
+  };
+
+  const next = [...(head ? [head] : []), note, ...recent];
+  return {
+    messages: next,
+    compacted: true,
+    before,
+    after: estimateTokens(next),
+    summary: summaryText,
+    error: null,
+  };
+}
+
+module.exports = {
+  compactIfNeeded,
+  estimateTokens,
+  safeCutIndex,
+  summaryPrompt,
+  buildCompactionNote,
+  scrubSecrets,
+  trimHugeMessages,
+  trimHugeMessage,
+  SUMMARY_SECTIONS,
+  DEFAULT_THRESHOLD_TOKENS,
+  DEFAULT_KEEP_MESSAGES,
+  MAX_SUMMARY_CHARS,
+};