kafox-cli 0.9.9 → 0.10.0

package/src/gateway.js

@@ -1,6 +1,7 @@
 const chalk = require("chalk");
 const storage = require("./storage");
 const { ensureSession, fetchApi } = require("./auth");
+const { providerForModel } = require("./providers");
 
 /**
  * Modelo do free tier: o nome carrega o sufixo " (free)" (ou ":free"). Esses
@@ -11,8 +12,10 @@ function isFreeModel(model) {
 }
 
 /**
- * Garante sessao, saldo, modelo e chave antes de qualquer chamada.
- * A chave `kafox_live_...` e da propria conta: o gateway cobra por ela.
+ * Garante sessao, saldo, modelo e chave antes de qualquer chamada ao gateway
+ * kafox. A chave `kafox_live_...` e da propria conta: o gateway cobra por ela.
+ * Provedores alternativos (OpenAI-compatible) tem seu proprio caminho em
+ * `attemptOpenAI`: nao passam por login/saldo, so precisam da chave do provedor.
  */
 async function ensureReady(options = {}) {
   const token = await ensureSession();
@@ -133,48 +136,10 @@ function errorFrom(data, status) {
 }
 
 /**
- * Uma tentativa: request + leitura do stream.
- * Devolve `retryable` quando o erro foi de rede/servidor e ainda nao veio texto.
+ * Le um stream SSE de chat completions (OpenAI-compatible) e chama os
+ * callbacks a cada delta. Devolve o resultado final.
  */
-async function attemptChat({ messages, model, tools, onDelta, onReasoning, signal } = {}) {
-  const ready = await ensureReady({ model });
-  if (!ready.ok) return ready;
-
-  const started = Date.now();
-  let response;
-  try {
-    response = await fetchApi("/api/chat", {
-      method: "POST",
-      headers: { accept: "text/event-stream" },
-      body: JSON.stringify({
-        api_key: ready.apiKey,
-        model: ready.model,
-        messages,
-        tools: tools && tools.length ? tools : undefined,
-        stream: true,
-      }),
-      signal,
-    });
-  } catch (error) {
-    if (error?.name === "AbortError") return { ok: false, code: "aborted", error: "Cancelado." };
-    return {
-      ok: false,
-      error: `Falha de rede: ${error.message}`,
-      retryable: retryableMessage(error.message),
-      keyCreated: ready.keyCreated,
-    };
-  }
-
-  if (!response.ok) {
-    const data = await response.json().catch(() => ({}));
-    return {
-      ...errorFrom(data, response.status),
-      status: response.status,
-      keyCreated: ready.keyCreated,
-      retryable: RETRYABLE_STATUS.has(response.status),
-    };
-  }
-
+async function readStream({ response, started, onDelta, onReasoning }) {
   const decoder = new TextDecoder();
   let buffer = "";
   let text = "";
@@ -238,16 +203,114 @@ async function attemptChat({ messages, model, tools, onDelta, onReasoning, signa
     };
   }
 
-  return {
-    ok: true,
-    text,
-    reasoning,
-    toolCalls: toolCalls.filter(Boolean),
-    usage,
-    ms: Date.now() - started,
-    model: ready.model,
-    keyCreated: ready.keyCreated,
-  };
+  return { ok: true, text, reasoning, toolCalls: toolCalls.filter(Boolean), usage, ms: Date.now() - started };
+}
+
+/**
+ * Uma tentativa no provedor kafox (gateway proprio): login/saldo/chave da conta
+ * e POST em `/api/chat`.
+ */
+async function attemptChat({ messages, model, tools, onDelta, onReasoning, signal } = {}) {
+  const socket = providerForModel(model);
+  if (socket.provider.kind === "openai") {
+    return attemptOpenAI({ messages, model: socket.model, provider: socket.provider, tools, onDelta, onReasoning, signal });
+  }
+
+  const ready = await ensureReady({ model });
+  if (!ready.ok) return ready;
+
+  const started = Date.now();
+  let response;
+  try {
+    response = await fetchApi("/api/chat", {
+      method: "POST",
+      headers: { accept: "text/event-stream" },
+      body: JSON.stringify({
+        api_key: ready.apiKey,
+        model: ready.model,
+        messages,
+        tools: tools && tools.length ? tools : undefined,
+        stream: true,
+      }),
+      signal,
+    });
+  } catch (error) {
+    if (error?.name === "AbortError") return { ok: false, code: "aborted", error: "Cancelado." };
+    return {
+      ok: false,
+      error: `Falha de rede: ${error.message}`,
+      retryable: retryableMessage(error.message),
+      keyCreated: ready.keyCreated,
+    };
+  }
+
+  if (!response.ok) {
+    const data = await response.json().catch(() => ({}));
+    return {
+      ...errorFrom(data, response.status),
+      status: response.status,
+      keyCreated: ready.keyCreated,
+      retryable: RETRYABLE_STATUS.has(response.status),
+    };
+  }
+
+  const result = await readStream({ response, started, onDelta, onReasoning });
+  return { ...result, model: ready.model, keyCreated: ready.keyCreated };
+}
+
+/**
+ * Uma tentativa num provedor OpenAI-compatible: POST direto em
+ * `{baseUrl}/chat/completions` com a chave do usuario. Sem login/saldo da conta
+ * kafox; o custo e cobrado pelo proprio provedor.
+ */
+async function attemptOpenAI({ messages, model, provider, tools, onDelta, onReasoning, signal } = {}) {
+  const apiKey = storage.getProviderKey(provider.id);
+  if (!apiKey) {
+    return {
+      ok: false,
+      code: "no_provider_key",
+      error: `Provedor ${provider.label} sem chave. Rode: kafox key ${provider.id} <chave>`,
+    };
+  }
+
+  const started = Date.now();
+  let response;
+  try {
+    response = await fetch(`${provider.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        accept: "text/event-stream",
+        authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        messages,
+        tools: tools && tools.length ? tools : undefined,
+        stream: true,
+      }),
+      signal,
+    });
+  } catch (error) {
+    if (error?.name === "AbortError") return { ok: false, code: "aborted", error: "Cancelado." };
+    return {
+      ok: false,
+      error: `Falha de rede: ${error.message}`,
+      retryable: retryableMessage(error.message),
+    };
+  }
+
+  if (!response.ok) {
+    const data = await response.json().catch(() => ({}));
+    return {
+      ...errorFrom(data, response.status),
+      status: response.status,
+      retryable: RETRYABLE_STATUS.has(response.status),
+    };
+  }
+
+  const result = await readStream({ response, started, onDelta, onReasoning });
+  return { ...result, model, provider: provider.id };
 }
 
 /**
@@ -324,6 +387,9 @@ module.exports = {
   askModel,
   chat,
   ensureReady,
+  attemptChat,
+  attemptOpenAI,
+  readStream,
   isFreeModel,
   mergeToolCalls,
   backoffMs,

package/src/mobile/auth.js

@@ -0,0 +1,352 @@
+/**
+ * Pareamento do kafox mobile.
+ *
+ * Fluxo (seguro por construcao):
+ *   1. a CLI gera um `pair_code` curto, valido por 120s, de uso unico;
+ *   2. o QR carrega SO esse codigo — nunca o token de sessao;
+ *   3. o celular troca o codigo por um `session_token` (12h) via POST /pair;
+ *   4. todas as rotas seguintes exigem o token no header `x-kafox-token`.
+ *
+ * O codigo e o token sao guardados apenas como SHA-256 em memoria (o par do
+ * arquivo de auditoria guarda so o hash, nunca o valor em claro).
+ */
+
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const PAIR_TTL_MS = 120_000;
+const TOKEN_TTL_MS = 12 * 60 * 60 * 1000;
+const ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"; // base32 sem 0/O/1/I
+
+function randomCode(length = 8) {
+  const bytes = crypto.randomBytes(length);
+  let out = "";
+  for (let i = 0; i < length; i += 1) out += ALPHABET[bytes[i] % ALPHABET.length];
+  return out;
+}
+
+function sha256(value) {
+  return crypto.createHash("sha256").update(String(value)).digest("hex");
+}
+
+// Registro dos pareamentos em disco: { hash(token): { createdAt, expiresAt, device } }.
+// Guarda so o SHA-256 do token (nunca o valor em claro), para o `--revoke`
+// funcionar mesmo depois de reiniciar o CLI.
+const SESSIONS_FILE =
+  process.env.KAFOX_MOBILE_SESSIONS || path.join(os.homedir(), ".kafox", "mobile-sessions.json");
+
+function loadSessions() {
+  try {
+    const raw = fs.readFileSync(SESSIONS_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function saveSessions(sessions) {
+  try {
+    fs.mkdirSync(path.dirname(SESSIONS_FILE), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(SESSIONS_FILE, JSON.stringify(sessions, null, 2), { mode: 0o600 });
+  } catch {
+    // persistencia nao pode derrubar o pareamento.
+  }
+}
+
+/**
+ * Revoga os pareamentos salvos em disco. `{ all: true }` limpa tudo e devolve
+ * quantos foram removidos. `{ token }` remove so o hash daquele token.
+ */
+function isTokenEntry(entry) {
+  // entradas de servidor tem kind:"server"; as antigas (sem kind) sao tokens.
+  return entry && entry.kind !== "server";
+}
+
+function revoke({ all = false, token = null } = {}) {
+  const sessions = loadSessions();
+  if (all) {
+    let count = 0;
+    for (const key of Object.keys(sessions)) {
+      // NAO apaga entradas de servidor (kind:"server") — elas nao sao pareamento.
+      if (isTokenEntry(sessions[key])) {
+        delete sessions[key];
+        count += 1;
+      }
+    }
+    saveSessions(sessions);
+    return count;
+  }
+  if (token) {
+    const hash = sha256(token);
+    if (!sessions[hash] || !isTokenEntry(sessions[hash])) return 0;
+    delete sessions[hash];
+    saveSessions(sessions);
+    return 1;
+  }
+  // sem alvo: limpa os que ja expiraram (apenas pareamentos).
+  const now = Date.now();
+  let removed = 0;
+  for (const key of Object.keys(sessions)) {
+    const entry = sessions[key];
+    if (!isTokenEntry(entry)) continue;
+    if (now > (entry?.expiresAt || 0)) {
+      delete sessions[key];
+      removed += 1;
+    }
+  }
+  if (removed) saveSessions(sessions);
+  return removed;
+}
+
+class PairingManager {
+  constructor({ auditLog = path.join(os.homedir(), ".kafox", "audit.log") } = {}) {
+    this.auditLog = auditLog;
+    this.pending = new Map(); // hash(pair_code) -> { createdAt, expiresAt, claims }
+    // Tokens pareados: carrega do disco (so o hash) e marca como ativos.
+    this.tokens = new Map();
+    const saved = loadSessions();
+    const now = Date.now();
+    for (const [hash, entry] of Object.entries(saved)) {
+      if (!isTokenEntry(entry)) continue; // pula entradas de servidor.
+      if (entry && now < (entry.expiresAt || 0)) this.tokens.set(hash, entry);
+    }
+    this.currentCode = null;
+    this.currentCodeHash = null;
+  }
+
+  /**
+   * Persiste o mapa de tokens (apenas hashes) no arquivo de sessoes,
+   * PRESERVANDO as entradas de servidor (kind:"server") ja registradas.
+   */
+  persistTokens() {
+    const out = {};
+    for (const [key, entry] of Object.entries(loadSessions())) {
+      if (isServerEntry(entry)) out[key] = entry;
+    }
+    for (const [hash, entry] of this.tokens) out[hash] = entry;
+    saveSessions(out);
+  }
+
+  /** Gera um par codigo+hash, expira o anterior e devolve o codigo em claro. */
+  issueCode() {
+    const code = randomCode(8);
+    const hash = sha256(code);
+    // um pareamento por vez: o codigo novo invalida o anterior.
+    if (this.currentCodeHash) this.pending.delete(this.currentCodeHash);
+    this.pending.set(hash, {
+      createdAt: Date.now(),
+      expiresAt: Date.now() + PAIR_TTL_MS,
+      claims: 0,
+    });
+    this.currentCode = code;
+    this.currentCodeHash = hash;
+    return code;
+  }
+
+  get expiresAt() {
+    const entry = this.currentCodeHash ? this.pending.get(this.currentCodeHash) : null;
+    return entry ? entry.expiresAt : 0;
+  }
+
+  /** True se o codigo e valido, nao expirou e nao foi usado. */
+  validateCode(code) {
+    const entry = this.pending.get(sha256(code));
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.pending.delete(sha256(code));
+      return false;
+    }
+    return true;
+  }
+
+  /** Troca um pair_code valido por um token de sessao. Uso unico. */
+  claim(code, device = {}) {
+    const hash = sha256(code);
+    const entry = this.pending.get(hash);
+    if (!entry || Date.now() > entry.expiresAt) return null;
+    // single-use: consome o codigo do servidor.
+    this.pending.delete(hash);
+    if (this.currentCodeHash === hash) this.currentCode = null;
+
+    const token = crypto.randomBytes(32).toString("hex");
+    this.tokens.set(sha256(token), {
+      createdAt: Date.now(),
+      expiresAt: Date.now() + TOKEN_TTL_MS,
+      code,
+      device,
+    });
+    this.persistTokens();
+    this.audit("pair", { device, codeHash: hash.slice(0, 12) });
+    return { token, expiresAt: Date.now() + TOKEN_TTL_MS };
+  }
+
+  /** True se o token de sessao existe e nao expirou. */
+  validateToken(token) {
+    if (!token) return false;
+    const entry = this.tokens.get(sha256(token));
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.tokens.delete(sha256(token));
+      return false;
+    }
+    return true;
+  }
+
+
+
+/** Revoga tudo (usado por `kafox mobile --revoke`). */
+  revokeAll() {
+    const count = this.tokens.size;
+    this.tokens.clear();
+    this.pending.clear();
+    this.currentCode = null;
+    this.currentCodeHash = null;
+    // preserva servidores registrados; apaga so os pareamentos.
+    const registry = loadSessions();
+    for (const key of Object.keys(registry)) {
+      if (isTokenEntry(registry[key])) delete registry[key];
+    }
+    saveSessions(registry);
+    this.audit("revoke-all", { tokens: count });
+    return count;
+  }
+
+  activeTokens() {
+    const now = Date.now();
+    for (const [hash, entry] of [...this.tokens]) if (now > entry.expiresAt) this.tokens.delete(hash);
+    return this.tokens.size;
+  }
+
+  audit(action, meta = {}) {
+    try {
+      fs.mkdirSync(path.dirname(this.auditLog), { recursive: true, mode: 0o700 });
+      fs.appendFileSync(
+        this.auditLog,
+        `${JSON.stringify({ at: new Date().toISOString(), action, ...meta })}\n`,
+        { mode: 0o600 }
+      );
+    } catch {
+      // auditoria nao pode quebrar o pareamento.
+    }
+  }
+}
+
+/**
+ * Sessao mobile ativa: representa UM servidor `kafox mobile` de pe.
+ *
+ * O arquivo `mobile-sessions.json` guarda dois tipos de entrada (discriminadas
+ * pelo campo `kind`):
+ *   - `kind: "token"`   -> pareamento do celular (hash -> { createdAt, ... }).
+ *   - `kind: "server"`  -> servidor rodando (id -> { pid, port, sessionId, ... }).
+ *
+ * Entradas antigas (sem `kind`) sao tratadas como token, para nao perder os
+ * pareamentos ja existentes.
+ */
+const SERVER_STATE_FILE =
+  process.env.KAFOX_MOBILE_SESSIONS || path.join(os.homedir(), ".kafox", "mobile-sessions.json");
+
+function isServerEntry(entry) {
+  return entry && entry.kind === "server";
+}
+
+/** Le o registro bruto (tokens + servidores). */
+function readRegistry() {
+  return loadSessions();
+}
+
+/** Grava o registro bruto. */
+function writeRegistry(registry) {
+  saveSessions(registry);
+}
+
+/** True se o processo `pid` esta vivo (sinal 0). */
+function pidAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM = existe mas sem permissao; tratar como vivo.
+    return error.code === "EPERM";
+  }
+}
+
+/**
+ * Registra um servidor `kafox mobile` no disco. Id estavel = pid.
+ * Devolve o id usado.
+ */
+function registerSession({ id = null, pid = process.pid, port, sessionId, base, readonly, log = null } = {}) {
+  const registry = readRegistry();
+  const key = String(id || pid);
+  registry[key] = {
+    kind: "server",
+    id: key,
+    pid: Number(pid),
+    port: Number(port),
+    sessionId: sessionId || null,
+    base: base || null,
+    readonly: Boolean(readonly),
+    log: log || process.env.KAFOX_MOBILE_LOG || null,
+    startedAt: Date.now(),
+  };
+  writeRegistry(registry);
+  return key;
+}
+
+/** Remove um servidor do registro. Devolve true se algo foi removido. */
+function unregisterSession(id) {
+  const registry = readRegistry();
+  const key = String(id);
+  if (!registry[key] || !isServerEntry(registry[key])) return false;
+  delete registry[key];
+  writeRegistry(registry);
+  return true;
+}
+
+/**
+ * Lista os servidores registrados. Marca `alive` conforme o PID e poda os que
+ * ja morreram (limpeza do registro). Devolve array ordenado por start.
+ */
+function listSessions({ prune = true } = {}) {
+  const registry = readRegistry();
+  const out = [];
+  let changed = false;
+  for (const [key, entry] of Object.entries(registry)) {
+    if (!isServerEntry(entry)) continue;
+    const alive = pidAlive(entry.pid);
+    if (!alive && prune) {
+      delete registry[key];
+      changed = true;
+      continue;
+    }
+    out.push({ ...entry, alive });
+  }
+  if (changed) writeRegistry(registry);
+  out.sort((a, b) => (a.startedAt || 0) - (b.startedAt || 0));
+  return out;
+}
+
+/** Encontra um servidor pelo id (ou pelo prefixo do id). */
+function findSession(id) {
+  const needle = String(id);
+  const all = listSessions({ prune: false });
+  return all.find((s) => s.id === needle) || all.find((s) => s.id.startsWith(needle)) || null;
+}
+
+module.exports = {
+  PairingManager,
+  PAIR_TTL_MS,
+  TOKEN_TTL_MS,
+  revoke,
+  loadSessions,
+  saveSessions,
+  // registro de servidores `kafox mobile` (list/kill)
+  registerSession,
+  unregisterSession,
+  listSessions,
+  findSession,
+  pidAlive,
+};