kafox-cli 0.10.0 → 0.10.2

package/package.json

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

package/src/auth.js

@@ -14,8 +14,10 @@ async function fetchApi(pathname, options = {}) {
       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,
+        // Timeout por tentativa: nao deixa um host travado segurar o login.
+        // Mas se o caller passou o proprio signal (ex.: o stream do chat, que
+        // pode durar minutos), respeita ele em vez de matar em 12s.
+        signal: options.signal || (AbortSignal.timeout ? AbortSignal.timeout(12000) : undefined),
       });
     } catch (error) {
       lastError = error;

package/src/compact.js

@@ -30,6 +30,10 @@ const { chat } = require("./gateway");
 const DEFAULT_THRESHOLD_TOKENS = 60_000;
 // Quantas mensagens recentes ficam intactas depois do resumo.
 const DEFAULT_KEEP_MESSAGES = 8;
+
+// Quantos turnos de usuario manter no historico enviado ao modelo. Casa com
+// "~20 mensagens" (10 do usuario + 10 da IA). Mantem o chat leve e o custo baixo.
+const DEFAULT_KEEP_TURNS = 10;
 // Teto do resumo: o texto gerado vira contexto permanente, entao nao pode crescer.
 const MAX_SUMMARY_CHARS = 4_000;
 
@@ -73,6 +77,40 @@ function safeCutIndex(messages, wantedIndex) {
   return Math.max(1, index);
 }
 
+/**
+ * Mantem so os ultimos `maxUserTurns` turnos do usuario no historico enviado
+ * ao modelo (mais o system). Cada turno arrasta junto a resposta do assistant
+ * e os pares de tool, entao o resultado gira em torno de `2 * maxUserTurns`
+ * mensagens — ex.: 10 turnos ~ 10 do usuario + 10 da IA.
+ *
+ * O corte e sempre seguro: usa safeCutIndex pra nao deixar tool orfao nem
+ * assistant(tool_calls) sem os resultados. Devolve sempre um array novo.
+ */
+function trimHistory(messages, maxUserTurns = DEFAULT_KEEP_TURNS) {
+  const list = Array.isArray(messages) ? messages : [];
+  if (maxUserTurns <= 0 || list.length === 0) return list;
+  // Quantos turnos de usuario existem e onde comecam os ultimos N.
+  let seen = 0;
+  let wanted = 0;
+  for (let i = list.length - 1; i >= 0; i -= 1) {
+    if (list[i]?.role === "user") {
+      seen += 1;
+      if (seen >= maxUserTurns) {
+        wanted = i;
+        break;
+      }
+    }
+  }
+  if (seen < maxUserTurns) return list.slice(); // cabem todos: nada a cortar
+  const cut = safeCutIndex(list, wanted);
+  const trimmed = list.slice(cut);
+  // Recoloca o system (que vive no indice 0) a frente, se existia.
+  if (list[0]?.role === "system" && trimmed[0]?.role !== "system") {
+    trimmed.unshift(list[0]);
+  }
+  return trimmed;
+}
+
 /** Texto corrido do historico, para alimentar o resumo. */
 function transcript(messages, limitPerMessage = 1_500) {
   return messages
@@ -334,6 +372,7 @@ module.exports = {
   compactIfNeeded,
   estimateTokens,
   safeCutIndex,
+  trimHistory,
   summaryPrompt,
   buildCompactionNote,
   scrubSecrets,
@@ -342,5 +381,6 @@ module.exports = {
   SUMMARY_SECTIONS,
   DEFAULT_THRESHOLD_TOKENS,
   DEFAULT_KEEP_MESSAGES,
+  DEFAULT_KEEP_TURNS,
   MAX_SUMMARY_CHARS,
 };

package/src/gateway.js

@@ -117,7 +117,9 @@ function wait(ms, signal) {
       resolve(value);
     };
     const timer = setTimeout(() => done(true), ms);
-    timer.unref?.();
+    // Sem unref(): o backoff precisa manter o event loop vivo. Se este for o
+    // unico timer pendente e estiver unref'd, o Node dorme e a CLI so acorda
+    // quando o usuario digita algo — o retry ficaria "travado" ate um input.
     function onAbort() {
       done(false);
     }
@@ -139,7 +141,7 @@ function errorFrom(data, status) {
  * Le um stream SSE de chat completions (OpenAI-compatible) e chama os
  * callbacks a cada delta. Devolve o resultado final.
  */
-async function readStream({ response, started, onDelta, onReasoning }) {
+async function readStream({ response, started, onDelta, onReasoning, skipPrefix = "", signal } = {}) {
   const decoder = new TextDecoder();
   let buffer = "";
   let text = "";
@@ -147,6 +149,73 @@ async function readStream({ response, started, onDelta, onReasoning }) {
   let usage = null;
   const toolCalls = [];
 
+  // Watchdog de inatividade: o provedor as vezes morre sem FIN e o `for await`
+  // do body fica pendurado pra sempre (o event loop dorme e a CLI so acorda no
+  // proximo input). Se nenhum byte chega por IDLE_MS, aborta localmente e marca
+  // como retryable — o chat() reconecta por continuacao.
+  const IDLE_MS = Number(process.env.KAFOX_STREAM_IDLE_MS) || 90_000;
+  const idle = new AbortController();
+  let idleTimer = null;
+  let idleFired = false;
+  const clearIdle = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = null;
+  };
+  // Quando o watchdog dispara, cancelamos o reader do body: isso desbloqueia o
+  // `read()` pendurado (o signal do fetch sozinho nao interrompe um body ja
+  // iniciado se a conexao morreu sem FIN).
+  let reader = null;
+  const onIdleAbort = () => {
+    idleFired = true;
+    reader?.cancel?.().catch(() => {});
+  };
+  idle.signal.addEventListener("abort", onIdleAbort, { once: true });
+  const bumpIdle = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => idle.abort(new Error("stream idle timeout")), IDLE_MS);
+  };
+  bumpIdle();
+  // Continuacao: o provedor costuma repetir o inicio ja recebido antes de
+  // seguir. Segura a emissao ate passar do prefixo para nao duplicar na tela.
+  let toSkip = skipPrefix;
+  // Texto efetivamente entregue ao onDelta nesta tentativa (sem o prefixo).
+  let emitted = "";
+
+  const emitContent = (chunk) => {
+    if (toSkip) {
+      if (chunk.length <= toSkip.length) {
+        // O trecho novo ainda esta dentro do prefixo repetido: confere se bate.
+        if (toSkip.startsWith(chunk)) {
+          toSkip = toSkip.slice(chunk.length);
+          return;
+        }
+        // Divergiu do prefixo: o modelo recomecou; emite tudo o que veio.
+        toSkip = "";
+        emitted += chunk;
+        onDelta?.(chunk);
+        return;
+      }
+      // Passou do prefixo: descarta a parte repetida e emite o resto.
+      const overlap = chunk.slice(0, toSkip.length);
+      if (overlap === toSkip || chunk.startsWith(toSkip)) {
+        const rest = chunk.slice(toSkip.length);
+        toSkip = "";
+        if (rest) {
+          emitted += rest;
+          onDelta?.(rest);
+        }
+        return;
+      }
+      // Nao bateu: recomecou, emite tudo.
+      toSkip = "";
+      emitted += chunk;
+      onDelta?.(chunk);
+      return;
+    }
+    emitted += chunk;
+    onDelta?.(chunk);
+  };
+
   const handleLine = (line) => {
     if (!line.startsWith("data:")) return null;
     const data = line.slice(5).trim();
@@ -172,48 +241,81 @@ async function readStream({ response, started, onDelta, onReasoning }) {
     }
     if (delta.content) {
       text += delta.content;
-      onDelta?.(delta.content);
+      emitContent(delta.content);
     }
     if (Array.isArray(delta.tool_calls)) mergeToolCalls(toolCalls, delta.tool_calls);
     return null;
   };
 
   try {
-    for await (const chunk of response.body) {
-      buffer += decoder.decode(chunk, { stream: true });
+    reader = response.body.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bumpIdle();
+      buffer += decoder.decode(value, { stream: true });
       let index = buffer.indexOf("\n");
       while (index >= 0) {
         const line = buffer.slice(0, index).replace(/\r$/, "");
         buffer = buffer.slice(index + 1);
         const failure = handleLine(line);
-        if (failure) return { ok: false, error: failure.error, retryable: failure.retryable };
+        if (failure) { clearIdle(); return { ok: false, error: failure.error, retryable: failure.retryable }; }
         index = buffer.indexOf("\n");
       }
     }
     if (buffer.trim()) handleLine(buffer.trim());
+    // O cancel() do watchdog pode encerrar o reader como "done": se foi o
+    // watchdog que disparou, isso e falha e deve reconectar.
+    if (idleFired) {
+      clearIdle();
+      return {
+        ok: false,
+        error: `Stream interrompido: sem resposta do provedor por ${Math.round(IDLE_MS / 1000)}s`,
+        text,
+        emitted,
+        retryable: true,
+      };
+    }
   } catch (error) {
-    if (error?.name === "AbortError") {
-      return { ok: true, text, reasoning, toolCalls, ms: Date.now() - started, aborted: true };
+    clearIdle();
+    if (error?.name === "AbortError" || idleFired) {
+      // Abort com o signal do usuario ativo = ele apertou Esc: encerra.
+      if (signal?.aborted && !idleFired) {
+        return { ok: true, text, emitted, reasoning, toolCalls, ms: Date.now() - started, aborted: true };
+      }
+      // Sem abort do usuario, falha de conexao ou watchdog de inatividade:
+      // marca como retryable para o chat() reconectar de onde parou.
+      return {
+        ok: false,
+        error: idleFired
+          ? `Stream interrompido: sem resposta do provedor por ${Math.round(IDLE_MS / 1000)}s`
+          : `Stream interrompido: ${error.message || "conexao caiu"}`,
+        text,
+        emitted,
+        retryable: true,
+      };
     }
     return {
       ok: false,
       error: `Stream interrompido: ${error.message}`,
       text,
+      emitted,
       retryable: retryableMessage(error.message),
     };
   }
+  clearIdle();
 
-  return { ok: true, text, reasoning, toolCalls: toolCalls.filter(Boolean), usage, ms: Date.now() - started };
+  return { ok: true, text, emitted, reasoning, toolCalls: toolCalls.filter(Boolean), usage, ms: Date.now() - started };
 }
 
 /**
  * Uma tentativa no provedor kafox (gateway proprio): login/saldo/chave da conta
  * e POST em `/api/chat`.
  */
-async function attemptChat({ messages, model, tools, onDelta, onReasoning, signal } = {}) {
+async function attemptChat({ messages, model, tools, onDelta, onReasoning, signal, skipPrefix } = {}) {
   const socket = providerForModel(model);
   if (socket.provider.kind === "openai") {
-    return attemptOpenAI({ messages, model: socket.model, provider: socket.provider, tools, onDelta, onReasoning, signal });
+    return attemptOpenAI({ messages, model: socket.model, provider: socket.provider, tools, onDelta, onReasoning, signal, skipPrefix });
   }
 
   const ready = await ensureReady({ model });
@@ -235,11 +337,11 @@ async function attemptChat({ messages, model, tools, onDelta, onReasoning, signa
       signal,
     });
   } catch (error) {
-    if (error?.name === "AbortError") return { ok: false, code: "aborted", error: "Cancelado." };
+    if (error?.name === "AbortError" && signal?.aborted) return { ok: false, code: "aborted", error: "Cancelado." };
     return {
       ok: false,
-      error: `Falha de rede: ${error.message}`,
-      retryable: retryableMessage(error.message),
+      error: error?.name === "AbortError" ? `Falha de rede: ${error.message || "conexao caiu"}` : `Falha de rede: ${error.message}`,
+      retryable: error?.name === "AbortError" ? true : retryableMessage(error.message),
       keyCreated: ready.keyCreated,
     };
   }
@@ -254,7 +356,7 @@ async function attemptChat({ messages, model, tools, onDelta, onReasoning, signa
     };
   }
 
-  const result = await readStream({ response, started, onDelta, onReasoning });
+  const result = await readStream({ response, started, onDelta, onReasoning, skipPrefix, signal });
   return { ...result, model: ready.model, keyCreated: ready.keyCreated };
 }
 
@@ -263,7 +365,7 @@ async function attemptChat({ messages, model, tools, onDelta, onReasoning, signa
  * `{baseUrl}/chat/completions` com a chave do usuario. Sem login/saldo da conta
  * kafox; o custo e cobrado pelo proprio provedor.
  */
-async function attemptOpenAI({ messages, model, provider, tools, onDelta, onReasoning, signal } = {}) {
+async function attemptOpenAI({ messages, model, provider, tools, onDelta, onReasoning, signal, skipPrefix } = {}) {
   const apiKey = storage.getProviderKey(provider.id);
   if (!apiKey) {
     return {
@@ -292,11 +394,11 @@ async function attemptOpenAI({ messages, model, provider, tools, onDelta, onReas
       signal,
     });
   } catch (error) {
-    if (error?.name === "AbortError") return { ok: false, code: "aborted", error: "Cancelado." };
+    if (error?.name === "AbortError" && signal?.aborted) return { ok: false, code: "aborted", error: "Cancelado." };
     return {
       ok: false,
-      error: `Falha de rede: ${error.message}`,
-      retryable: retryableMessage(error.message),
+      error: error?.name === "AbortError" ? `Falha de rede: ${error.message || "conexao caiu"}` : `Falha de rede: ${error.message}`,
+      retryable: error?.name === "AbortError" ? true : retryableMessage(error.message),
     };
   }
 
@@ -309,42 +411,93 @@ async function attemptOpenAI({ messages, model, provider, tools, onDelta, onReas
     };
   }
 
-  const result = await readStream({ response, started, onDelta, onReasoning });
+  const result = await readStream({ response, started, onDelta, onReasoning, skipPrefix, signal });
   return { ...result, model, provider: provider.id };
 }
 
 /**
  * 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.
+ *
+ * Queda no meio da resposta (o pior caso: ja saiu texto e o stream morre) e
+ * reconectada por continuacao: reenvia a conversa com o trecho parcial como
+ * assistant e pede para seguir de onde parou. O `skipPrefix` faz o provedor
+ * repetir o inicio; o gateway descarta a repeticao, entao a TUI so ve o que
+ * e novo. Se a continuacao falhar, devolve o parcial para nao perder nada.
  */
 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;
   let clearedKey = false;
+  // Acumulado entre tentativas (modo continuacao).
+  let carried = "";
+  let working = messages;
+  let skipPrefix = "";
 
   while (attempt < maxAttempts) {
     attempt += 1;
-    const result = await attemptChat({ messages, model, tools, onDelta, onReasoning, signal });
+    const result = await attemptChat({
+      messages: working,
+      model,
+      tools,
+      onDelta,
+      onReasoning,
+      signal,
+      skipPrefix,
+    });
 
-    if (result.ok || result.code === "aborted") return result;
+    if (result.ok || result.code === "aborted") {
+      if (carried && result.ok) {
+        // Junta o trecho das tentativas anteriores ao texto final.
+        const emitted = result.emitted ?? "";
+        const fullText = carried + emitted;
+        // Se o provedor mandou texto novo menor que o esperado, ainda vale o
+        // que ja foi mostrado; devolve o maior dos dois para o consumidor.
+        return { ...result, text: fullText.length >= (result.text || "").length ? fullText : result.text };
+      }
+      return result;
+    }
     if (result.code === "invalid_api_key" && !clearedKey) {
       clearedKey = true;
       storage.clearApiKey();
       continue;
     }
-    // Ja saiu texto: repetir duplicaria a resposta na tela.
-    if (!result.retryable || result.text) return result;
+    // Erro nao recuperavel (saldo, chave, modelo): devolve como veio.
+    if (!result.retryable) return carried ? { ...result, text: result.text || carried } : result;
     last = result;
 
+    // Caiu ja com texto na tela: reconecta continuando de onde parou.
+    const partial = String(result.text || "");
+    if (partial.trim()) {
+      carried += partial;
+      skipPrefix = carried;
+      working = [
+        ...messages,
+        { role: "assistant", content: carried },
+        {
+          role: "user",
+          content:
+            "Sua resposta anterior foi interrompida por uma falha de conexao. " +
+            "Continue exatamente de onde parou, sem repetir nada do que ja foi escrito.",
+        },
+      ];
+    }
+
     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 };
+    if (!slept) {
+      return { ok: false, code: "aborted", error: "Cancelado.", text: carried, keyCreated: result.keyCreated };
+    }
   }
 
+  // Esgotou as tentativas: se ja tinha texto, entrega o parcial (melhor que erro).
+  if (carried.trim()) {
+    return { ...last, ok: true, text: carried, attempts: attempt, partial: true };
+  }
   return { ...last, attempts: attempt };
 }
 

package/src/mobile/auth.js

@@ -115,6 +115,128 @@ class PairingManager {
     }
     this.currentCode = null;
     this.currentCodeHash = null;
+    // Pedidos de pareamento aguardando aprovacao do dono do terminal.
+    // requestId -> { createdAt, expiresAt, code, device, sessionTitle, status,
+    //                token?, tokenExpiresAt? }
+    this.requests = new Map();
+    // Listener chamado quando chega um pedido novo (a TUI usa pra abrir modal).
+    this.onRequest = null;
+  }
+
+  /**
+   * PASSO 1 do novo fluxo: o celular pede entrada. NAO devolve token ainda —
+   * cria um pedido pendente e avisa o terminal (this.onRequest). O dono
+   * aprova/nega; so entao o token e emitido (ver resolveRequest/claim).
+   * @returns {{requestId:string, expiresAt:number}|null}
+   */
+  requestPair(code, device = {}, meta = {}) {
+    if (!this.validateCode(code)) return null;
+    // Consome o codigo JA na criacao do pedido: garante uso unico (dois
+    // celulares nao podem abrir pedidos concorrentes com o mesmo codigo).
+    const codeHash = sha256(code);
+    this.pending.delete(codeHash);
+    if (this.currentCodeHash === codeHash) {
+      this.currentCode = null;
+      this.currentCodeHash = null;
+    }
+    const requestId = crypto.randomBytes(16).toString("hex");
+    const expiresAt = Date.now() + PAIR_TTL_MS;
+    const req = {
+      createdAt: Date.now(),
+      expiresAt,
+      code,
+      device,
+      sessionTitle: String(meta.sessionTitle || "").slice(0, 120),
+      sessionId: String(meta.sessionId || "").slice(0, 40),
+      status: "pending", // pending | approved | denied
+      token: null,
+      tokenExpiresAt: 0,
+    };
+    this.requests.set(requestId, req);
+    // Avisa o terminal (best-effort: se nao houver listener, so fica pendente).
+    try {
+      this.onRequest?.({ requestId, device, sessionTitle: req.sessionTitle, expiresAt });
+    } catch {
+      /* nao deixa o pedido quebrar por erro do listener */
+    }
+    this.audit("pair-request", { requestId: requestId.slice(0, 12), device });
+    return { requestId, expiresAt };
+  }
+
+  /** PASSO 2 (terminal): aprova ou nega um pedido. Ao aprovar, emite o token. */
+  resolveRequest(requestId, approved, device = null) {
+    const req = this.requests.get(requestId);
+    if (!req) return false;
+    if (Date.now() > req.expiresAt) {
+      this.requests.delete(requestId);
+      return false;
+    }
+    if (req.status !== "pending") return false;
+    if (!approved) {
+      req.status = "denied";
+      this.audit("pair-denied", { requestId: requestId.slice(0, 12) });
+      return true;
+    }
+    // Aprovado: consome o codigo (single-use) e emite o token de sessao.
+    const codeHash = sha256(req.code);
+    this.pending.delete(codeHash);
+    if (this.currentCodeHash === codeHash) {
+      this.currentCode = null;
+      this.currentCodeHash = null;
+    }
+    const token = crypto.randomBytes(32).toString("hex");
+    const tokenExpiresAt = Date.now() + TOKEN_TTL_MS;
+    this.tokens.set(sha256(token), {
+      createdAt: Date.now(),
+      expiresAt: tokenExpiresAt,
+      code: req.code,
+      device: device || req.device,
+    });
+    this.persistTokens();
+    req.status = "approved";
+    req.token = token;
+    req.tokenExpiresAt = tokenExpiresAt;
+    this.audit("pair-approved", { requestId: requestId.slice(0, 12), device: req.device });
+    // Notifica o terminal: um pareamento CONCLUIU agora (some com o QR).
+    try {
+      this.onPaired?.({ requestId, device: device || req.device, sessionTitle: req.sessionTitle });
+    } catch {
+      /* listener do terminal nunca derruba o pareamento */
+    }
+    return true;
+  }
+
+  /**
+   * PASSO 3 (celular): consulta o status do pedido. Quando aprovado, devolve o
+   * token UMA vez e marca o pedido como consumido (nao vaza token em retries).
+   * @returns {{status:string, token?:string, expiresAt?:number}}
+   */
+  pollRequest(requestId) {
+    const req = this.requests.get(requestId);
+    if (!req) return { status: "unknown" };
+    if (req.status === "pending" && Date.now() > req.expiresAt) {
+      this.requests.delete(requestId);
+      return { status: "expired" };
+    }
+    if (req.status === "approved") {
+      const token = req.token;
+      const expiresAt = req.tokenExpiresAt;
+      // single-shot: o token so sai do servidor uma vez.
+      this.requests.delete(requestId);
+      return { status: "approved", token, expiresAt };
+    }
+    return { status: req.status };
+  }
+
+  /** Pedidos pendentes (para reabrir o modal se a TUI renderizar de novo). */
+  pendingRequests() {
+    const out = [];
+    const now = Date.now();
+    for (const [id, req] of [...this.requests]) {
+      if (req.status === "pending" && now <= req.expiresAt) out.push({ requestId: id, ...req });
+      else if (now > req.expiresAt) this.requests.delete(id);
+    }
+    return out;
   }
 
   /**

package/src/mobile/bridge.js

@@ -20,6 +20,7 @@ const { EventEmitter } = require("events");
 const { runAgent } = require("../agent");
 const { estimateTokens } = require("../compact");
 const sessions = require("../sessions");
+const { trimHistory } = require("./history");
 const { EventLog } = require("./protocol");
 
 const SAVE_DEBOUNCE_MS = 400;
@@ -39,6 +40,7 @@ class SessionBridge extends EventEmitter {
     super();
     this.cwd = cwd;
     this.sessionId = sessionId || sessions.newId();
+    this.title = null; // preenchido no snapshot a partir da 1a mensagem do usuario
     this.sessionStartedAt = sessionStartedAt || new Date().toISOString();
     this.messages = Array.isArray(messages) ? messages : [];
     this.context = Array.isArray(context) ? context : [];
@@ -58,14 +60,23 @@ class SessionBridge extends EventEmitter {
 
   /** Snapshot inicial para quem acabou de conectar (historico + estado). */
   snapshot() {
+    // O celular nao sobe o chat inteiro: manda so as ultimas ~20 mensagens
+    // (10 do usuario + 10 da IA). O resto fica no PC.
+    const trimmed = trimHistory(this.messages);
     return {
       sessionId: this.sessionId,
+      title:
+        this.title ||
+        (this.messages.find((m) => m.role === "user")?.text || "").slice(0, 120) ||
+        null,
       model: this.model,
       cwd: this.cwd,
       allowAll: this.allowAll,
       busy: this.busy,
       streaming: this.streaming,
-      messages: this.messages,
+      messages: trimmed.messages,
+      historyTruncated: trimmed.truncated,
+      historyTotal: trimmed.total,
       context: this.context,
       pendingApproval: this.pendingApproval
         ? {

package/src/mobile/captcha.js

@@ -0,0 +1,96 @@
+/**
+ * Captcha proprio do kafox mobile — sem dependencia externa (sem node:crypto
+ * extra, sem servico de terceiros). Desafio aritmetico simples, renderizado
+ * como SVG inline no cliente, resolvido no servidor.
+ *
+ * Modelo de seguranca:
+ *  - cada desafio e de USO UNICO e expira em CAPTCHA_TTL_MS;
+ *  - a resposta fica guardada como hash (sha256), nunca em texto;
+ *  - apos K tentativas o desafio morre (evita forca bruta);
+ *  - limpeza oportunista dos expirados a cada emissao.
+ *
+ * Nao substitui Cloudflare Turnstile/hCaptcha, mas corta bots ingenuos e
+ * scripts que so reenviam o codigo do QR, que e o suficiente aqui.
+ */
+
+const crypto = require("crypto");
+
+const CAPTCHA_TTL_MS = 3 * 60 * 1000; // 3 minutos
+const MAX_ATTEMPTS = 5;
+
+/** @type {Map<string, {hash:string, expires:number, tries:number}>} */
+const store = new Map();
+
+function hash(text) {
+  return crypto.createHash("sha256").update(String(text).trim().toLowerCase()).digest("hex");
+}
+
+function sweep() {
+  const now = Date.now();
+  for (const [id, entry] of store) {
+    if (entry.expires <= now) store.delete(id);
+  }
+}
+
+function randomInt(min, max) {
+  // inteiro uniforme em [min, max] usando bytes aleatorios
+  const span = max - min + 1;
+  const buf = crypto.randomBytes(4);
+  const n = buf.readUInt32BE(0);
+  return min + (n % span);
+}
+
+/**
+ * Emite um novo desafio.
+ * @returns {{ id:string, question:string, expiresAt:number }}
+ */
+function issue() {
+  sweep();
+  const a = randomInt(2, 9);
+  const b = randomInt(2, 9);
+  const usePlus = randomInt(0, 1) === 0;
+  let answer;
+  let question;
+  if (usePlus) {
+    answer = a + b;
+    question = `${a} + ${b} = ?`;
+  } else {
+    // subtracao sempre positiva
+    const hi = Math.max(a, b);
+    const lo = Math.min(a, b);
+    answer = hi - lo;
+    question = `${hi} - ${lo} = ?`;
+  }
+  const id = crypto.randomBytes(16).toString("hex");
+  store.set(id, { hash: hash(answer), expires: Date.now() + CAPTCHA_TTL_MS, tries: 0 });
+  return { id, question, expiresAt: Date.now() + CAPTCHA_TTL_MS };
+}
+
+/**
+ * Verifica e CONSOME o desafio (uso unico).
+ * @returns {{ ok:boolean, reason?:string }}
+ */
+function verify(id, answer) {
+  const entry = store.get(String(id || ""));
+  if (!entry) return { ok: false, reason: "captcha expirado ou invalido" };
+  if (entry.expires <= Date.now()) {
+    store.delete(id);
+    return { ok: false, reason: "captcha expirado" };
+  }
+  entry.tries += 1;
+  if (entry.tries > MAX_ATTEMPTS) {
+    store.delete(id);
+    return { ok: false, reason: "tentativas demais — recarregue o captcha" };
+  }
+  if (entry.hash !== hash(answer)) {
+    return { ok: false, reason: "captcha incorreto" };
+  }
+  store.delete(id); // uso unico
+  return { ok: true };
+}
+
+function size() {
+  return store.size;
+}
+
+module.exports = { issue, verify, size, CAPTCHA_TTL_MS };