kafox-cli 0.9.8 → 0.10.0

package/src/mobile/index.js

@@ -0,0 +1,538 @@
+/**
+ * `kafox mobile`: abre a sessao da CLI no navegador do celular.
+ *
+ * Dois jeitos de usar, mesma base:
+ *
+ *  1. HOSPEDADO NA TUI (padrao, caminho do `kafox mobile`):
+ *     `attachMobile({ state, api, options })` — chamado de dentro do runTUI.
+ *     A TUI continua dona da sessao; o celular vira mais um cliente (TuiBridge).
+ *     PC e celular operam a MESMA conversa: o que um digita, o outro ve.
+ *
+ *  2. HEADLESS (`runMobile`, sem TUI):
+ *     sobe um servidor ligado a uma conversa salva, sem abrir a interface do
+ *     terminal. Util para rodar em segundo plano / ssh. Usa SessionBridge.
+ *
+ * Exposicao de rede:
+ *   --lan: serve em 0.0.0.0 e o QR usa http://<ip>:<porta>. Bom para testar.
+ *   --public <url> (padrao https://web.kafox.dev/): bind em 127.0.0.1; o Caddy
+ *     (com TLS) faz reverse_proxy de web.kafox.dev -> 127.0.0.1:<porta>. Assim
+ *     o QR aponta para uma URL https valida — o navegador do celular exige
+ *     HTTPS para varios recursos (e a camera para o proprio QR).
+ */
+
+const os = require("os");
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const inquirer = require("inquirer");
+const qr = require("./qr");
+const { SessionBridge } = require("./bridge");
+const { TuiBridge } = require("./tui-bridge");
+const { createMobileServer, listenWithFallback } = require("./server");
+const { PairingManager } = require("./auth");
+const authStore = require("./auth");
+const sessions = require("../sessions");
+
+const DEFAULT_PORT = 7788;
+const DEFAULT_PUBLIC = "https://web.kafox.dev";
+
+function localIPs() {
+  const out = [];
+  const ifaces = os.networkInterfaces();
+  for (const name of Object.keys(ifaces)) {
+    for (const net of ifaces[name] || []) {
+      if (net.family === "IPv4" && !net.internal) out.push({ name, address: net.address });
+    }
+  }
+  return out;
+}
+
+function pickLanIP() {
+  const ips = localIPs();
+  const preferred = ips.find((i) => /^(192\.168|10\.|172\.(1[6-9]|2\d|3[01]))/.test(i.address));
+  return (preferred || ips[0])?.address || "127.0.0.1";
+}
+
+/**
+ * Seletor de conversa do `kafox mobile` headless.
+ * Mesmo espirito do picker do `kafox resume`: lista as conversas salvas
+ * (sessions.list(), de ~/.kafox/chats) da mais nova para a mais antiga, com
+ * titulo, data e o codigo para retomar — e uma opcao de comecar uma nova.
+ */
+async function chooseSession() {
+  const chats = sessions.list();
+  const choices = [{ name: chalk.green("＋  nova conversa"), value: "__new__" }];
+  for (const chat of chats) {
+    const when = sessions.dayMonth(chat.updatedAt);
+    const title = String(chat.title || "(sem titulo)").slice(0, 60);
+    choices.push({
+      name: `${title}${when ? chalk.dim(` - ${when}`) : ""}  ${chalk.dim(chat.id)}`,
+      value: chat.id,
+      short: title,
+    });
+  }
+
+  if (!chats.length) {
+    console.log(chalk.dim("Nenhuma conversa salva ainda — começando uma nova.\n"));
+    return null;
+  }
+
+  const { picked } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "picked",
+      message: "Qual conversa tunnelar para o celular?",
+      pageSize: 12,
+      choices,
+    },
+  ]);
+  if (picked === "__new__") return null;
+  return picked;
+}
+
+/** Monta o texto do QR + moldura para o terminal (ou para o modal da TUI). */
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+const visibleLen = (s) => [...String(s).replace(ANSI_RE, "")].length;
+
+function qrPanel(qrUrl, { sessionId, readonly, scale = 2, color = true } = {}) {
+  // quietZone=4 (minimo da spec) + scale=2: cada modulo fica 2 chars de largura
+  // x 2 meias-linhas de altura (bloco cheio) => QUADRADO e 2x maior que
+  // scale=1. Camera de celular le bem melhor de perto e de longe. Nunca
+  // "estica": largura e altura escalam juntas.
+  //
+  // color=true forca preto-no-branco em cores ANSI: camera de celular costuma
+  // NAO decodificar QR invertido (claro no fundo escuro do terminal), entao
+  // sem isso o codigo muitas vezes simplesmente nao e lido.
+  const lines = qr.toAscii(qrUrl, { quietZone: 4, scale, color }).split("\n");
+  const width = Math.max(...lines.map(visibleLen), qrUrl.length);
+  const bar = "─".repeat(width + 2);
+  const out = [];
+  out.push(`┌${bar}┐`);
+  out.push("│" + "  Escaneie com a câmera do celular".padEnd(width + 2) + "│");
+  out.push(`│${" ".repeat(width + 2)}│`);
+  for (const line of lines) out.push("│ " + line + " ".repeat(Math.max(0, width - visibleLen(line))) + " │");
+  out.push(`│${" ".repeat(width + 2)}│`);
+  out.push("│ " + qrUrl.padEnd(width) + " │");
+  out.push(
+    "│ " +
+      `sessão ${sessionId || "?"}${readonly ? " · somente leitura" : ""} · expira em 120s`.padEnd(width) +
+      " │"
+  );
+  out.push(`└${bar}┘`);
+  return out;
+}
+
+/**
+ * Sobe o servidor mobile preso a um `bridge` qualquer (TuiBridge ou
+ * SessionBridge). Devolve { server, pairing, port, base, qrUrl, watch }.
+ *
+ * Usa fallback de porta: se a porta pedida estiver ocupada, tenta as seguintes
+ * (7789, 7790…) em vez de estourar EADDRINUSE — assim varios `kafox mobile`
+ * podem coexistir.
+ */
+function serveBridge({ bridge, port = DEFAULT_PORT, lan = false, publicUrl, register = true, readonly = false, log = null }) {
+  const pairing = new PairingManager();
+  const { server } = createMobileServer({ bridge, pairing });
+  const host = lan ? "0.0.0.0" : "127.0.0.1";
+
+  return listenWithFallback(server, { port, host }).then((usedPort) => {
+    // Base publica:
+    //  - --lan: IP da maquina (teste local na rede);
+    //  - publicUrl explicito (--public-url): usa o que o usuario mandou;
+    //  - porta base 7788: o dominio principal https://web.kafox.dev;
+    //  - porta extra (fallback p/ varias sessoes): MESMA URL, com path
+    //    https://web.kafox.dev/s/<porta>, que o Caddy roteia pra
+    //    127.0.0.1:<porta> (strip_prefix). Assim um so cert serve tudo.
+    let base;
+    if (lan) base = `http://${pickLanIP()}:${usedPort}`;
+    else if (publicUrl) base = String(publicUrl).replace(/\/$/, "");
+    else if (usedPort === DEFAULT_PORT) base = DEFAULT_PUBLIC;
+    else base = `${DEFAULT_PUBLIC}/s/${usedPort}`;
+
+    const code = pairing.issueCode();
+    const qrUrl = `${base}/#p=${code}`;
+    let sessionKey = null;
+    if (register) {
+      try {
+        sessionKey = authStore.registerSession({
+          port: usedPort,
+          sessionId: bridge.sessionId,
+          base,
+          readonly,
+          log,
+        });
+      } catch {
+        /* registro best-effort */
+      }
+    }
+    return { server, pairing, port: usedPort, base, qrUrl, sessionKey };
+  });
+}
+
+/** Redireciona o console para nao colidir com o desenho da TUI. */
+function quietConsole() {
+  const noop = () => {};
+  const saved = { log: console.log, warn: console.warn, error: console.error };
+  console.log = console.warn = console.error = noop;
+  return () => {
+    console.log = saved.log;
+    console.warn = saved.warn;
+    console.error = saved.error;
+  };
+}
+
+/**
+ * Modo hospedado: chamado de dentro da TUI. Sobe o servidor e mostra o QR em
+ * um modal. Nao bloqueia o terminal — a interface continua usavel e o celular
+ * entra na mesma sessao.
+ */
+async function attachMobile({ state, api, options = {}, print } = {}) {
+  const bridge = new TuiBridge({
+    state,
+    api,
+    sessionId: state.sessionId,
+    cwd: process.cwd(),
+    readonly: Boolean(options.readonly),
+  });
+  bridge.start();
+
+  const { server, pairing, base, qrUrl, sessionKey } = await serveBridge({
+    bridge,
+    port: options.port || DEFAULT_PORT,
+    lan: Boolean(options.lan),
+    publicUrl: options.publicUrl,
+    readonly: Boolean(options.readonly),
+  });
+
+  const panel = qrPanel(qrUrl, { sessionId: state.sessionId, readonly: options.readonly });
+  const title = "kafox mobile";
+  const lines = [
+    `servidor em ${base}`,
+    "",
+    ...panel,
+    "",
+    "aguardando pareamento… (Ctrl+C encerra)",
+  ];
+  print ? print(lines) : console.log(`${title}\n${lines.join("\n")}`);
+
+  // Avisa no modal (se ainda estiver mostrando o QR) quando o celular pareia.
+  const watcher = setInterval(() => {
+    if (pairing.activeTokens() > 0) {
+      clearInterval(watcher);
+      if (state.modal?.title === title) {
+        state.modal = {
+          title,
+          text: [`✓ celular pareado — abra ${base}`, "", "kafox mobile rodando; Ctrl+C encerra."].join("\n"),
+        };
+      }
+    }
+  }, 600);
+  watcher.unref?.();
+
+  const shutdown = () => {
+    bridge.stop();
+    if (sessionKey) authStore.unregisterSession(sessionKey);
+    try {
+      server.close();
+    } catch {
+      /* ja fechado */
+    }
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+
+  return { bridge, server, pairing, base, qrUrl, sessionKey, stop: shutdown };
+}
+
+/**
+ * Entry do `kafox mobile` headless: escolhe a conversa (seletor igual ao
+ * resume quando nao vem codigo), monta o bridge e sobe o servidor. Nao abre a TUI.
+ */
+async function runMobile({
+  code = null,
+  port = DEFAULT_PORT,
+  lan = false,
+  publicUrl,
+  allowAll = false,
+  readonly = false,
+} = {}) {
+  let resolved = code;
+  if (!resolved && process.stdin.isTTY) {
+    resolved = await chooseSession();
+  }
+
+  let saved = null;
+  if (resolved === "last") saved = sessions.latest();
+  else if (resolved) saved = sessions.find(resolved);
+
+  const bridge = new SessionBridge({
+    cwd: process.cwd(),
+    sessionId: saved?.id || sessions.newId(),
+    sessionStartedAt: saved?.startedAt || new Date().toISOString(),
+    messages: saved?.messages || [],
+    context: saved?.context || [],
+    model: saved?.model || null,
+    allowAll: allowAll || Boolean(saved?.allowAll),
+  });
+
+  if (saved) console.log(chalk.dim(`  retomando: ${chalk.bold(saved.title || saved.id)} ${chalk.dim(saved.id)}`));
+  else console.log(chalk.dim("  nova conversa"));
+
+  // Log em arquivo para o `kafox mobile log <id>` funcionar tambem em
+  // primeiro plano (o daemon ja redireciona via KAFOX_MOBILE_LOG).
+  const logFile = process.env.KAFOX_MOBILE_LOG || path.join(os.homedir(), ".kafox", `mobile-${process.pid}.log`);
+  const daemon = Boolean(process.env.KAFOX_MOBILE_LOG); // daemon ja redireciona stdout
+  function note(line) {
+    if (daemon) return; // o redirect do daemon grava tudo; evita duplicar
+    try {
+      fs.appendFileSync(logFile, line.replace(/\x1b\[[0-9;]*m/g, "") + "\n");
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  const { server, pairing, base, qrUrl, sessionKey } = await serveBridge({
+    bridge,
+    port,
+    lan,
+    publicUrl,
+    readonly,
+    log: logFile,
+  });
+  console.log("");
+  note("");
+  for (const line of qrPanel(qrUrl, { sessionId: bridge.sessionId, readonly })) {
+    console.log(chalk.cyan(line));
+    note(line);
+  }
+  const tail = `  servidor em ${base}  ·  aguardando pareamento…  (Ctrl+C sai)`;
+  console.log(chalk.dim(`\n${tail}\n`));
+  note(tail);
+
+  await new Promise((resolve) => {
+    const shutdown = () => {
+      pairing.audit("shutdown", {});
+      bridge.save();
+      if (sessionKey) authStore.unregisterSession(sessionKey);
+      server.close(() => resolve());
+      setTimeout(resolve, 700).unref?.();
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+}
+
+/**
+ * `kafox mobile list`: lista os servidores mobile de pe (do registro em disco),
+ * marcando os que ainda tem processo vivo.
+ */
+function printMobileList() {
+  const list = authStore.listSessions();
+  if (!list.length) {
+    console.log(chalk.dim("Nenhum servidor `kafox mobile` ativo."));
+    console.log(chalk.dim("Suba um com:  kafox mobile"));
+    return;
+  }
+  console.log(chalk.bold("\n  Servidores mobile ativos\n"));
+  const now = Date.now();
+  for (const s of list) {
+    const age = Math.max(0, Math.round((now - (s.startedAt || now)) / 1000));
+    const ago = age < 60 ? `${age}s` : age < 3600 ? `${Math.round(age / 60)}min` : `${Math.round(age / 3600)}h`;
+    const state = s.alive ? chalk.green("● ativo") : chalk.red("○ morto");
+    console.log(
+      `  ${state}  ${chalk.cyan(String(s.id).padEnd(8))}  porta ${String(s.port).padEnd(5)}  ` +
+        `sessão ${chalk.dim(s.sessionId || "?")}  ${chalk.dim(`há ${ago}`)}`
+    );
+    if (s.base) console.log(chalk.dim(`           ${s.base}${s.readonly ? "  (somente leitura)" : ""}`));
+  }
+  console.log(chalk.dim("\n  Encerrar:  kafox mobile kill <id>   (ou `kafox mobile kill all`)"));
+  console.log(chalk.dim("  Ver QR:    kafox mobile log <id>\n"));
+}
+
+/**
+ * `kafox mobile kill <id|all>`: encerra o(s) servidor(es) pelo PID registrado.
+ * `all` mata todos. Sem argumento, pergunta (quando interativo).
+ */
+async function killMobileSessions(target) {
+  let list = authStore.listSessions();
+  if (!list.length) {
+    console.log(chalk.dim("Nenhum servidor `kafox mobile` ativo."));
+    return;
+  }
+
+  let chosen = null;
+  if (!target) {
+    if (!process.stdin.isTTY) {
+      console.log(chalk.yellow("Informe o id (ou `all`):  kafox mobile kill <id|all>"));
+      printMobileList();
+      return;
+    }
+    const { picked } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "picked",
+        message: "Encerrar qual servidor mobile?",
+        choices: [
+          { name: chalk.red("✕ todos"), value: "__all__" },
+          ...list.map((s) => ({
+            name: `${s.alive ? chalk.green("●") : chalk.red("○")} ${s.id}  porta ${s.port}  ${s.sessionId || "?"}`,
+            value: s.id,
+          })),
+        ],
+      },
+    ]);
+    chosen = picked;
+  } else {
+    chosen = String(target);
+  }
+
+  const targets =
+    chosen === "all" || chosen === "__all__"
+      ? list
+      : list.filter((s) => s.id === chosen || String(s.id).startsWith(chosen));
+
+  if (!targets.length) {
+    console.log(chalk.yellow(`Nenhum servidor mobile com id "${chosen}".`));
+    return;
+  }
+
+  for (const s of targets) {
+    let killed = false;
+    if (s.alive) {
+      try {
+        process.kill(s.pid, "SIGTERM");
+        killed = true;
+      } catch (error) {
+        console.log(chalk.red(`  não deu pra encerrar ${s.id} (pid ${s.pid}): ${error.message}`));
+      }
+    }
+    authStore.unregisterSession(s.id);
+    console.log(
+      killed
+        ? chalk.green(`  ✓ encerrado ${s.id}  (pid ${s.pid}, porta ${s.port})`)
+        : chalk.dim(`  • ${s.id} já estava morto (registro limpo)`)
+    );
+  }
+}
+
+/**
+ * `kafox mobile --daemon`: relanca o fluxo mobile em background (detached) e
+ * devolve o terminal. O filho:
+ *   - e destacado com setsid (sobrevive ao fechar o SSH/terminal);
+ *   - tem stdout/stderr redirecionados para ~/.kafox/mobile-<pid>.log;
+ *   - grava PID/porta/sessao no registro (mobile-sessions.json) via serveBridge,
+ *     entao `kafox mobile list` / `kill` / `log` o encontram.
+ *
+ * Reconstroi o argv a partir das opcoes (sem a flag -d) porque o filho roda o
+ * comando normal, em primeiro plano, mas destacado do terminal.
+ */
+function spawnMobileDaemon({
+  code = null,
+  port,
+  lan = false,
+  publicUrl,
+  readonly = false,
+  allowAll = false,
+} = {}) {
+  const { spawn } = require("child_process");
+  const fs = require("fs");
+  const path = require("path");
+
+  const bin = path.join(__dirname, "..", "..", "bin", "kafox.js");
+  const args = [bin, "mobile"];
+
+  // Repassa o alvo: 'last', codigo da conversa, ou nada (-> seletor nao roda
+  // em daemon porque nao ha TTY; nesse caso o filho cai em conversa nova).
+  if (code === "last") args.push("--last");
+  else if (code) args.push(code);
+
+  if (port) args.push("--port", String(port));
+  if (lan) args.push("--lan");
+  if (publicUrl) args.push("--public-url", publicUrl);
+  if (readonly) args.push("--readonly");
+  if (allowAll) args.push("-y");
+
+  // O daemon nao tem TTY: o runMobile nao deve tentar abrir o seletor.
+  const logDir = path.join(os.homedir(), ".kafox");
+  try {
+    fs.mkdirSync(logDir, { recursive: true });
+  } catch {
+    /* ok */
+  }
+  // Nome do log inclui o timestamp pra nao sobrescrever sessoes antigas; o
+  // mapa pid->log fica no registro (campo log). Aqui usamos um sufixo curto.
+  const stamp = Date.now().toString(36);
+  const logFile = path.join(logDir, `mobile-${stamp}.log`);
+  const out = fs.openSync(logFile, "a");
+
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: ["ignore", out, out],
+    env: { ...process.env, KAFOX_MOBILE_DAEMON: "1", KAFOX_MOBILE_LOG: logFile },
+    cwd: process.cwd(),
+  });
+  child.unref();
+
+  console.log(chalk.green(`  ✓ kafox mobile rodando em background  (pid ${child.pid})`));
+  console.log(chalk.dim(`    porta/log: ~/.kafox/${path.basename(logFile)}`));
+  console.log(chalk.dim(`    veja o QR depois com:  ${chalk.bold(`kafox mobile log ${child.pid}`)}`));
+  console.log(chalk.dim(`    encerrar:  ${chalk.bold(`kafox mobile kill ${child.pid}`)}  (ou kill all)`));
+  return child.pid;
+}
+
+/**
+ * `kafox mobile log <id>` (alias `qr`): reimprime o QR/URL de um servidor
+ * mobile em execucao, pra parear mais um celular. Se nao achar no registro,
+ * mostra o log bruto do processo (util pra ver erro de subida).
+ */
+function printMobileLog(id) {
+  const fs = require("fs");
+  const path = require("path");
+  const list = authStore.listSessions();
+
+  let entry = null;
+  if (id) {
+    entry =
+      list.find((s) => String(s.id) === String(id)) ||
+      list.find((s) => String(s.id).startsWith(String(id)));
+  } else if (list.length === 1) {
+    entry = list[0];
+  } else if (list.length > 1) {
+    console.log(chalk.yellow("Há mais de um servidor ativo. Informe o id:\n"));
+    printMobileList();
+    return;
+  }
+
+  if (!entry) {
+    console.log(chalk.dim("Nenhum servidor `kafox mobile` ativo com esse id."));
+    return;
+  }
+
+  const logFile = entry.log || null;
+  if (logFile && fs.existsSync(logFile)) {
+    const text = fs.readFileSync(logFile, "utf8");
+    // Reproduz as ultimas linhas do log, onde fica o QR do pareamento.
+    const lines = text.split("\n").filter(Boolean).slice(-40).join("\n");
+    console.log(chalk.dim(`── log de ${entry.id} (porta ${entry.port}) ──\n`));
+    console.log(lines);
+  } else {
+    console.log(chalk.dim(`servidor ${entry.id} na porta ${entry.port} · ${entry.base || ""}`));
+    console.log(chalk.dim("(log nao encontrado; use `kafox mobile list` para os detalhes)"));
+  }
+}
+
+module.exports = {
+  attachMobile,
+  runMobile,
+  serveBridge,
+  qrPanel,
+  visibleLen,
+  chooseSession,
+  quietConsole,
+  printMobileList,
+  killMobileSessions,
+  spawnMobileDaemon,
+  printMobileLog,
+  DEFAULT_PORT,
+  DEFAULT_PUBLIC,
+};

package/src/mobile/protocol.js

@@ -0,0 +1,51 @@
+/**
+ * Protocolo do kafox mobile: envelope de eventos com sequencia (seq) e um
+ * ring buffer para replay no reconnect.
+ *
+ * Por que seq + buffer: o celular dorme, troca Wi-Fi/4G e o SSE cai. Quando ele
+ * volta, manda `?since=<ultimoSeq>` e recebe so o que perdeu, em vez de perder
+ * o turno inteiro (ou ter que recarregar o historico).
+ *
+ * Envelope (sempre JSON em uma linha):
+ *   { seq, type, at, ...payload }
+ */
+
+const RING_SIZE = 500;
+
+class EventLog {
+  constructor(size = RING_SIZE) {
+    this.size = size;
+    this.seq = 0;
+    this.buffer = [];
+    this.listeners = new Set();
+  }
+
+  /** Registra um evento, guarda no ring buffer e entrega aos assinantes. */
+  push(type, payload = {}) {
+    this.seq += 1;
+    const event = { seq: this.seq, type, at: Date.now(), ...payload };
+    this.buffer.push(event);
+    if (this.buffer.length > this.size) this.buffer.shift();
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+        // um cliente com erro nao derruba os outros nem a sessao.
+      }
+    }
+    return event;
+  }
+
+  /** Eventos a partir de um seq (exclusivo), para replay no reconnect. */
+  since(seq = 0) {
+    if (!seq) return this.buffer.slice();
+    return this.buffer.filter((event) => event.seq > seq);
+  }
+
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+}
+
+module.exports = { EventLog, RING_SIZE };