kafox-cli 0.10.0 → 0.10.1

package/package.json

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

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

package/src/mobile/history.js

@@ -0,0 +1,71 @@
+/**
+ * Recorte de historico para o celular.
+ *
+ * Regra do produto: o celular NUNCA sobe o chat inteiro. Sobe no maximo
+ * MAX_USER mensagens do usuario + MAX_ASSISTANT respostas da IA (as mais
+ * recentes), deixando a conversa leve no primeiro carregamento.
+ *
+ * O recorte preserva a ordem cronologica e, quando ha varias, prioriza as
+ * mensagens recentes de cada papel. Turnos auxiliares (system/erro/compaction)
+ * que caiam entre as selecionadas sao mantidos para o contexto fazer sentido.
+ */
+
+const MAX_USER = 10;
+const MAX_ASSISTANT = 10;
+
+/**
+ * @param {Array<{role:string}>} messages
+ * @param {{ maxUser?:number, maxAssistant?:number }} [opts]
+ * @returns {{ messages:Array, truncated:boolean, total:number, shown:number }}
+ */
+function trimHistory(messages, opts = {}) {
+  const list = Array.isArray(messages) ? messages : [];
+  const maxUser = Number.isInteger(opts.maxUser) ? opts.maxUser : MAX_USER;
+  const maxAssistant = Number.isInteger(opts.maxAssistant) ? opts.maxAssistant : MAX_ASSISTANT;
+
+  // Conta quantas ainda devemos MANTER, varrendo do fim pro inicio.
+  let userLeft = maxUser;
+  let assistantLeft = maxAssistant;
+  const keep = new Array(list.length).fill(false);
+
+  for (let i = list.length - 1; i >= 0; i--) {
+    const role = list[i] && list[i].role;
+    if (role === "user") {
+      if (userLeft > 0) {
+        keep[i] = true;
+        userLeft -= 1;
+      }
+    } else if (role === "assistant") {
+      if (assistantLeft > 0) {
+        keep[i] = true;
+        assistantLeft -= 1;
+      }
+    } else {
+      // system / error / compaction: acompanha o vizinho mais proximo que ficou.
+      // Mantem provisoriamente; a segunda passada remove orfaos das bordas.
+      keep[i] = true;
+    }
+  }
+
+  // Remove auxiliares nas bordas que nao tem nenhum user/assistant mantido
+  // depois (ou antes) deles — evita abrir o chat com uma linha solta.
+  let first = keep.indexOf(true);
+  let last = keep.lastIndexOf(true);
+  if (first === -1) return { messages: [], truncated: list.length > 0, total: list.length, shown: 0 };
+  while (first <= last && !isKeptTurn(list[first])) first++;
+  while (last >= first && !isKeptTurn(list[last])) last--;
+
+  const out = [];
+  for (let i = first; i <= last; i++) {
+    if (keep[i]) out.push(list[i]);
+  }
+  const truncated = out.length < list.length;
+  return { messages: out, truncated, total: list.length, shown: out.length };
+}
+
+function isKeptTurn(m) {
+  const role = m && m.role;
+  return role === "user" || role === "assistant";
+}
+
+module.exports = { trimHistory, MAX_USER, MAX_ASSISTANT };

package/src/mobile/index.js

