kafox-cli 0.9.9 → 0.10.1

package/src/mobile/bridge.js

@@ -0,0 +1,296 @@
+/**
+ * SessionBridge: a ponte de sessao entre o agente e os clientes (TUI e mobile).
+ *
+ * Ele NAO reimplementa o agente: chama `runAgent` (src/agent.js) exatamente como
+ * a TUI chama, e transforma os callbacks em eventos numerados no EventLog — que
+ * a TUI e o celular (via SSE) consomem.
+ *
+ * Modelo de uso:
+ *   const bridge = new SessionBridge({ cwd, sessionId, messages, context, model });
+ *   bridge.on("event", (ev) => renderTUI(ev));           // a TUI assina
+ *   bridge.prompt("faz X");                              // o usuario manda
+ *   await bridge.approve(id, "once"|"always"|"deny");    // decisao de tool
+ *   bridge.abort();                                      // para o turno
+ *
+ * Estado persistido: usa src/sessions.js (os mesmos ~/.kafox/chats/<id>.json),
+ * com debounce, igual a TUI, para o `kafox resume` continuar achando a conversa.
+ */
+
+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;
+
+class SessionBridge extends EventEmitter {
+  constructor({
+    cwd = process.cwd(),
+    sessionId = null,
+    sessionStartedAt = null,
+    messages = [],
+    context = [],
+    model = null,
+    allowAll = false,
+    mcp = null,
+    extraTools = [],
+  } = {}) {
+    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 : [];
+    this.model = model || null;
+    this.allowAll = Boolean(allowAll);
+    this.mcp = mcp;
+    this.extraTools = extraTools;
+
+    this.log = new EventLog();
+    this.busy = false;
+    this.streaming = null;
+    this.abortController = null;
+    this.pendingApproval = null; // { id, resolve, name, args, change }
+    this.approvalCounter = 0;
+    this.saveTimer = null;
+  }
+
+  /** 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: trimmed.messages,
+      historyTruncated: trimmed.truncated,
+      historyTotal: trimmed.total,
+      context: this.context,
+      pendingApproval: this.pendingApproval
+        ? {
+            id: this.pendingApproval.id,
+            name: this.pendingApproval.name,
+            args: this.pendingApproval.args,
+            change: this.pendingApproval.change,
+          }
+        : null,
+      seq: this.log.seq,
+    };
+  }
+
+  emitEvent(type, payload) {
+    const event = this.log.push(type, payload);
+    this.emit("event", event);
+    return event;
+  }
+
+  /** Enfileira/roda um turno do usuario. Um turno por vez (igual a TUI). */
+  async prompt(text) {
+    const line = String(text || "").trim();
+    if (!line) return { ok: false, error: "vazio" };
+    if (this.busy) return { ok: false, error: "ocupado" };
+
+    this.emitEvent("user", { text: line });
+    this.messages.push({ role: "user", text: line });
+    this.context.push({ role: "user", content: line });
+    this.scheduleSave();
+    return this.runTurn();
+  }
+
+  async runTurn() {
+    this.busy = true;
+    this.streaming = { text: "", reasoning: "", thinkingStartedAt: 0 };
+    this.emitEvent("stream-start", {});
+    const controller = new AbortController();
+    this.abortController = controller;
+
+    let result;
+    try {
+      result = await runAgent({
+        messages: this.context,
+        model: this.model,
+        cwd: this.cwd,
+        approve: (name, args, extra) => this.requestApproval(name, args, extra),
+        autoApprove: () => this.allowAll,
+        extraTools: this.extraTools,
+        mcp: this.mcp,
+        signal: controller.signal,
+        onText: (chunk) => {
+          if (!this.streaming) return;
+          this.streaming.text += chunk;
+          this.emitEvent("token", { text: chunk });
+        },
+        onReasoning: (chunk) => {
+          if (!this.streaming) return;
+          if (!this.streaming.thinkingStartedAt) this.streaming.thinkingStartedAt = Date.now();
+          this.streaming.reasoning += chunk;
+          this.emitEvent("thought", { text: chunk });
+        },
+        onToolStart: ({ id, name, args, label, change, fromMcp, needsApproval, subagent }) => {
+          this.finishStreaming();
+          this.emitEvent("tool-start", {
+            id,
+            name,
+            args,
+            label,
+            change,
+            fromMcp,
+            needsApproval,
+            subagent,
+          });
+        },
+        onToolResult: ({ id, name, output, change, ok, skipped, summary, ms }) => {
+          this.emitEvent("tool-result", {
+            id,
+            name,
+            output: String(output || "").slice(0, 6000),
+            change,
+            ok,
+            skipped,
+            summary,
+            ms,
+          });
+        },
+        onRetry: (info) => this.emitEvent("retry", info),
+        onCompact: ({ before, after, summary }) => {
+          this.finishStreaming();
+          this.messages.push({ role: "compaction", text: summary || "", compaction: { before, after, at: Date.now() } });
+          this.emitEvent("compact", { before, after, summary });
+        },
+        onSubagentEvent: (event) =>
+          this.emitEvent("subagent", {
+            id: event.id,
+            index: event.index,
+            total: event.total,
+            objective: event.objective,
+            phase: event.phase,
+            text: event.text,
+            tool: event.tool,
+            ok: event.ok,
+            ms: event.ms,
+          }),
+      });
+    } catch (error) {
+      result = { ok: false, error: `Falha inesperada: ${error.message}` };
+    }
+
+    this.finishStreaming();
+    this.abortController = null;
+    this.busy = false;
+
+    if (result.messages) this.context = result.messages;
+
+    if (result.aborted || result.code === "aborted") {
+      const partial = String(result.text || "").trim();
+      if (partial) this.messages.push({ role: "assistant", text: partial, ms: result.ms, interrupted: true });
+      this.emitEvent("aborted", { text: partial });
+    } else if (result.ok) {
+      const text = String(result.text || "").trim();
+      if (text) this.messages.push({ role: "assistant", text, ms: result.ms });
+      this.emitEvent("done", { text, ms: result.ms, usage: result.usage || null });
+    } else {
+      this.messages.push({ role: "system", text: result.error || "Falha ao responder.", error: true });
+      this.emitEvent("error", { text: result.error || "Falha ao responder." });
+    }
+
+    this.streaming = null;
+    this.scheduleSave();
+    return result;
+  }
+
+  finishStreaming() {
+    const streaming = this.streaming;
+    if (!streaming) return;
+    if (streaming.reasoning.trim()) {
+      this.messages.push({
+        role: "thinking",
+        text: streaming.reasoning.trim(),
+        ms: streaming.thinkingStartedAt ? Date.now() - streaming.thinkingStartedAt : 0,
+      });
+    }
+    // Nao empilha o texto aqui: o evento final ("done") ja carrega o texto e o
+    // runTurn commita uma unica vez — evita a duplicacao que a TUI tambem evita.
+    this.streaming = { text: "", reasoning: "", thinkingStartedAt: 0 };
+  }
+
+  /** Pede aprovacao para uma ferramenta. Resolve pelo cliente (PC ou celular). */
+  requestApproval(name, args, extra = {}) {
+    if (this.allowAll) return Promise.resolve(true);
+    this.approvalCounter += 1;
+    const id = `ap_${Date.now().toString(36)}_${this.approvalCounter}`;
+    return new Promise((resolve) => {
+      this.pendingApproval = { id, name, args, change: extra.change ?? null, fromMcp: !!extra.fromMcp, resolve };
+      this.emitEvent("approval-request", {
+        id,
+        name,
+        args,
+        change: this.pendingApproval.change,
+        fromMcp: this.pendingApproval.fromMcp,
+      });
+    });
+  }
+
+  /** Resolve a aprovacao pendente. `decision` = "once" | "always" | "deny". */
+  approve(id, decision = "once") {
+    const pending = this.pendingApproval;
+    if (!pending) return false;
+    if (id && pending.id !== id) return false;
+    this.pendingApproval = null;
+    if (decision === "always") {
+      this.allowAll = true;
+      this.scheduleSave();
+    }
+    const allowed = decision !== "deny";
+    this.emitEvent("approval-resolved", { id: pending.id, decision, allowed });
+    pending.resolve(allowed);
+    return true;
+  }
+
+  abort() {
+    if (this.pendingApproval) this.approve(this.pendingApproval.id, "deny");
+    this.abortController?.abort();
+  }
+
+  scheduleSave() {
+    if (this.saveTimer) return;
+    this.saveTimer = setTimeout(() => {
+      this.saveTimer = null;
+      this.save();
+    }, SAVE_DEBOUNCE_MS);
+    this.saveTimer.unref?.();
+  }
+
+  save() {
+    try {
+      sessions.save({
+        id: this.sessionId,
+        cwd: this.cwd,
+        model: this.model,
+        allowAll: this.allowAll,
+        messages: this.messages,
+        context: this.context,
+        startedAt: this.sessionStartedAt,
+      });
+    } catch {
+      // persistencia best-effort: nunca derruba o turno.
+    }
+  }
+
+  tokens() {
+    return estimateTokens({ context: this.context });
+  }
+}
+
+module.exports = { SessionBridge };

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