kafox-cli 0.10.0 → 0.10.2

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, "");
   });