kafox-cli 0.9.8 → 0.10.0

package/src/mobile/bridge.js

@@ -0,0 +1,285 @@
+/**
+ * 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 { 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.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() {
+    return {
+      sessionId: this.sessionId,
+      model: this.model,
+      cwd: this.cwd,
+      allowAll: this.allowAll,
+      busy: this.busy,
+      streaming: this.streaming,
+      messages: this.messages,
+      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 };