@@ -309,6 +309,24 @@ async function runMobile({
   console.log(chalk.dim(`\n${tail}\n`));
   note(tail);
 
+  // O celular confirmou o modal e se pareou: some com o QR. Em terminal
+  // interativo limpamos a tela e redesenhamos sem o QR; no daemon (log em
+  // arquivo) so registramos a linha de sucesso. Usa onPaired (evento real),
+  // nao polling de activeTokens(), pra nao confundir token antigo do disco
+  // com um pareamento novo.
+  function onPaired(ev) {
+    const who = ev?.device?.name || "celular";
+    const ok = `✓ celular pareado (${who})  ·  abra ${base}`;
+    if (process.stdout.isTTY) {
+      process.stdout.write("\x1b[2J\x1b[H"); // limpa e volta ao topo
+      console.log(chalk.green(`\n${ok}\n`));
+    } else {
+      console.log(chalk.green(`\n${ok}\n`));
+    }
+    note(ok);
+  }
+  pairing.onPaired = onPaired;
+
   await new Promise((resolve) => {
     const shutdown = () => {
       pairing.audit("shutdown", {});

package/src/mobile/ratelimit.js

@@ -0,0 +1,79 @@
+/**
+ * Rate limit do kafox mobile — janela deslizante por chave (IP + rota).
+ * Sem dependencia: mapa em memoria, poda periodica, sem timer pendurado.
+ *
+ * Objetivo: frear brute-force nas rotas publicas (adivinhar pair_code/sessao
+ * pela URL). Conta por IP com janela curta e teto generoso o bastante pra um
+ * usuario de verdade nem perceber, mas curto o bastante pra inviabilizar
+ * varredura de codigos.
+ */
+
+const DEFAULTS = {
+  // POST /pair: tentativas de pareamento por IP.
+  pair: { max: 10, windowMs: 60_000 },
+  // GET /pair (poll): consulta de status do pedido. Por IP.
+  poll: { max: 120, windowMs: 60_000 },
+  // GET /captcha: emitir desafios (evita farmar captcha).
+  captcha: { max: 30, windowMs: 60_000 },
+  // Rotas autenticadas por token: teto por TOKEN (nao so por IP), pra frear
+  // quem varre a URL adivinhando sessao mesmo atras de um unico IP.
+  auth: { max: 150, windowMs: 60_000 },
+  // Tentativas de token INVALIDO por IP: piso curto. Bater aqui = varredura.
+  authFail: { max: 20, windowMs: 60_000 },
+  // POST /prompt e /approve: acoes que mexem no agente. Por token.
+  action: { max: 40, windowMs: 60_000 },
+  // GET / (a propria pagina) + qualquer rota nao classificada.
+  global: { max: 240, windowMs: 60_000 },
+};
+
+class SlideLimiter {
+  constructor(now = () => Date.now()) {
+    this.buckets = new Map();
+    this.now = now;
+    this.lastPrune = 0;
+  }
+
+  /**
+   * Registra um hit. Devolve { ok, retryAfter } — ok=false quando estourou.
+   * @param {string} key  ex: "pair:1.2.3.4"
+   * @param {{max:number, windowMs:number}} rule
+   */
+  hit(key, rule) {
+    const now = this.now();
+    this.maybePrune(now);
+    const hits = this.buckets.get(key) || [];
+    // descarta timestamps fora da janela (sliding window)
+    const cutoff = now - rule.windowMs;
+    let i = 0;
+    while (i < hits.length && hits[i] <= cutoff) i += 1;
+    if (i > 0) hits.splice(0, i);
+
+    if (hits.length >= rule.max) {
+      const retryAfter = Math.max(1, Math.ceil((hits[0] + rule.windowMs - now) / 1000));
+      this.buckets.set(key, hits);
+      return { ok: false, retryAfter };
+    }
+    hits.push(now);
+    this.buckets.set(key, hits);
+    return { ok: true, remaining: rule.max - hits.length };
+  }
+
+  maybePrune(now) {
+    if (now - this.lastPrune < 60_000) return;
+    this.lastPrune = now;
+    const longest = 5 * 60_000;
+    for (const [key, hits] of this.buckets) {
+      if (!hits.length || hits[hits.length - 1] < now - longest) this.buckets.delete(key);
+    }
+  }
+
+  size() {
+    return this.buckets.size;
+  }
+
+  reset() {
+    this.buckets.clear();
+  }
+}
+
+module.exports = { SlideLimiter, DEFAULTS };

package/src/mobile/server.js

@@ -17,6 +17,8 @@
 const http = require("http");
 const { PairingManager } = require("./auth");
 const { renderPage } = require("./view");
+const captcha = require("./captcha");
+const { SlideLimiter, DEFAULTS } = require("./ratelimit");
 
 const HEARTBEAT_MS = 5_000;
 
@@ -48,8 +50,38 @@ function json(res, status, body) {
 function createMobileServer({ bridge, pairing = new PairingManager(), pageHtml = renderPage() } = {}) {
   if (!bridge) throw new Error("createMobileServer precisa de um SessionBridge");
 
+  const limiter = new SlideLimiter();
   const sseClients = new Set();
 
+  // IP do cliente. Atras do Caddy (reverse_proxy) vem em x-forwarded-for; em
+  // acesso direto, o socket. Normaliza pro primeiro IP da cadeia.
+  function clientIp(req) {
+    const fwd = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim();
+    return fwd || req.socket.remoteAddress || "desconhecido";
+  }
+
+  // Aplica o rate limit da rota. Devolve true se JA respondeu (bloqueado).
+  function blocked(req, res, ruleName, overrideKey) {
+    const rule = DEFAULTS[ruleName];
+    if (!rule) return false;
+    const key = `${ruleName}:${overrideKey || clientIp(req)}`;
+    const verdict = limiter.hit(key, rule);
+    if (verdict.ok) return false;
+    res.writeHead(429, {
+      "content-type": "application/json; charset=utf-8",
+      "retry-after": String(verdict.retryAfter),
+      "cache-control": "no-store",
+    });
+    res.end(
+      JSON.stringify({
+        error: "muitas requisições — aguarde alguns instantes",
+        code: "rate_limited",
+        retryAfter: verdict.retryAfter,
+      })
+    );
+    return true;
+  }
+
   function broadcast(event) {
     const frame = `data: ${JSON.stringify(event)}\n\n`;
     for (const client of sseClients) {
@@ -67,6 +99,10 @@ function createMobileServer({ bridge, pairing = new PairingManager(), pageHtml =
     const url = new URL(req.url, "http://localhost");
     const pathname = url.pathname;
 
+    // Teto global por IP: nenhuma rota escapa de um piso minimo de protecao
+    // contra varredura de URLs.
+    if (blocked(req, res, "global")) return;
+
     // A pagina e o proprio endpoint de pareamento nao exigem token.
     if (req.method === "GET" && (pathname === "/" || pathname === "/index.html")) {
       res.writeHead(200, {
@@ -94,30 +130,94 @@ function createMobileServer({ bridge, pairing = new PairingManager(), pageHtml =
       return;
     }
 
+    // CAPTCHA: emite um desafio novo (publico, de uso unico). O celular pede
+    // isso antes de tentar parear. Sem ele, o POST /pair e rejeitado.
+    if (req.method === "GET" && pathname === "/captcha") {
+      if (blocked(req, res, "captcha")) return;
+      return json(res, 200, captcha.issue());
+    }
+
+    // PASSO 1: o celular pede entrada (com o codigo do QR). Nao recebe token
+    // ainda — cria um pedido pendente e o dono do terminal aprova/nega.
     if (req.method === "POST" && pathname === "/pair") {
+      if (blocked(req, res, "pair")) return;
       let body;
       try {
         body = JSON.parse((await readBody(req)) || "{}");
       } catch {
         return json(res, 400, { error: "json invalido" });
       }
+      // Portao anti-bot: valida e consome o captcha ANTES de olhar o codigo.
+      const captchaCheck = captcha.verify(body.captchaId, body.captchaAnswer);
+      if (!captchaCheck.ok) {
+        return json(res, 400, { error: captchaCheck.reason || "captcha invalido", captcha: true });
+      }
       const code = String(body.code || "").trim().toUpperCase();
       const device = {
         ua: String(req.headers["user-agent"] || "").slice(0, 160),
         ip: String(req.headers["x-forwarded-for"] || req.socket.remoteAddress || "").slice(0, 80),
         name: String(body.device || "celular").slice(0, 60),
       };
-      const claim = pairing.claim(code, device);
-      if (!claim) return json(res, 401, { error: "codigo invalido ou expirado" });
-      return json(res, 200, { token: claim.token, expiresAt: claim.expiresAt, session: bridge.snapshot() });
+      const snap = bridge.snapshot();
+      const request = pairing.requestPair(code, device, {
+        sessionTitle: snap.title || snap.name || "",
+        sessionId: snap.sessionId || "",
+      });
+      if (!request) return json(res, 401, { error: "codigo invalido ou expirado" });
+      return json(res, 200, {
+        requestId: request.requestId,
+        expiresAt: request.expiresAt,
+        status: "pending",
+        session: { sessionId: snap.sessionId, title: snap.title || snap.name || "" },
+      });
+    }
+
+    // PASSO 3: o celular consulta o status do pedido. Quando aprovado, recebe o
+    // token UMA vez. Rota publica (autenticada pelo requestId aleatorio).
+    if (req.method === "GET" && pathname === "/pair") {
+      if (blocked(req, res, "poll")) return;
+      const requestId = String(url.searchParams.get("id") || "");
+      if (!requestId) return json(res, 400, { error: "id obrigatorio" });
+      const status = pairing.pollRequest(requestId);
+      if (status.status === "unknown") return json(res, 404, { error: "pedido nao encontrado" });
+      if (status.status === "approved") {
+        return json(res, 200, { status: "approved", token: status.token, expiresAt: status.expiresAt, session: bridge.snapshot() });
+      }
+      return json(res, 200, { status: status.status });
+    }
+
+    // PASSO 2: o terminal aprova/nega um pedido pendente. Exige token de um
+    // pareamento JA existente OU vem do proprio dono (rota local). Aqui so
+    // aceitamos quando ha um pedido valido — a rota e usada pela TUI no PC.
+    if (req.method === "POST" && pathname === "/pair/decide") {
+      let body;
+      try {
+        body = JSON.parse((await readBody(req)) || "{}");
+      } catch {
+        return json(res, 400, { error: "json invalido" });
+      }
+      const requestId = String(body.id || "");
+      const approved = Boolean(body.approved);
+      if (!requestId) return json(res, 400, { error: "id obrigatorio" });
+      const ok = pairing.resolveRequest(requestId, approved);
+      if (!ok) return json(res, 404, { error: "pedido nao encontrado ou ja resolvido" });
+      return json(res, 200, { ok: true, status: approved ? "approved" : "denied" });
     }
 
     // A partir daqui, exige token de sessao.
     const token = req.headers["x-kafox-token"] || url.searchParams.get("t");
     if (!pairing.validateToken(token)) {
+      // Teto curto por IP para TOKEN INVALIDO: bater aqui e sinal de varredura
+      // de sessao pela URL. Vale mesmo antes de responder o 401.
+      if (blocked(req, res, "authFail")) return;
       return json(res, 401, { error: "sem token valido" });
     }
 
+    // Token valido: conta por TOKEN (nao so por IP), pra um IP sozinho nao
+    // conseguir varrer sessoes sem estourar o bucket da propria sessao.
+    const tokenKey = String(token).slice(0, 16);
+    if (blocked(req, res, "auth", tokenKey)) return;
+
     if (req.method === "GET" && pathname === "/state") {
       return json(res, 200, bridge.snapshot());
     }
@@ -195,6 +295,7 @@ function createMobileServer({ bridge, pairing = new PairingManager(), pageHtml =
     }
 
     if (req.method === "POST" && pathname === "/prompt") {
+      if (blocked(req, res, "action", tokenKey)) return;
       let body;
       try {
         body = JSON.parse((await readBody(req)) || "{}");
@@ -211,6 +312,7 @@ function createMobileServer({ bridge, pairing = new PairingManager(), pageHtml =
     }
 
     if (req.method === "POST" && pathname === "/approve") {
+      if (blocked(req, res, "action", tokenKey)) return;
       let body;
       try {
         body = JSON.parse((await readBody(req)) || "{}");

package/src/mobile/tui-bridge.js

@@ -71,6 +71,7 @@ class TuiBridge extends EventEmitter {
   snapshot() {
     return {
       sessionId: this.sessionId,
+      title: this.state.title || (this.state.messages || []).find((m) => m.role === "user")?.text || null,
       model: this.state.model || null,
       cwd: this.cwd || process.cwd(),
       allowAll: Boolean(this.state.autoApprove),

package/src/mobile/view.js

@@ -167,6 +167,36 @@ function renderPage() {
   #pairing .code:focus { outline:none; box-shadow:4px 4px 0 0 var(--neon); }
   #pairing .err { color:var(--err); min-height:1.2em; font-size:12px; }
   #pairing button { width:min(92vw,420px); }
+  /* captcha: desafio em SVG + campo curto, lado a lado */
+  #pairing .captcha { display:flex; align-items:center; gap:10px; width:min(92vw,420px); }
+  #pairing .captcha .q { flex:1; height:56px; border:2px solid var(--neon); background:#000;
+    display:flex; align-items:center; justify-content:center; }
+  #pairing .captcha .q svg { display:block; }
+  #pairing .captcha .reload { width:44px; height:56px; flex:0 0 auto; border:2px solid var(--neon);
+    background:#000; color:var(--neon); font-size:18px; line-height:1; cursor:pointer; padding:0; }
+  #pairing .captcha .reload:active { background:var(--neon); color:#000; }
+  #pairing input.small { font-size:22px; font-weight:800; letter-spacing:0.2em; text-align:center;
+    border:2px solid var(--neon); background:#000; color:var(--neon); padding:12px;
+    width:min(92vw,420px); }
+  #pairing input.small:focus { outline:none; box-shadow:4px 4px 0 0 var(--neon); }
+  #pairing .hint { color:var(--dim); font-size:11px; letter-spacing:0.06em; max-width:34ch; }
+
+  /* modal de confirmacao de entrada (pedido de pareamento) */
+  #confirm { position:fixed; inset:0; background:rgba(0,0,0,0.92); z-index:21; display:none;
+    flex-direction:column; align-items:center; justify-content:center; gap:14px; padding:24px;
+    text-align:center; }
+  #confirm.show { display:flex; }
+  #confirm h2 { font-size:16px; text-transform:uppercase; letter-spacing:0.14em; margin:0; color:var(--neon); }
+  #confirm p { color:var(--dim); font-size:12.5px; margin:0; max-width:34ch; line-height:1.6; }
+  #confirm .chat { color:#fff; font-size:15px; font-weight:700; border:2px solid #fff;
+    padding:10px 16px; max-width:min(92vw,420px); word-break:break-word; min-height:1.2em; }
+  #confirm .chat:empty { display:none; }
+  #confirm .err { color:var(--err); min-height:1.2em; font-size:12.5px; max-width:34ch; }
+  #confirm .wait { color:var(--neon); font-size:13px; letter-spacing:0.1em; }
+  #confirm button { width:min(92vw,420px); }
+  #confirm[data-state="waiting"] #confirmBtn,
+  #confirm[data-state="waiting"] #confirmCancel { display:none; }
+  #confirm:not([data-state="waiting"]) .wait { display:none; }
 
   /* Pensamento recolhido: mostra so a primeira linha como "resumo" clicavel. */
   .ln.think { cursor:pointer; }
@@ -196,9 +226,24 @@ function renderPage() {
     <p>se a câmera não leu o QR, digite o código que aparece embaixo dele na tela do PC.</p>
     <input class="code" id="paircode" inputmode="text" autocomplete="off" autocapitalize="characters"
       spellcheck="false" placeholder="CÓDIGO" maxlength="12" />
+    <div class="hint" id="captchaHint">resolva a conta pra provar que você é humano:</div>
+    <div class="captcha">
+      <div class="q" id="captchaQ"></div>
+      <button class="reload" id="captchaReload" type="button" title="outro desafio" aria-label="outro desafio">↻</button>
+    </div>
+    <input class="small" id="captchaA" inputmode="numeric" autocomplete="off" placeholder="?" maxlength="3" />
     <div class="err" id="pairerr"></div>
     <button class="primary" id="pairbtn">parear</button>
   </div>
+  <div id="confirm">
+    <h2>entrar no chat?</h2>
+    <p id="confirmText">você vai pedir acesso ao terminal deste PC.</p>
+    <div class="chat" id="confirmTitle"></div>
+    <div class="err" id="confirmErr"></div>
+    <div class="wait" id="confirmWait">aguardando aprovação no PC…</div>
+    <button class="primary" id="confirmBtn">entrar</button>
+    <button id="confirmCancel">cancelar</button>
+  </div>
 </div>
 <script>
 (function () {
@@ -414,30 +459,190 @@ function renderPage() {
     return BASE.replace(/\\/$/, "") + "/" + String(path).replace(/^\\//, "");
   }
 
-  async function pair(code) {
-    if (!code) return false;
-    var res;
+  // PASSO 1: pede entrada. NAO recebe token ainda — o dono do terminal aprova.
+  // Devolve { requestId, session } ou null.
+  async function requestEntry(code) {
+    if (!code) return null;
+    var res, data;
     try {
       res = await fetch(url("pair"), {
         method: "POST", headers: { "content-type": "application/json" },
-        body: JSON.stringify({ code: code, device: navigator.platform || "celular" }),
+        body: JSON.stringify({
+          code: code,
+          device: navigator.platform || "celular",
+          captchaId: captchaId,
+          captchaAnswer: ($("captchaA") && $("captchaA").value.trim()) || "",
+        }),
       });
     } catch (e) {
       pairErr("sem ligação com o servidor — confira a URL");
-      return false;
+      return null;
     }
-    if (!res.ok) { pairErr("código inválido ou expirado — gere outro no PC"); return false; }
-    var data = await res.json();
-    token = data.token;
-    sessionStorage.setItem("kafox_token", token);
-    sid.textContent = (data.session && data.session.sessionId) || "";
-    showPairing(false);
-    return true;
+    try { data = await res.json(); } catch (e) { data = {}; }
+    if (!res.ok) {
+      if (data && data.captcha) {
+        pairErr("captcha incorreto — tente de novo");
+        loadCaptcha(); // desafio e de uso unico: pede outro
+      } else {
+        pairErr((data && data.error) || "código inválido ou expirado — gere outro no PC");
+      }
+      return null;
+    }
+    return data;
+  }
+
+  // --- captcha anti-bot (desafio emitido pelo servidor) ---
+  var captchaId = "";
+  var captchaSvg = null;
+
+  // Desenha a pergunta como SVG com leve ruido/rotacao (dificulta OCR simples),
+  // tudo em texto vetorial — nada de canvas/imagem externa.
+  function renderCaptchaSvg(question, seed) {
+    var chars = String(question).split("");
+    var pad = 10, cw = 15, fs = 24;
+    var w = pad * 2 + chars.length * cw;
+    var h = 56;
+    var parts = ['<svg xmlns="http://www.w3.org/2000/svg" width="' + w + '" height="' + h + '" viewBox="0 0 ' + w + " " + h + '">'];
+    parts.push('<rect width="' + w + '" height="' + h + '" fill="#000"/>');
+    // algumas linhas de ruido
+    var rnd = function (n) { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed % n; };
+    for (var k = 0; k < 4; k++) {
+      var x1 = rnd(w), y1 = rnd(h), x2 = rnd(w), y2 = rnd(h);
+      parts.push('<line x1="' + x1 + '" y1="' + y1 + '" x2="' + x2 + '" y2="' + y2 + '" stroke="#bfa682" stroke-width="1" opacity="0.35"/>');
+    }
+    for (var i = 0; i < chars.length; i++) {
+      var ch = chars[i];
+      if (ch === " ") { continue; }
+      var rot = (rnd(17) - 8);
+      var y = Math.round(h / 2 + 6 + (rnd(7) - 3));
+      var x = pad + i * cw;
+      parts.push(
+        '<text x="' + x + '" y="' + y + '" font-family="monospace" font-size="' + fs +
+        '" font-weight="700" fill="#bfa682" transform="rotate(' + rot + " " + x + " " + y + ')">' +
+        ch.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;") +
+        "</text>"
+      );
+    }
+    parts.push("</svg>");
+    return parts.join("");
   }
 
-  function showPairing(on) { $("pairing").classList[on ? "add" : "remove"]("show"); }
+  async function loadCaptcha() {
+    var box = $("captchaQ");
+    if (box) box.textContent = "…";
+    try {
+      var res = await fetch(url("captcha"), { cache: "no-store" });
+      var data = await res.json();
+      captchaId = data.id || "";
+      var seed = 0;
+      for (var i = 0; i < captchaId.length; i++) seed = (seed * 31 + captchaId.charCodeAt(i)) & 0x7fffffff;
+      if (box) box.innerHTML = renderCaptchaSvg(data.question || "", seed);
+      var a = $("captchaA");
+      if (a) { a.value = ""; }
+    } catch (e) {
+      captchaId = "";
+      if (box) box.textContent = "falha ao carregar";
+    }
+  }
+
+  function showPairing(on) {
+    $("pairing").classList[on ? "add" : "remove"]("show");
+    if (on && !captchaId) loadCaptcha();
+  }
   function pairErr(msg) { $("pairerr").textContent = msg || ""; }
 
+  // Modal de confirmacao: mostra o titulo do chat e pede "entrar".
+  function showConfirm(state, msg) {
+    var el = $("confirm");
+    if (!state) { el.classList.remove("show"); el.removeAttribute("data-state"); return; }
+    $("confirmErr").textContent = msg || "";
+    el.setAttribute("data-state", state);
+    el.classList.add("show");
+  }
+  function confirmErr(msg) { $("confirmErr").textContent = msg || ""; }
+
+  // Pareamento (Opção A): o celular se auto-aprova apos confirmar no modal.
+  //   1. pede entrada (sem token) -> cria um pedido PENDENTE no servidor;
+  //   2. mostra o modal "entrar no chat? <titulo>" com os botoes entrar/cancelar;
+  //      ao clicar em "entrar", ESTE navegador chama /pair/decide {approved:true},
+  //      o token de sessao e emitido para ele e o terminal detecta (some o QR).
+  //      Cancelar nega o pedido (approved:false).
+  // Devolve true se pareou; false se negado/expirado/erro/cancelado.
+  function pair(code) {
+    if (!code) return false;
+    return new Promise(async function (resolve) {
+      // garante um captcha valido (fluxo QR nao passa por showPairing).
+      if (!captchaId) await loadCaptcha();
+      // valida o codigo primeiro (rapido). Se for valido, mostra direto o modal
+      // "entrar no chat?" — o proprio usuario confirma no celular.
+      var req = await requestEntry(code);
+      if (!req || !req.requestId) { showConfirm(null); resolve(false); return; }
+      $("confirmTitle").textContent = ((req.session && req.session.title) || req.title || "conversa sem título");
+      confirmErr("");
+      showConfirm("ask");
+
+      var settled = false;
+      function finish(ok, msg) {
+        if (settled) return;
+        settled = true;
+        $("confirmBtn").onclick = null;
+        $("confirmCancel").onclick = null;
+        if (ok) { showConfirm(null); resolve(true); }
+        else { showConfirm("ask", msg); resolve(false); }
+      }
+
+      function decide(approved) {
+        return fetch(url("pair/decide"), {
+          method: "POST", headers: { "content-type": "application/json" },
+          body: JSON.stringify({ id: req.requestId, approved: approved }),
+        }).catch(function () { return null; });
+      }
+
+      $("confirmBtn").onclick = function () {
+        $("confirmBtn").disabled = true;
+        // aprova explicitamente ("tem certeza?") e espera o token desta sessao.
+        (async function () {
+          await decide(true);
+          var decision;
+          while (!settled) {
+            decision = await awaitDecisionOnce(req.requestId);
+            if (decision.status !== "pending") break;
+            await new Promise(function (r) { setTimeout(r, 1000); });
+          }
+          $("confirmBtn").disabled = false;
+          if (decision && decision.status === "approved") finish(true);
+          else if (decision && decision.status === "denied") finish(false, "entrada negada — gere outro código");
+          else finish(false, "pedido expirou — gere outro código no PC");
+        })();
+      };
+      $("confirmCancel").onclick = function () {
+        decide(false);
+        finish(false, "cancelado — escaneie o QR ou digite o código de novo");
+      };
+    });
+  }
+
+  // Uma consulta de status (sem loop), para o modal controlar o polling.
+  async function awaitDecisionOnce(requestId) {
+    var res;
+    try {
+      res = await fetch(url("pair") + "?id=" + encodeURIComponent(requestId), { cache: "no-store" });
+    } catch (e) {
+      return { status: "pending" };
+    }
+    if (res.status === 404) return { status: "expired" };
+    var data = await res.json().catch(function () { return {}; });
+    if (data.status === "approved" && data.token) {
+      token = data.token;
+      sessionStorage.setItem("kafox_token", token);
+      sid.textContent = (data.session && data.session.sessionId) || "";
+      return { status: "approved" };
+    }
+    if (data.status === "denied") return { status: "denied" };
+    if (data.status === "expired" || data.status === "unknown") return { status: "expired" };
+    return { status: "pending" };
+  }
+
   // Reconstroi o log a partir do historico (um turno por mensagem do usuario,
   // com as respostas/tools/pensamentos abaixo).
   function renderHistory(messages) {
@@ -663,14 +868,17 @@ function renderPage() {
 
   async function boot() {
     var m = location.hash.match(/p=([A-Za-z0-9]+)/);
+    var scanned = m ? m[1] : "";
     if (m) {
       await pair(m[1]);
       history.replaceState(null, "", location.pathname);
     }
     if (!token) {
       // Sem token (nem por QR, nem salvo): mostra a tela de pareamento manual.
+      // Se veio do QR, deixa o codigo preenchido pra so resolver o captcha.
+      if (scanned && !$("paircode").value) $("paircode").value = scanned.toUpperCase();
       showPairing(true);
-      $("paircode").focus();
+      $("captchaA").focus();
       return;
     }
     var okState = await loadState();
@@ -692,6 +900,7 @@ function renderPage() {
     }
   }
   $("pairbtn").onclick = pairManual;
+  $("captchaReload").onclick = function () { pairErr(""); loadCaptcha(); };
   $("paircode").addEventListener("input", function () {
     this.value = this.value.toUpperCase().replace(/[^A-Z0-9]/g, "");
   });

package/src/tui.js

@@ -16,7 +16,7 @@ const os = require("os");
 const path = require("path");
 const chalk = require("chalk");
 const storage = require("./storage");
-const { estimateTokens: countContextTokens, compactIfNeeded } = require("./compact");
+const { estimateTokens: countContextTokens, compactIfNeeded, trimHistory } = require("./compact");
 const { ensureSession, fetchApi } = require("./auth");
 const { runAgent } = require("./agent");
 const { THEMES, themeColors, paintLine, paintPanel, borderColor } = require("./theme");
@@ -1408,6 +1408,29 @@ function box(state, { title, body, hint, width }) {
 
 function approvalBody(state, width) {
   const { name, args, change } = state.approval;
+
+  // Pedido de pareamento do celular: mesmo widget de opcoes, conteudo proprio.
+  if (name === "__pair__") {
+    const body = [];
+    const who = change?.device || "celular";
+    body.push(chalk.bold("Um celular quer entrar nesta conversa."));
+    body.push("");
+    if (change?.title) body.push(truncate("conversa: " + change.title, width - 4));
+    if (change?.base) body.push(chalk.dim(truncate(change.base, width - 4)));
+    body.push(chalk.dim(truncate("dispositivo: " + who, width - 4)));
+    body.push("");
+    const optionsStart = body.length;
+    const opts = state.approval.options || APPROVAL_OPTIONS;
+    for (const [index, option] of opts.entries()) {
+      const selected = index === state.approval.index;
+      const line = padRight(`${selected ? "▸ " : "  "}${option.label}`, width - 6);
+      if (selected) body.push(chalk.inverse(chalk.bold(line)));
+      else if (option.id === "deny") body.push(chalk.dim(line));
+      else body.push(line);
+    }
+    return { title: "Pareamento do celular", body, optionsStart };
+  }
+
   const meta = toolMeta(name);
   const body = [];
 
@@ -2420,14 +2443,14 @@ async function runTUI({
         text: "Interrompido por você (Esc).",
         interrupted: true,
       });
-      if (result.messages) state.context = result.messages;
+      if (result.messages) state.context = trimHistory(result.messages);
     } else if (result.ok) {
       const text = String(result.text || "").trim();
       // O stream ja foi commitado em finishStreaming(): so empurra aqui se for
       // texto novo (ou se nao houve streaming, ex.: resposta sem onText).
       if (text) commitFinalText(state, text, result.ms);
       state.streamedText = "";
-      if (result.messages) state.context = result.messages;
+      if (result.messages) state.context = trimHistory(result.messages);
       // Reconectou de verdade: limpa o alerta e os erros de rede pendentes.
       clearRetry();
     } else {
@@ -2510,10 +2533,15 @@ async function runTUI({
     const pending = state.approval;
     if (!pending) return;
     state.approval = null;
-    if (decision === "always") state.autoApprove = true;
-    if (decision === "always") persist();
+    // O pedido de pareamento NAO mexe no autoApprove de ferramentas: "lembrar"
+    // ali significa confiar naquele navegador, tratado por quem criou o pedido.
+    const isPair = pending.name === "__pair__";
+    if (decision === "always" && !isPair) state.autoApprove = true;
+    if (decision === "always" && !isPair) persist();
     render();
-    pending.resolve(decision !== "deny");
+    // Pareamento precisa do texto da decisao (once/always/deny); ferramentas
+    // so querem o booleano "aprovado?".
+    pending.resolve(isPair ? decision : decision !== "deny");
   }
 
   // Com captura de mouse ligada o terminal entrega a roda para a TUI, mas em
@@ -2593,7 +2621,8 @@ async function runTUI({
   }
 
   function moveApproval(delta) {
-    const count = APPROVAL_OPTIONS.length;
+    const opts = state.approval.options || APPROVAL_OPTIONS;
+    const count = opts.length;
     state.approval.index = (state.approval.index + delta + count) % count;
     render();
   }
@@ -2610,10 +2639,11 @@ async function runTUI({
 
     // Aprovacao de ferramenta: navega e confirma.
     if (state.approval) {
+      const opts = state.approval.options || APPROVAL_OPTIONS;
       if (key.name === "up" || key.name === "down" || key.name === "tab") {
         return moveApproval(key.name === "up" ? -1 : 1);
       }
-      if (key.name === "return") return settleApproval(APPROVAL_OPTIONS[state.approval.index].id);
+      if (key.name === "return") return settleApproval(opts[state.approval.index].id);
       if (key.name === "escape") return settleApproval("deny");
       if (key.name === "a") return settleApproval("always");
       if (key.name === "y") return settleApproval("once");