kafox-cli 0.3.0 → 0.7.0

package/src/auth.js

@@ -20,12 +20,11 @@ async function ensureSession() {
   return null;
 }
 
+/**
+ * Login por device code. Com TTY abre a tela cheia (logo grande, link no meio);
+ * sem TTY (pipe/CI) mantem o fluxo de texto, que continua funcionando.
+ */
 async function login() {
-  console.log(MASCOT);
-  console.log(
-    chalk.cyan("  Kafox CLI - login by device code (SSO)\n")
-  );
-
   const res = await fetchApi("/api/cli/device", {
     method: "POST",
     body: "{}",
@@ -36,10 +35,15 @@ async function login() {
     return;
   }
 
-  console.log(
-    chalk.bold("\n  Open this URL in your browser to approve:\n") +
-    chalk.cyan(`    ${storage.getApiUrl()}/cli?code=${data.user_code}\n`)
-  );
+  const url = `${storage.getApiUrl()}/cli?code=${data.user_code}`;
+
+  if (process.stdout.isTTY && process.stdin.isTTY) {
+    return loginWithScreen({ url, data });
+  }
+
+  console.log(MASCOT);
+  console.log(chalk.cyan("  Kafox CLI - login by device code (SSO)\n"));
+  console.log(chalk.bold("  Open this URL in your browser to approve:\n") + chalk.cyan(`    ${url}\n`));
   console.log(`  Code: ${chalk.bold(data.user_code)}  (expires in ${data.expires_in}s)\n`);
 
   const interval = Math.max(1, data.interval) * 1000;
@@ -50,32 +54,75 @@ async function login() {
     process.stdout.write(`\r  Waiting for approval${".".repeat(dots % 4)}   `);
     dots += 1;
     await new Promise((r) => setTimeout(r, interval));
-    try {
-      const poll = await fetchApi(`/api/cli/poll/${encodeURIComponent(data.device_code)}`);
-      const pd = await poll.json().catch(() => ({}));
-      if (poll.status === 200 && pd.status === "approved") {
-        const previous = storage.getToken() || {};
-        storage.setToken({ session: pd.session, csrf: previous.csrf });
-        console.log(
-          chalk.green("\n  Approved! Session saved to ~/.kafox/token.json")
-        );
-        return;
-      }
-      if (pd.status === "denied" || poll.status === 403) {
-        console.log(chalk.red("\n  Login denied."));
-        return;
-      }
-      if (poll.status === 404 || poll.status === 410) {
-        console.log(chalk.red("\n  Device code expired. Run `kafox login` again."));
-        return;
-      }
-    } catch {
-      // ignore transient errors, keep polling
+    const outcome = await pollDevice(data);
+    if (outcome.ok) {
+      console.log(chalk.green("\n  Approved! Session saved to ~/.kafox/token.json"));
+      return;
+    }
+    if (outcome.stop) {
+      console.log(chalk.red(`\n  ${outcome.error}`));
+      return;
     }
   }
   console.log(chalk.red("\n  Device code expired. Run `kafox login` again."));
 }
 
+/** Uma consulta do device code; grava a sessao quando aprovada. */
+async function pollDevice(data) {
+  let poll;
+  try {
+    poll = await fetchApi(`/api/cli/poll/${encodeURIComponent(data.device_code)}`);
+  } catch {
+    return { ok: false, stop: false };
+  }
+  const pd = await poll.json().catch(() => ({}));
+  if (poll.status === 200 && pd.status === "approved") {
+    const previous = storage.getToken() || {};
+    storage.setToken({ session: pd.session, csrf: previous.csrf });
+    return { ok: true, stop: true };
+  }
+  if (pd.status === "denied" || poll.status === 403) {
+    return { ok: false, stop: true, error: "Login denied." };
+  }
+  if (poll.status === 404 || poll.status === 410) {
+    return { ok: false, stop: true, error: "Device code expired. Run `kafox login` again." };
+  }
+  return { ok: false, stop: false };
+}
+
+async function loginWithScreen({ url, data }) {
+  const { runLoginScreen } = require("./login-screen");
+  const { version } = require("../package.json");
+  const theme = storage.getConfig().theme || "default";
+
+  const result = await runLoginScreen({
+    url,
+    code: data.user_code,
+    interval: data.interval,
+    expiresIn: data.expires_in,
+    theme,
+    version,
+    poll: async () => {
+      const outcome = await pollDevice(data);
+      if (outcome.ok) return { ok: true };
+      if (outcome.stop) return { ok: false, error: outcome.error };
+      return { ok: false };
+    },
+  });
+
+  if (result.ok) {
+    console.log(chalk.green("  Aprovado! Sessao salva em ~/.kafox/token.json"));
+    console.log(chalk.dim("  Bom proveito.\n"));
+    return true;
+  }
+  if (result.cancelled) {
+    console.log(chalk.dim("  Login cancelado.\n"));
+    return false;
+  }
+  console.log(chalk.red(`  ${result.error || "Nao foi possivel entrar"}.\n`));
+  return false;
+}
+
 async function logout() {
   storage.clearToken();
   console.log(chalk.green("  Session ended."));

package/src/cli.js

@@ -1,19 +1,23 @@
 const readline = require("readline");
+const os = require("os");
+const path = require("path");
 const inquirer = require("inquirer");
 const chalk = require("chalk");
 const storage = require("./storage");
 const { ensureSession, fetchApi } = require("./auth");
 const { ask } = require("./gateway");
 const { runTUI } = require("./tui");
-const { runTheme, setContentBackground, paint } = require("./theme");
-const { mascot } = require("./mascot");
+const { runTheme, setContentBackground } = require("./theme");
+const { logoText, logoLines } = require("./logo");
+
+const mascot = logoText();
 
 const { version: VERSION } = require("../package.json");
 
 const COMMANDS = {
   "/help": "show this help",
-  "/models": "list models and prices",
-  "/model": "choose the default model (picker)",
+  "/models": "escolhe o modelo (setas, mouse ou Enter)",
+  "/model": "escolhe o modelo no seletor, ou direto com /model <id>",
   "/balance": "show balance",
   "/pricing": "show recharge packages",
   "/key": "create an API key",
@@ -21,6 +25,9 @@ const COMMANDS = {
   "/logout": "end the session",
   "/whoami": "show the linked account",
   "/theme": "open theme selector",
+  "/agents": "lista os subagentes desta sessao (objetivo, ferramentas, tempo)",
+  "/mcp": "list MCP servers and tools (/mcp reload reconecta)",
+  "/allow": "aprovacao automatica nesta sessao (/allow off volta a perguntar)",
   "/background": "set background image (modal asks for URL)",
   "/clear": "clear conversation context",
   "/compact": "compact conversation context",
@@ -45,6 +52,13 @@ async function handleCommand(line) {
       for (const [key, value] of Object.entries(COMMANDS)) {
         console.log(`  ${chalk.bold(key)}  ${chalk.dim(value)}`);
       }
+      console.log(chalk.cyan("\nKeys:\n"));
+      console.log(`  ${chalk.bold("Enter")}  ${chalk.dim("manda a mensagem; durante a resposta ela entra na fila")}`);
+      console.log(`  ${chalk.bold("Esc Esc")}  ${chalk.dim("para a IA na hora (o primeiro Esc avisa)")}`);
+      console.log(`  ${chalk.bold("PgUp/PgDn")}  ${chalk.dim("ou a roda do mouse rola a conversa")}`);
+      console.log(`  ${chalk.bold("Ctrl+Y")}  ${chalk.dim("copia a ultima resposta para a area de transferencia")}`);
+      console.log(`  ${chalk.bold("F2")}  ${chalk.dim("solta o mouse para selecionar texto com o terminal")}`);
+      console.log(`  ${chalk.bold("Ctrl+C")}  ${chalk.dim("sai")}`);
       console.log("");
       return true;
     case "/models": {
@@ -94,6 +108,61 @@ async function handleCommand(line) {
     case "/theme":
       await runTheme();
       return true;
+    case "/allow": {
+      console.log(
+        chalk.dim(
+          "Na interface, /allow liga e /allow off desliga a aprovacao automatica.\n" +
+            "Para ja abrir assim: kafox --allow-all (ou KAFOX_ALLOW_ALL=1)."
+        )
+      );
+      return true;
+    }
+    case "/agents": {
+      const { listRuns } = require("./subagents");
+      const runs = listRuns();
+      if (!runs.length) {
+        console.log(chalk.dim("\nNenhum subagente nesta sessao."));
+        console.log(
+          chalk.dim(
+            "O agente abre subagentes sozinho quando dividir ajuda: objetivo proprio,\n" +
+              "ate 3 em paralelo, cada um em contexto separado. Para pedir na mao:\n" +
+              '  "lanca dois subagentes: um revisa src/agent.js e outro roda os testes do backend"'
+          )
+        );
+        return true;
+      }
+      console.log(chalk.cyan(`\nSubagentes desta sessao (${runs.length}):\n`));
+      for (const run of runs) {
+        const status = run.ok ? chalk.green("ok") : chalk.red("falhou");
+        console.log(`  ${status} ${chalk.bold(run.objective.slice(0, 90))}`);
+        console.log(
+          chalk.dim(
+            `       ${run.tools.join(", ") || "read_file"} · ${run.steps} passo(s) · ${Math.round(run.ms / 1000)}s`
+          )
+        );
+      }
+      console.log("");
+      return true;
+    }
+    case "/mcp": {
+      const { McpHub } = require("./mcp");
+      const hub = new McpHub({ cwd: process.cwd() });
+      const statuses = hub.statuses();
+      hub.close();
+      if (!statuses.length) {
+        console.log(chalk.dim("\nNenhum servidor MCP configurado."));
+        const file = path.join(os.homedir(), ".kafox", "mcp.json");
+        console.log(chalk.dim(`Crie ${file} com:`));
+        console.log(chalk.dim('{ "mcp": { "playwright": { "type": "local", "command": ["npx","-y","@playwright/mcp@latest"] } } }'));
+        return true;
+      }
+      console.log(chalk.cyan("\nServidores MCP:\n"));
+      for (const status of statuses) {
+        console.log(`  ${chalk.bold(status.name)}  ${chalk.dim(status.kind)}`);
+      }
+      console.log(chalk.dim("\nAbra a TUI (kafox) e use /mcp para conectar e ver as ferramentas."));
+      return true;
+    }
     case "/background":
       await setContentBackground(arg || null);
       return true;
@@ -168,8 +237,8 @@ async function runPlainREPL() {
   const cfg = storage.getConfig();
   const theme = cfg.theme || "default";
 
-  console.log(paint(theme, mascot));
-  console.log(paint(theme, `\n  Kafox CLI  v${VERSION}  -  opencode style`));
+  console.log(logoLines(theme).join("\n"));
+  console.log(chalk.bold(`\n  Kafox CLI  v${VERSION}`));
   console.log(chalk.dim("  Type /help for commands. Ctrl+C to exit.\n"));
 
   const token = await ensureSession().catch(() => null);
@@ -224,7 +293,7 @@ async function runPlainREPL() {
   });
 }
 
-async function runREPL() {
+async function runREPL(options = {}) {
   // Sem TTY (pipe/CI), mantem o REPL linha a linha.
   if (!process.stdin.isTTY || !process.stdout.isTTY) return runPlainREPL();
 
@@ -232,8 +301,8 @@ async function runREPL() {
   const token = await ensureSession().catch(() => null);
 
   if (!token) {
-    console.log(paint(cfg.theme || "default", mascot));
-    console.log(paint(cfg.theme || "default", `\n  Kafox CLI  v${VERSION}`));
+    console.log(logoLines(cfg.theme || "default").join("\n"));
+    console.log(chalk.bold(`\n  Kafox CLI  v${VERSION}`));
     console.log(chalk.yellow("  You are not logged in."));
     const { doLogin } = await inquirer.prompt([
       { type: "confirm", name: "doLogin", message: "Login now?", default: true },
@@ -246,7 +315,11 @@ async function runREPL() {
   return runTUI({
     commands: COMMANDS,
     onCommand: handleCommand,
-    interactiveCommands: new Set(["/login", "/theme", "/key", "/background"]),
+    // /theme roda dentro da TUI (modal com preview); os demais abrem prompt no terminal.
+    interactiveCommands: new Set(["/login", "/key", "/background"]),
+    autoApprove: Boolean(options?.allowAll),
+    // kafox --resume <codigo> volta para a conversa salva em ~/.kafox/chats.
+    resume: options?.resume || null,
   });
 }
 

package/src/diff.js

@@ -0,0 +1,193 @@
+/**
+ * Diff de linhas para o preview de edicao (estilo `git diff`, enxuto).
+ *
+ * Usa LCS quando os trechos sao pequenos e cai para um resumo grosseiro em
+ * arquivos grandes, para nao travar a TUI.
+ */
+const MAX_LCS_LINES = 700;
+
+function splitLines(text) {
+  return String(text ?? "").replace(/\r\n?/g, "\n").split("\n");
+}
+
+function commonPrefix(a, b) {
+  const limit = Math.min(a.length, b.length);
+  let index = 0;
+  while (index < limit && a[index] === b[index]) index += 1;
+  return index;
+}
+
+function commonSuffix(a, b, prefix) {
+  const limit = Math.min(a.length, b.length) - prefix;
+  let count = 0;
+  while (count < limit && a[a.length - 1 - count] === b[b.length - 1 - count]) count += 1;
+  return count;
+}
+
+/** LCS classico: devolve as operacoes (del/add) do trecho que mudou. */
+function lcsOps(left, right) {
+  const rows = left.length;
+  const cols = right.length;
+  const table = new Uint16Array((rows + 1) * (cols + 1));
+  const width = cols + 1;
+
+  for (let i = rows - 1; i >= 0; i -= 1) {
+    for (let j = cols - 1; j >= 0; j -= 1) {
+      table[i * width + j] =
+        left[i] === right[j]
+          ? table[(i + 1) * width + j + 1] + 1
+          : Math.max(table[(i + 1) * width + j], table[i * width + j + 1]);
+    }
+  }
+
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < rows && j < cols) {
+    if (left[i] === right[j]) {
+      ops.push({ type: "ctx", text: left[i] });
+      i += 1;
+      j += 1;
+    } else if (table[(i + 1) * width + j] >= table[i * width + j + 1]) {
+      ops.push({ type: "del", text: left[i] });
+      i += 1;
+    } else {
+      ops.push({ type: "add", text: right[j] });
+      j += 1;
+    }
+  }
+  while (i < rows) ops.push({ type: "del", text: left[i++] });
+  while (j < cols) ops.push({ type: "add", text: right[j++] });
+  return ops;
+}
+
+function coarseOps(left, right) {
+  return [
+    ...left.map((text) => ({ type: "del", text })),
+    ...right.map((text) => ({ type: "add", text })),
+  ];
+}
+
+/**
+ * Todas as operacoes, com numero de linha nos dois lados.
+ * `truncated` avisa que o miolo foi tratado de forma grosseira.
+ */
+function buildOps(before, after) {
+  const left = splitLines(before);
+  const right = splitLines(after);
+  const prefix = commonPrefix(left, right);
+  const suffix = commonSuffix(left, right, prefix);
+
+  const leftMiddle = left.slice(prefix, left.length - suffix);
+  const rightMiddle = right.slice(prefix, right.length - suffix);
+  const truncated = leftMiddle.length > MAX_LCS_LINES || rightMiddle.length > MAX_LCS_LINES;
+  const middle = truncated ? coarseOps(leftMiddle, rightMiddle) : lcsOps(leftMiddle, rightMiddle);
+
+  const ops = [];
+  for (let index = 0; index < prefix; index += 1) {
+    ops.push({ type: "ctx", text: left[index], beforeNo: index + 1, afterNo: index + 1 });
+  }
+
+  let beforeNo = prefix + 1;
+  let afterNo = prefix + 1;
+  let changed = false;
+  for (const op of middle) {
+    if (op.type === "ctx") {
+      ops.push({ ...op, beforeNo, afterNo });
+      beforeNo += 1;
+      afterNo += 1;
+    } else if (op.type === "del") {
+      ops.push({ ...op, beforeNo });
+      beforeNo += 1;
+      changed = true;
+    } else {
+      ops.push({ ...op, afterNo });
+      afterNo += 1;
+      changed = true;
+    }
+  }
+
+  for (let index = 0; index < suffix; index += 1) {
+    const line = left.length - suffix + index;
+    ops.push({
+      type: "ctx",
+      text: left[line],
+      beforeNo: line + 1,
+      afterNo: right.length - suffix + index + 1,
+    });
+  }
+
+  return { ops, truncated, changed };
+}
+
+function count(lines) {
+  return {
+    added: lines.filter((line) => line.type === "add").length,
+    removed: lines.filter((line) => line.type === "del").length,
+  };
+}
+
+/** Mantem so as mudancas e `context` linhas em volta (com o indice original). */
+function keptWithContext(ops, context) {
+  const keep = new Set();
+  ops.forEach((op, index) => {
+    if (op.type === "ctx") return;
+    for (let cursor = index - context; cursor <= index + context; cursor += 1) {
+      if (cursor >= 0 && cursor < ops.length) keep.add(cursor);
+    }
+  });
+  return ops.map((op, index) => ({ op, index })).filter((entry) => keep.has(entry.index));
+}
+
+/**
+ * Diff enxuto, com numeros de linha e `context` linhas de contexto.
+ * Arquivo identico devolve lista vazia.
+ */
+function diffLines(before, after, { context = 2 } = {}) {
+  const { ops, truncated, changed } = buildOps(before, after);
+  if (!changed) return { lines: [], added: 0, removed: 0, truncated: false };
+  const lines = keptWithContext(ops, context).map((entry) => entry.op);
+  return { lines, ...count(lines), truncated };
+}
+
+/**
+ * Diff agrupado em blocos separados (cada regiao que mudou vira um bloco),
+ * limitado a `maxLines` linhas para caber no preview.
+ */
+function diffBlocks(before, after, { context = 2, maxLines = 60 } = {}) {
+  const { ops, truncated, changed } = buildOps(before, after);
+  if (!changed) return { blocks: [], added: 0, removed: 0, truncated: false, total: 0 };
+
+  const kept = keptWithContext(ops, context);
+  const blocks = [];
+  let current = null;
+  let previousIndex = null;
+
+  for (const entry of kept) {
+    if (previousIndex == null || entry.index !== previousIndex + 1) {
+      current = [];
+      blocks.push(current);
+    }
+    current.push(entry.op);
+    previousIndex = entry.index;
+  }
+
+  let budget = maxLines;
+  const limited = [];
+  for (const block of blocks) {
+    if (budget <= 0) break;
+    const slice = block.slice(0, budget);
+    limited.push(slice);
+    budget -= slice.length;
+    if (slice.length < block.length) limited.push([{ type: "gap", text: "..." }]);
+  }
+
+  return {
+    blocks: limited,
+    ...count(kept.map((entry) => entry.op)),
+    truncated,
+    total: blocks.length,
+  };
+}
+
+module.exports = { diffLines, diffBlocks, splitLines, lcsOps, buildOps };