kafox-cli 0.9.9 → 0.10.1

package/src/mobile/server.js

@@ -0,0 +1,399 @@
+/**
+ * Servidor HTTP do kafox mobile (node:http, sem dependencia).
+ *
+ * Rotas:
+ *   GET  /            -> pagina do celular (view.js)
+ *   GET  /events      -> SSE com os eventos da sessao (?since=<seq> p/ replay)
+ *   GET  /state       -> snapshot inicial (exige token)
+ *   POST /pair        -> troca pair_code por session_token
+ *   POST /prompt      -> enfileira um turno  { text }
+ *   POST /approve     -> resolve aprovacao    { id, decision }
+ *   POST /abort       -> aborta o turno
+ *
+ * O Caddy faz o TLS e o reverse_proxy (web.kafox.dev -> 127.0.0.1:porta); aqui
+ * so escutamos em loopback. Nada de buffer no SSE: header + flush por evento.
+ */
+
+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;
+
+function readBody(req, limit = 64 * 1024) {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += chunk;
+      if (data.length > limit) {
+        reject(new Error("corpo grande demais"));
+        req.destroy();
+      }
+    });
+    req.on("end", () => resolve(data));
+    req.on("error", reject);
+  });
+}
+
+function json(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": Buffer.byteLength(payload),
+    "cache-control": "no-store",
+  });
+  res.end(payload);
+}
+
+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) {
+      try {
+        client.write(frame);
+      } catch {
+        sseClients.delete(client);
+      }
+    }
+  }
+
+  bridge.on("event", broadcast);
+
+  const server = http.createServer(async (req, res) => {
+    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, {
+        "content-type": "text/html; charset=utf-8",
+        "cache-control": "no-store",
+      });
+      res.end(pageHtml);
+      return;
+    }
+
+    if (req.method === "GET" && pathname === "/health") {
+      json(res, 200, { ok: true, busy: bridge.busy, sessionId: bridge.sessionId });
+      return;
+    }
+
+    // Favicon: o navegador pede sozinho e nao manda token. Sem isso, ele leva
+    // 401 e polui o console. Servimos um "K" brutalist em SVG.
+    if (req.method === "GET" && (pathname === "/favicon.ico" || pathname === "/favicon.svg")) {
+      const svg =
+        "<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'>" +
+        "<rect width='32' height='32' fill='#000'/>" +
+        "<text x='6' y='24' font-size='22' fill='#fff' font-family='monospace' font-weight='bold'>K</text></svg>";
+      res.writeHead(200, { "content-type": "image/svg+xml", "cache-control": "max-age=86400" });
+      res.end(svg);
+      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 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());
+    }
+
+    // Long-polling: retorna os eventos novos e FECHA a resposta. Diferente do
+    // SSE, uma resposta normal com fim e entregue de imediato pelo Cloudflare,
+    // que costuma segurar/abortar streams text/event-stream de navegadores.
+    if (req.method === "GET" && pathname === "/poll") {
+      const since = Number.parseInt(url.searchParams.get("since") || "0", 10) || 0;
+      const waitMs = Math.min(Math.max(Number.parseInt(url.searchParams.get("wait") || "15000", 10) || 15000, 0), 25000);
+      const existing = bridge.log.since(since);
+      if (existing.length) {
+        res.writeHead(200, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+        return res.end(JSON.stringify({ events: existing, seq: bridge.log.seq }));
+      }
+      let done = false;
+      let unsub = null;
+      const finish = (events) => {
+        if (done) return;
+        done = true;
+        clearTimeout(timer);
+        if (unsub) unsub();
+        try {
+          res.writeHead(200, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+          res.end(JSON.stringify({ events, seq: bridge.log.seq }));
+        } catch {
+          /* cliente sumiu */
+        }
+      };
+      const onEvent = (ev) => finish([ev]);
+      const timer = setTimeout(() => finish([]), waitMs);
+      timer.unref?.();
+      unsub = bridge.log.subscribe(onEvent);
+      req.on("close", () => { done = true; clearTimeout(timer); if (unsub) unsub(); });
+      return;
+    }
+
+    if (req.method === "GET" && pathname === "/events") {
+      const since = Number.parseInt(url.searchParams.get("since") || "0", 10) || 0;
+      // Cache-Control com no-transform evita que proxies (Cloudflare/Caddy)
+      // reescrevam/segurem o stream. X-Accel-Buffering desliga o buffer do nginx.
+      res.writeHead(200, {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-store, no-transform",
+        connection: "keep-alive",
+        // impedem buffering em proxies (Caddy/nginx) — SSE sem isso trava.
+        "x-accel-buffering": "no",
+        "transfer-encoding": "chunked",
+      });
+      // Cloudflare (e outros edges) seguram o SSE num buffer antes de comecar a
+      // repassar. Preenchemos esse buffer com um comentario de padding logo na
+      // abertura (8KB) para forcar o flush e o streaming continuo no navegador.
+      res.write(": kafox mobile\n");
+      res.write(`:${" ".repeat(8192)}\n\n`);
+      // replay do que o cliente perdeu, depois assina o ao vivo.
+      for (const event of bridge.log.since(since)) res.write(`data: ${JSON.stringify(event)}\n\n`);
+
+      sseClients.add(res);
+      const heartbeat = setInterval(() => {
+        try {
+          res.write(": ping\n\n");
+        } catch {
+          /* tratado no close */
+        }
+      }, HEARTBEAT_MS);
+      heartbeat.unref?.();
+
+      const cleanup = () => {
+        clearInterval(heartbeat);
+        sseClients.delete(res);
+      };
+      req.on("close", cleanup);
+      req.on("error", cleanup);
+      return;
+    }
+
+    if (req.method === "POST" && pathname === "/prompt") {
+      if (blocked(req, res, "action", tokenKey)) return;
+      let body;
+      try {
+        body = JSON.parse((await readBody(req)) || "{}");
+      } catch {
+        return json(res, 400, { error: "json invalido" });
+      }
+      const text = String(body.text || "");
+      if (!text.trim()) return json(res, 400, { error: "texto vazio" });
+      if (bridge.busy) return json(res, 409, { error: "ocupado" });
+      pairing.audit("prompt", { chars: text.length });
+      // roda em background; o resultado chega pelo SSE.
+      bridge.prompt(text).catch(() => {});
+      return json(res, 202, { ok: true });
+    }
+
+    if (req.method === "POST" && pathname === "/approve") {
+      if (blocked(req, res, "action", tokenKey)) return;
+      let body;
+      try {
+        body = JSON.parse((await readBody(req)) || "{}");
+      } catch {
+        return json(res, 400, { error: "json invalido" });
+      }
+      const decision = ["once", "always", "deny"].includes(body.decision) ? body.decision : "deny";
+      const ok = bridge.approve(body.id, decision);
+      pairing.audit("approve", { decision, id: body.id });
+      return json(res, ok ? 200 : 409, { ok });
+    }
+
+    if (req.method === "POST" && pathname === "/abort") {
+      pairing.audit("abort", {});
+      bridge.abort();
+      return json(res, 200, { ok: true });
+    }
+
+    json(res, 404, { error: "nao encontrado" });
+  });
+
+  server.on("close", () => bridge.off("event", broadcast));
+
+  return { server, pairing, sseClients };
+}
+
+/**
+ * Descobre quem esta segurando uma porta local (best-effort, sem depender de
+ * `lsof`). Usa `ss -tlnp` quando disponivel; devolve [] se nao conseguir.
+ */
+function portHolders(port) {
+  try {
+    const { execSync } = require("child_process");
+    const out = execSync(`ss -tlnp 2>/dev/null | grep ':${Number(port)}\\b' || true`, {
+      encoding: "utf8",
+      timeout: 3000,
+    });
+    const holders = [];
+    for (const line of out.split("\n")) {
+      const m = line.match(/users:\(\("([^"]+)",pid=(\d+)/);
+      if (m) holders.push({ name: m[1], pid: Number(m[2]) });
+    }
+    return holders;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Escuta com fallback de porta: tenta `port`, e se estiver ocupada (EADDRINUSE)
+ * tenta as proximas `maxTries` portas. Resolve com a porta efetivamente usada.
+ *
+ * Sem isso, subir dois `kafox mobile` estourava EADDRINUSE e derrubava o CLI.
+ */
+function listenWithFallback(server, { port, host = "127.0.0.1", maxTries = 12 } = {}) {
+  return new Promise((resolve, reject) => {
+    let attempt = 0;
+    let current = Number(port);
+
+    const onError = (error) => {
+      if (error.code === "EADDRINUSE" && attempt < maxTries) {
+        const holders = portHolders(current);
+        const who = holders.length ? ` (ocupada por ${holders.map((h) => `${h.name} pid ${h.pid}`).join(", ")})` : "";
+        process.stderr.write(`  porta ${current} em uso${who}; tentando ${current + 1}…\n`);
+        attempt += 1;
+        current += 1;
+        server.once("error", onError);
+        server.listen(current, host);
+        return;
+      }
+      server.removeListener("error", onError);
+      reject(error);
+    };
+
+    server.once("error", onError);
+    server.once("listening", () => {
+      server.removeListener("error", onError);
+      resolve(current);
+    });
+    server.listen(current, host);
+  });
+}
+
+module.exports = { createMobileServer, listenWithFallback, portHolders };

package/src/mobile/tui-bridge.js

@@ -0,0 +1,290 @@
+/**
+ * TuiBridge: adaptador que faz o servidor mobile falar com a sessao REAL da TUI.
+ *
+ * Diferente do SessionBridge (que roda o seu proprio runAgent, ver bridge.js),
+ * este NAO tem agente proprio: a TUI continua dona do estado e o celular entra
+ * como mais um cliente. O bridge so:
+ *
+ *   - ENVIA turnos: prompt(text) -> enfileira no mesmo caminho do teclado
+ *     (api.submitText), entao PC e celular compartilham a MESMA sessao/contexto.
+ *   - RESOLVE aprovacoes: approve(id, decision) -> fecha a mesma caixa que o
+ *     teclado abriria (api.settleApproval).
+ *   - ABORTA o turno: abort() -> api.abortTurn() (o mesmo do Esc).
+ *   - ESPELHA o estado: um watcher leve compara `state.messages`/`streaming`
+ *     com a ultima foto e emite eventos numerados (mesmo contrato do
+ *     SessionBridge, consumido pelo server.js/SSE e por view.js).
+ *
+ * Por que polling e nao hooks: a TUI muta `state` direto (sem emitter); o
+ * watcher de ~120ms e barato (comparacoes numericas) e nao exige tocar em cada
+ * ponto do runLine. Nada aqui limita a taxa do PC — so observa.
+ *
+ * Interface exigida do `api` (exposta por runTUI):
+ *   submitText(line) -> Promise   enfileira um turno como se viesse do teclado
+ *   settleApproval(decision)      "once" | "always" | "deny"
+ *   abortTurn()                   aborta o turno corrente
+ */
+
+const { EventEmitter } = require("events");
+const { EventLog } = require("./protocol");
+
+const WATCH_MS = 120;
+
+class TuiBridge extends EventEmitter {
+  constructor({ state, api, sessionId = null, cwd = process.cwd(), readonly = false } = {}) {
+    super();
+    if (!state || !api) throw new Error("TuiBridge precisa de { state, api }");
+    this.state = state;
+    this.api = api;
+    this.readonly = Boolean(readonly);
+    this.log = new EventLog();
+
+    // Foto do ultimo estado observado, para detectar diffs.
+    this.snap = {
+      messages: 0, // quantas mensagens ja foram espelhadas
+      streamText: "",
+      streamReasoning: "",
+      approvalId: null,
+      busy: false,
+      toolsSeen: new Map(), // id -> { status, summary }
+    };
+
+    this.timer = null;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Interface consumida pelo servidor (mesma do SessionBridge)
+  // ---------------------------------------------------------------------------
+
+  get busy() {
+    return Boolean(this.state.busy);
+  }
+
+  get sessionId() {
+    return this.sessionIdValue || this.state.sessionId || null;
+  }
+
+  set sessionId(value) {
+    this.sessionIdValue = value;
+  }
+
+  /** Snapshot inicial para o celular: historico + estado atual da TUI. */
+  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),
+      readonly: this.readonly,
+      busy: Boolean(this.state.busy),
+      streaming: this.state.streaming
+        ? { text: this.state.streaming.text, reasoning: this.state.streaming.reasoning }
+        : null,
+      messages: this.state.messages || [],
+      context: [],
+      pendingApproval: this.state.approval
+        ? {
+            id: this._approvalId(),
+            name: this.state.approval.name,
+            args: this.state.approval.args,
+            change: this.state.approval.change ?? null,
+          }
+        : null,
+      seq: this.log.seq,
+    };
+  }
+
+  emitEvent(type, payload = {}) {
+    const event = this.log.push(type, payload);
+    this.emit("event", event);
+    return event;
+  }
+
+  /** Enfileira um turno vindo do celular na MESMA fila do teclado. */
+  async prompt(text) {
+    const line = String(text || "").trim();
+    if (!line) return { ok: false, error: "vazio" };
+    if (this.readonly) return { ok: false, error: "modo somente leitura" };
+    if (this.state.busy || this.state.queue?.length) return { ok: false, error: "ocupado" };
+    // Nao emitimos "user" aqui: o watcher ja espelha a mensagem que a TUI cria.
+    await this.api.submitText(line);
+    return { ok: true };
+  }
+
+  /** Resolve a aprovacao pendente (mesma que o teclado mostraria). */
+  approve(id, decision = "once") {
+    if (this.readonly) return false;
+    const pending = this.state.approval;
+    if (!pending) return false;
+    if (id && this._approvalId() !== id) return false;
+    this.api.settleApproval(decision === "always" ? "always" : decision === "deny" ? "deny" : "once");
+    // O evento "approval-resolved" sai pelo watcher (ao ver approval === null).
+    return true;
+  }
+
+  abort() {
+    if (this.readonly) return false;
+    this.api.abortTurn();
+    return true;
+  }
+
+  start() {
+    if (this.timer) return;
+    this._seed();
+    this.timer = setInterval(() => this._tick(), WATCH_MS);
+    this.timer.unref?.();
+  }
+
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Espelho do estado da TUI -> eventos para o celular
+  // ---------------------------------------------------------------------------
+
+  _approvalId() {
+    // A TUI nao da id a aprovacao; derivamos um estavel a partir do nome+args
+    // para o celular poder correlacionar o botao com a caixa do PC.
+    const ap = this.state.approval;
+    if (!ap) return null;
+    if (!ap.__mobileId) {
+      const base = JSON.stringify({ n: ap.name, a: ap.args || {} });
+      let hash = 0;
+      for (let i = 0; i < base.length; i += 1) hash = (hash * 31 + base.charCodeAt(i)) | 0;
+      ap.__mobileId = `ap_${(hash >>> 0).toString(36)}`;
+    }
+    return ap.__mobileId;
+  }
+
+  /** Marca o historico ja existente como "espelhado" (nao reenvia pro celular). */
+  _seed() {
+    const messages = this.state.messages || [];
+    this.snap.messages = messages.length;
+    for (const m of messages) {
+      if (m.role === "tool" && m.tool?.id) {
+        this.snap.toolsSeen.set(m.tool.id, { status: m.tool.status, summary: m.tool.summary });
+      }
+    }
+  }
+
+  _tick() {
+    const state = this.state;
+    const messages = state.messages || [];
+
+    // 1) Mensagens commitadas novas (user/assistant/thinking/tool/system/compaction).
+    while (this.snap.messages < messages.length) {
+      const m = messages[this.snap.messages];
+      this._emitMessage(m);
+      this.snap.messages += 1;
+    }
+
+    // 2) Streaming ao vivo (texto/reasoning) — a TUI muta state.streaming.
+    const streaming = state.streaming;
+    const text = streaming?.text || "";
+    if (text.length > this.snap.streamText.length) {
+      const chunk = text.slice(this.snap.streamText.length);
+      this.emitEvent("token", { text: chunk });
+    }
+    this.snap.streamText = text;
+
+    const reasoning = streaming?.reasoning || "";
+    if (reasoning.length > this.snap.streamReasoning.length) {
+      const chunk = reasoning.slice(this.snap.streamReasoning.length);
+      this.emitEvent("thought", { text: chunk });
+    }
+    this.snap.streamReasoning = reasoning;
+
+    // 3) Tool cards em andamento: status/summary mudam sem nova mensagem.
+    for (const m of messages) {
+      if (m.role !== "tool" || !m.tool?.id) continue;
+      const prev = this.snap.toolsSeen.get(m.tool.id);
+      const cur = { status: m.tool.status, summary: m.tool.summary };
+      if (!prev) {
+        this.emitEvent("tool-start", {
+          id: m.tool.id,
+          name: m.tool.name,
+          args: m.tool.args,
+          label: m.tool.label,
+          change: m.tool.change,
+          fromMcp: Boolean(m.tool.meta?.mcp),
+          subagent: m.tool.subagent,
+        });
+      } else if (prev.status !== cur.status) {
+        this.emitEvent("tool-result", {
+          id: m.tool.id,
+          name: m.tool.name,
+          output: m.tool.output || "",
+          change: m.tool.change,
+          ok: m.tool.ok !== false,
+          skipped: m.tool.skipped,
+          summary: m.tool.summary || "",
+          ms: m.tool.ms || 0,
+        });
+      }
+      this.snap.toolsSeen.set(m.tool.id, cur);
+    }
+
+    // 4) Aprovacao abrindo/fechando.
+    const apId = this.state.approval ? this._approvalId() : null;
+    if (apId && apId !== this.snap.approvalId) {
+      this.emitEvent("approval-request", {
+        id: apId,
+        name: this.state.approval.name,
+        args: this.state.approval.args,
+        change: this.state.approval.change ?? null,
+        fromMcp: Boolean(this.state.approval.fromMcp),
+      });
+    } else if (!apId && this.snap.approvalId) {
+      this.emitEvent("approval-resolved", { id: this.snap.approvalId, allowed: true });
+    }
+    this.snap.approvalId = apId;
+
+    // 5) Inicio/fim de turno.
+    const busy = Boolean(state.busy);
+    if (busy && !this.snap.busy) {
+      this.snap.streamText = "";
+      this.snap.streamReasoning = "";
+      this.emitEvent("stream-start", {});
+    } else if (!busy && this.snap.busy) {
+      this.emitEvent("done", { text: this.snap.streamText, ms: 0 });
+      this.snap.streamText = "";
+      this.snap.streamReasoning = "";
+    }
+    this.snap.busy = busy;
+  }
+
+  _emitMessage(m) {
+    if (!m) return;
+    if (m.role === "user") this.emitEvent("user", { text: m.text });
+    else if (m.role === "thinking") this.emitEvent("thought", { text: m.text });
+    else if (m.role === "compaction") {
+      this.emitEvent("compact", {
+        before: m.compaction?.before ?? 0,
+        after: m.compaction?.after ?? 0,
+        summary: m.text || "",
+      });
+    } else if (m.role === "system") this.emitEvent("error", { text: m.text });
+    else if (m.role === "tool" && m.tool?.id) {
+      // Ja tratado no diff de tools; garante o card caso o watcher tenha perdido.
+      if (!this.snap.toolsSeen.has(m.tool.id)) {
+        this.emitEvent("tool-start", {
+          id: m.tool.id,
+          name: m.tool.name,
+          args: m.tool.args,
+          label: m.tool.label,
+          change: m.tool.change,
+        });
+      }
+    } else if (m.role === "assistant") {
+      // O texto do assistant chega pelo stream; so usa como fallback quando nao
+      // houve streaming (evita card duplicado no celular).
+      if (!m.ms || !this.snap.streamText) {
+        // nada: assistant final ja coberto por "done"
+      }
+    }
+  }
+}
+
+module.exports = { TuiBridge };