kafox-cli 0.1.0 → 0.2.1

package/README.md

@@ -12,7 +12,7 @@ npm install -g kafox-cli
 O comando instalado e `kafox`. Alternativa sem npm:
 
 ```bash
-npm install -g https://kafox.pypag.com/static/downloads/kafox-0.1.0.tgz
+npm install -g https://kafox.pypag.com/static/downloads/kafox-cli-0.2.1.tgz
 ```
 
 Requisito: Node.js 22.5+.

package/bin/kafox.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 const { Command } = require("commander");
+const { version } = require("../package.json");
 const { runREPL, compact, clearContext, showStatus } = require("../src/cli");
 const { login, logout, whoami, createKey } = require("../src/auth");
 const { listModels, showBalance, showPricing } = require("../src/models");
@@ -10,8 +11,8 @@ const program = new Command();
 
 program
   .name("kafox")
-  .description("Kafox CLI in opencode style: REPL, account login, models, balance, themes")
-  .version("0.1.0");
+  .description("Kafox CLI in opencode style: terminal UI, account login, models, balance, themes")
+  .version(version);
 
 program.command("login").description("Login with your Kafox account (device code SSO)").action(login);
 program.command("logout").description("End the CLI session").action(logout);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kafox-cli",
-  "version": "0.1.0",
-  "description": "Kafox CLI in opencode style: REPL, account login, models, balance, themes",
+  "version": "0.2.1",
+  "description": "Kafox CLI in opencode style: full-screen terminal UI, device login, models, balance, themes",
   "bin": {
     "kafox": "bin/kafox.js"
   },
@@ -18,5 +18,8 @@
     "chalk": "4.1.2",
     "commander": "12.1.0",
     "inquirer": "8.2.6"
+  },
+  "scripts": {
+    "test": "node --test \"test/*.test.js\""
   }
-}
+}

package/src/cli.js

@@ -4,9 +4,12 @@ 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 { version: VERSION } = require("../package.json");
+
 const COMMANDS = {
   "/help": "show this help",
   "/models": "list models and prices",
@@ -39,8 +42,8 @@ async function handleCommand(line) {
   switch (cmd) {
     case "/help":
       console.log(chalk.cyan("\nCommands:\n"));
-      for (const [k, v] of Object.entries(COMMANDS)) {
-        console.log(`  ${chalk.bold(k)}  ${chalk.dim(v)}`);
+      for (const [key, value] of Object.entries(COMMANDS)) {
+        console.log(`  ${chalk.bold(key)}  ${chalk.dim(value)}`);
       }
       console.log("");
       return true;
@@ -133,9 +136,7 @@ async function compact() {
     ...last,
   ];
   console.log(
-    chalk.green(
-      `Context compacted: ${turns} -> ${history.length} messages (auto summary).`
-    )
+    chalk.green(`Context compacted: ${turns} -> ${history.length} messages (auto summary).`)
   );
 }
 
@@ -155,35 +156,27 @@ async function showStatus() {
   console.log(chalk.cyan("\nKafox status\n"));
   console.log(`  Account: ${data.user.email} (${data.user.name})`);
   console.log(
-    `  Balance: ${chalk.green(
-      (data.user.balance_micros / 1_000_000).toFixed(2) + " R$"
-    )}`
-  );
-  console.log(
-    `  Model: ${modelOverride || cfg.model || "(auto)"}`
+    `  Balance: ${chalk.green((data.user.balance_micros / 1_000_000).toFixed(2) + " R$")}`
   );
+  console.log(`  Model: ${modelOverride || cfg.model || "(auto)"}`);
   console.log(`  Keys: ${data.keys.active}/${data.max_active_keys} active`);
   console.log(`  Gateway: ${data.gateway_url}`);
 }
 
-async function runREPL() {
+/** Modo simples: sem TTY (scripts, pipes) ou apos o login. */
+async function runPlainREPL() {
   const cfg = storage.getConfig();
   const theme = cfg.theme || "default";
 
   console.log(paint(theme, mascot));
-  console.log(paint(theme, "\n  Kafox CLI  v0.1.0  -  opencode style"));
+  console.log(paint(theme, `\n  Kafox CLI  v${VERSION}  -  opencode style`));
   console.log(chalk.dim("  Type /help for commands. Ctrl+C to exit.\n"));
 
   const token = await ensureSession().catch(() => null);
   if (!token) {
     console.log(chalk.yellow("  You are not logged in."));
     const { doLogin } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "doLogin",
-        message: "Login now?",
-        default: true,
-      },
+      { type: "confirm", name: "doLogin", message: "Login now?", default: true },
     ]);
     if (doLogin) {
       const { login } = require("./auth");
@@ -216,10 +209,8 @@ async function runREPL() {
         await handleCommand(line);
       } else {
         pushHistory("user", line);
-        process.stdout.write(chalk.dim("thinking..."));
         await ask(line, { model: modelOverride || storage.getConfig().model });
         pushHistory("assistant", "(answer above)");
-        process.stdout.write("\r");
       }
     } catch (err) {
       console.log(chalk.red(`\nError: ${err.message}`));
@@ -233,6 +224,32 @@ async function runREPL() {
   });
 }
 
+async function runREPL() {
+  // Sem TTY (pipe/CI), mantem o REPL linha a linha.
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return runPlainREPL();
+
+  const cfg = storage.getConfig();
+  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(chalk.yellow("  You are not logged in."));
+    const { doLogin } = await inquirer.prompt([
+      { type: "confirm", name: "doLogin", message: "Login now?", default: true },
+    ]);
+    if (!doLogin) return;
+    const { login } = require("./auth");
+    await login();
+  }
+
+  return runTUI({
+    commands: COMMANDS,
+    onCommand: handleCommand,
+    interactiveCommands: new Set(["/login", "/theme", "/key", "/background"]),
+  });
+}
+
 module.exports = {
   runREPL,
   compact,
@@ -240,4 +257,4 @@ module.exports = {
   showStatus,
   handleCommand,
   COMMANDS,
-};
+};

package/src/gateway.js

@@ -2,101 +2,126 @@ const chalk = require("chalk");
 const storage = require("./storage");
 const { ensureSession, fetchApi } = require("./auth");
 
-async function ask(question, options = {}) {
+/**
+ * Envia a pergunta ao gateway e devolve o resultado estruturado.
+ * A TUI usa o retorno; o comando `kafox ask` so imprime.
+ */
+async function askModel(question, options = {}) {
   const text = typeof question === "string" ? question : (question || []).join(" ");
   if (!text.trim()) {
-    console.log(chalk.dim('Usage: kafox ask "your question" [-m model]'));
-    return;
+    return { ok: false, error: 'Usage: kafox ask "your question" [-m model]' };
   }
 
   const token = await ensureSession();
   if (!token) {
-    console.log(chalk.yellow("Login first: `kafox login`"));
-    return;
+    return { ok: false, error: "Login first: `kafox login`" };
   }
 
   // Saldo decide se a CLI responde: sem credito, nem chega no gateway.
   const boot = await fetchApi("/api/bootstrap");
   if (!boot.ok) {
-    console.log(chalk.red("Session invalid. Run `kafox login`"));
-    return;
+    return { ok: false, error: "Session invalid. Run `kafox login`" };
   }
   const account = await boot.json();
   const balance = Number(account?.user?.balance_micros || 0);
   if (balance <= 0) {
-    console.log(
-      chalk.red("\nSem saldo para responder. Recarregue em https://kafox.pypag.com/dashboard")
-    );
-    return;
+    return {
+      ok: false,
+      code: "no_balance",
+      error: "Sem saldo para responder. Recarregue em https://kafox.pypag.com/dashboard",
+    };
   }
 
   let model = options.model || storage.getConfig().model;
   if (!model) {
     const pricing = await fetchApi("/api/public/pricing")
-      .then((r) => r.json())
+      .then((response) => response.json())
       .catch(() => null);
     model = pricing?.pricing?.[0]?.model;
     if (!model) {
-      console.log(chalk.red("Could not load model catalog."));
-      return;
+      return { ok: false, error: "Could not load model catalog." };
     }
   }
 
+  let keyCreated = false;
   let apiKey = storage.getConfig().api_key;
   if (!apiKey) {
-    const kr = await fetchApi("/api/keys", {
+    const keyResponse = await fetchApi("/api/keys", {
       method: "POST",
       body: JSON.stringify({ name: "kafox-cli" }),
     });
-    const kd = await kr.json().catch(() => ({}));
-    if (!kr.ok) {
-      console.log(chalk.red(`Failed to create key: ${kd.error || "error"}`));
-      return;
+    const keyData = await keyResponse.json().catch(() => ({}));
+    if (!keyResponse.ok) {
+      return { ok: false, error: `Failed to create key: ${keyData.error || "error"}` };
     }
-    apiKey = kd.secret;
+    apiKey = keyData.secret;
     storage.setConfig({ api_key: apiKey });
-    console.log(chalk.dim("(key created and saved to ~/.kafox/config.json)"));
+    keyCreated = true;
   }
 
-  console.log(chalk.dim(`Model: ${model}`));
-  const res = await fetchApi("/api/public/playground", {
+  const response = await fetchApi("/api/public/playground", {
     method: "POST",
     body: JSON.stringify({ api_key: apiKey, model, message: text }),
   });
-  const data = await res.json().catch(() => ({}));
-  if (!res.ok) {
-    if (res.status === 402) {
-      console.log(
-        chalk.red("\nNo balance! Recharge at https://kafox.pypag.com/dashboard")
-      );
-    } else {
-      console.log(chalk.red(`\nFailed: ${data.error || "gateway error"}`));
+  const data = await response.json().catch(() => ({}));
+
+  if (!response.ok) {
+    if (response.status === 402) {
+      return {
+        ok: false,
+        code: "no_balance",
+        error: "Sem saldo para responder. Recarregue em https://kafox.pypag.com/dashboard",
+      };
     }
-    return;
+    return { ok: false, error: `Failed: ${data.error || "gateway error"}` };
   }
+
   // O playground devolve 200 mesmo quando o gateway recusa a chamada.
   if (data.ok === false) {
-    const detail =
-      data.body?.error?.message || data.body?.error || "gateway error";
+    const detail = data.body?.error?.message || data.body?.error || "gateway error";
     if (data.status === 402) {
-      console.log(
-        chalk.red("\nNo balance! Recharge at https://kafox.pypag.com/dashboard")
-      );
-    } else {
-      console.log(chalk.red(`\nFailed (${data.status}): ${detail}`));
+      return {
+        ok: false,
+        code: "no_balance",
+        error: "Sem saldo para responder. Recarregue em https://kafox.pypag.com/dashboard",
+      };
     }
-    return;
+    return { ok: false, error: `Failed (${data.status}): ${detail}` };
   }
+
   const body = data.body;
-  const out =
+  const output =
     typeof body === "string"
       ? body
-      : body?.choices?.[0]?.message?.content
-      || body?.choices?.[0]?.text
-      || JSON.stringify(body, null, 2);
+      : body?.choices?.[0]?.message?.content ||
+        body?.choices?.[0]?.text ||
+        JSON.stringify(body, null, 2);
+
+  return {
+    ok: true,
+    text: String(output || "").trim() || "(resposta vazia)",
+    ms: data.ms,
+    provider: data.provider,
+    model,
+    keyCreated,
+  };
+}
+
+async function ask(question, options = {}) {
+  const result = await askModel(question, options);
+  if (!result.ok) {
+    console.log(chalk.red(`\n${result.error}`));
+    return;
+  }
+  if (result.keyCreated) {
+    console.log(chalk.dim("(key created and saved to ~/.kafox/config.json)"));
+  }
+  console.log(chalk.dim(`Model: ${result.model}`));
   console.log(chalk.green("\nAnswer:"));
-  console.log(out);
-  if (data.ms) console.log(chalk.dim(`\n(${data.ms}ms  provider ${data.provider || "?"})`));
+  console.log(result.text);
+  if (result.ms) {
+    console.log(chalk.dim(`\n(${result.ms}ms  provider ${result.provider || "?"})`));
+  }
 }
 
-module.exports = { ask };
+module.exports = { ask, askModel };

package/src/tui.js

@@ -0,0 +1,453 @@
+/**
+ * Interface de terminal do kafox, no estilo opencode:
+ * tela cheia, mascote, menu de comandos "/", caixa de input e rodape.
+ *
+ * Tudo e desenhado a mao (sem dependencia de TUI) para manter o pacote leve e
+ * funcionar no Windows Terminal. Sem TTY, o cli.js usa o REPL simples.
+ */
+const readline = require("readline");
+const chalk = require("chalk");
+const storage = require("./storage");
+const { mascot } = require("./mascot");
+const { paint } = require("./theme");
+const { ensureSession, fetchApi } = require("./auth");
+const { askModel } = require("./gateway");
+
+const ANSI = /\x1b\[[0-9;]*m/g;
+const stripAnsi = (value) => String(value).replace(ANSI, "");
+const visible = (value) => stripAnsi(value).length;
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+
+function wrap(text, width) {
+  const max = Math.max(10, width);
+  const lines = [];
+  for (const paragraph of String(text).replace(/\r/g, "").split("\n")) {
+    if (!paragraph.length) {
+      lines.push("");
+      continue;
+    }
+    let line = "";
+    for (const word of paragraph.split(/\s+/)) {
+      if (!line) line = word;
+      else if (line.length + 1 + word.length <= max) line += " " + word;
+      else {
+        lines.push(line);
+        line = word;
+      }
+      while (line.length > max) {
+        lines.push(line.slice(0, max));
+        line = line.slice(max);
+      }
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+
+function truncate(text, width) {
+  const plain = stripAnsi(text);
+  if (plain.length <= width) return text;
+  if (width <= 3) return plain.slice(0, width);
+  return plain.slice(0, width - 3) + "...";
+}
+
+function center(text, width) {
+  const pad = Math.max(0, Math.floor((width - visible(text)) / 2));
+  return " ".repeat(pad) + text;
+}
+
+function padRight(text, width) {
+  const missing = width - visible(text);
+  return missing > 0 ? text + " ".repeat(missing) : truncate(text, width);
+}
+
+function initialState() {
+  const cfg = storage.getConfig();
+  return {
+    input: "",
+    cursor: 0,
+    history: [],
+    historyIndex: -1,
+    messages: [],
+    busy: false,
+    frame: 0,
+    menuIndex: 0,
+    balance: null,
+    model: cfg.model || null,
+    theme: cfg.theme || "default",
+    suspended: false,
+    version: require("../package.json").version,
+  };
+}
+
+/* ------------------------------------------------------------------ layout */
+
+function headerLines(state, width, rows) {
+  if (state.messages.length) return [];
+  const art = mascot.split("\n");
+  const visibleArt = rows >= 46 ? art : art.slice(0, 9);
+  const lines = visibleArt.map((line) => center(paint(state.theme, line), width));
+  lines.push("");
+  lines.push(center(chalk.bold("O que voce quer fazer?"), width));
+  lines.push(
+    center(chalk.dim("Use / para comandos  |  Enter envia  |  Ctrl+C sai"), width)
+  );
+  lines.push("");
+  return lines;
+}
+
+function messageLines(state, width) {
+  const lines = [];
+  for (const message of state.messages) {
+    if (message.role === "user") {
+      lines.push("");
+      const body = wrap(message.text, width - 2);
+      lines.push(chalk.cyan("> ") + chalk.bold(body[0] || ""));
+      for (let index = 1; index < body.length; index += 1) {
+        lines.push("  " + chalk.bold(body[index]));
+      }
+    } else if (message.role === "assistant") {
+      lines.push("");
+      for (const line of wrap(message.text, width - 2)) lines.push("  " + line);
+      const meta = [
+        message.ms ? `${(message.ms / 1000).toFixed(1)}s` : null,
+        message.provider,
+      ]
+        .filter(Boolean)
+        .join(" | ");
+      if (meta) lines.push(chalk.dim("  " + meta));
+    } else {
+      lines.push("");
+      const color = message.error ? chalk.red : chalk.dim;
+      for (const line of wrap(message.text, width - 2)) lines.push(color("  " + line));
+    }
+  }
+  if (state.busy) {
+    lines.push("");
+    lines.push(chalk.dim(`  pensando${".".repeat(state.frame % 4)}`));
+  }
+  return lines;
+}
+
+function filteredCommands(state, commands) {
+  if (!state.input.startsWith("/") || state.input.includes(" ")) return [];
+  const query = state.input.toLowerCase();
+  return Object.entries(commands).filter(([name]) =>
+    name.toLowerCase().startsWith(query)
+  );
+}
+
+function menuLines(state, commands, width) {
+  const items = filteredCommands(state, commands).slice(0, 8);
+  if (!items.length) return [];
+  return items.map(([name, description], index) => {
+    const selected = index === state.menuIndex % items.length;
+    const text = truncate(` ${name}`.padEnd(24) + description, width);
+    return selected ? chalk.inverse(padRight(text, width)) : chalk.dim(text);
+  });
+}
+
+function footerLines(state, width) {
+  const name = state.version ? `kafox ${state.version}` : "kafox";
+  const left = chalk.dim(truncate(`${name}  |  ${state.model || "auto"}`, width - 16));
+  const right = chalk.green(
+    state.balance == null ? "saldo --" : `R$ ${(state.balance / 1_000_000).toFixed(2)}`
+  );
+  const gap = " ".repeat(Math.max(1, width - visible(left) - visible(right)));
+  return [
+    left + gap + right,
+    chalk.dim(truncate(process.cwd(), width)),
+    chalk.dim(truncate("Enter envia  |  / comandos  |  Ctrl+C sai", width)),
+  ];
+}
+
+function buildFrame(state, cols, rows, commands) {
+  const width = Math.min(cols - 2, 108);
+  const margin = Math.floor((cols - width) / 2);
+  const gutter = " ".repeat(Math.max(0, margin));
+
+  const header = headerLines(state, width, rows);
+  const menu = menuLines(state, commands, width);
+  const footer = footerLines(state, width);
+
+  const inputWidth = width - 2;
+  const start = state.input.length > inputWidth
+    ? clamp(state.cursor - (inputWidth - 2), 0, Math.max(0, state.input.length - inputWidth))
+    : 0;
+  const shown = state.input.slice(start, start + inputWidth);
+  const inputLine = state.input
+    ? chalk.cyan("> ") + shown
+    : chalk.cyan("> ") + chalk.dim(truncate("Pergunte alguma coisa...", inputWidth));
+  const rule = chalk.dim("-".repeat(width));
+
+  const reserved = footer.length + menu.length + 3;
+  const available = Math.max(1, rows - header.length - reserved);
+  let body = messageLines(state, width);
+  if (body.length > available) body = body.slice(body.length - available);
+  while (body.length < available) body.unshift("");
+
+  const raw = [...header, ...body, "", ...menu, inputLine, rule, ...footer];
+  while (raw.length < rows) raw.push("");
+  const lines = raw.slice(0, rows).map((line) => gutter + padRight(line, width));
+
+  const inputRow = header.length + available + 1 + menu.length + 1;
+  const cursorCol = Math.max(1, margin + 2 + (state.cursor - start) + 1);
+  return { lines, cursorRow: Math.min(rows, inputRow), cursorCol };
+}
+
+/* --------------------------------------------------------------------- app */
+
+async function runTUI({ commands = {}, onCommand, interactiveCommands = new Set() } = {}) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const state = initialState();
+  let spinner = null;
+  let closed = false;
+
+  const write = (value) => stdout.write(value);
+  const enterScreen = () => write("\x1b[?1049h\x1b[?25l\x1b[H\x1b[2J");
+  const leaveScreen = () => write("\x1b[?25h\x1b[?1049l");
+
+  async function refreshAccount() {
+    const token = await ensureSession();
+    if (!token) return;
+    const response = await fetchApi("/api/bootstrap").catch(() => null);
+    if (!response || !response.ok) return;
+    const data = await response.json().catch(() => null);
+    if (data?.user) state.balance = data.user.balance_micros;
+
+    if (!state.model) {
+      const pricing = await fetchApi("/api/public/pricing")
+        .then((res) => res.json())
+        .catch(() => null);
+      state.model = pricing?.pricing?.[0]?.model || null;
+    }
+  }
+
+  function render() {
+    if (closed || state.suspended) return;
+    const cols = Math.max(40, stdout.columns || 80);
+    const rows = Math.max(16, stdout.rows || 24);
+    const frame = buildFrame(state, cols, rows, commands);
+    write("\x1b[?25l\x1b[H" + frame.lines.join("\r\n"));
+    write(`\x1b[${frame.cursorRow};${frame.cursorCol}H\x1b[?25h`);
+  }
+
+  async function capture(fn) {
+    const original = console.log;
+    const collected = [];
+    console.log = (...args) => collected.push(args.map((item) => String(item)).join(" "));
+    try {
+      await fn();
+    } catch (error) {
+      collected.push(`Erro: ${error.message}`);
+    } finally {
+      console.log = original;
+    }
+    return collected.join("\n");
+  }
+
+  async function runOutside(line) {
+    state.suspended = true;
+    leaveScreen();
+    stdin.setRawMode(false);
+    stdin.pause();
+    try {
+      await onCommand(line);
+    } finally {
+      stdin.resume();
+      stdin.setRawMode(true);
+      state.suspended = false;
+      enterScreen();
+      await refreshAccount();
+      render();
+    }
+  }
+
+  async function runCommand(line) {
+    const name = line.split(/\s+/)[0];
+    if (name === "/exit" || name === "/quit") return quit();
+
+    if (name === "/clear") {
+      state.messages = [];
+      state.status = "";
+      return render();
+    }
+    if (name === "/compact") {
+      if (!state.messages.length) {
+        state.messages.push({ role: "system", text: "Nada para compactar." });
+      } else {
+        const total = state.messages.length;
+        state.messages = [
+          {
+            role: "system",
+            text: `Contexto compactado: ${total} mensagens resumidas.`,
+          },
+          ...state.messages.slice(-6),
+        ];
+      }
+      return render();
+    }
+
+    if (interactiveCommands.has(name)) return runOutside(line);
+
+    const before = state.messages.length;
+    const output = (await capture(() => onCommand(line))).trim();
+    if (output) state.messages.push({ role: "system", text: output });
+    else if (state.messages.length === before) {
+      state.messages.push({ role: "system", text: `${name}: sem saida.` });
+    }
+    state.model = storage.getConfig().model || state.model;
+    render();
+    await refreshAccount();
+    render();
+  }
+
+  async function submit() {
+    const line = state.input.trim();
+    if (!line || state.busy) return;
+    state.history.push(line);
+    state.historyIndex = state.history.length;
+    state.input = "";
+    state.cursor = 0;
+    state.menuIndex = 0;
+
+    if (line.startsWith("/")) return runCommand(line);
+
+    state.messages.push({ role: "user", text: line });
+    state.busy = true;
+    render();
+
+    const result = await askModel(line, { model: state.model });
+    state.busy = false;
+    if (result.ok) {
+      state.messages.push({
+        role: "assistant",
+        text: result.text,
+        ms: result.ms,
+        provider: result.provider,
+      });
+    } else {
+      state.messages.push({ role: "system", text: result.error || "Falha ao responder.", error: true });
+    }
+    render();
+    await refreshAccount();
+    render();
+  }
+
+  function setInput(value, cursor) {
+    state.input = value;
+    state.cursor = cursor == null ? value.length : clamp(cursor, 0, value.length);
+    state.menuIndex = 0;
+    render();
+  }
+
+  function onKey(str, key = {}) {
+    if (state.suspended) return;
+    if (key.ctrl && key.name === "c") return quit();
+
+    const items = filteredCommands(state, commands);
+    const menuOpen = items.length > 0;
+
+    if (key.name === "return") return submit();
+    if (key.name === "tab") {
+      if (menuOpen) {
+        const selected = items[state.menuIndex % items.length];
+        return setInput(selected[0] + " ");
+      }
+      return;
+    }
+    if (key.name === "escape") {
+      if (menuOpen) return setInput("");
+      return;
+    }
+    if (key.name === "up" || key.name === "down") {
+      if (menuOpen) {
+        const delta = key.name === "up" ? -1 : 1;
+        state.menuIndex = (state.menuIndex + delta + items.length) % items.length;
+        return render();
+      }
+      if (!state.history.length) return;
+      const delta = key.name === "up" ? -1 : 1;
+      const next = clamp(state.historyIndex + delta, 0, state.history.length);
+      state.historyIndex = next;
+      if (next === state.history.length) return setInput("");
+      return setInput(state.history[next]);
+    }
+    if (key.name === "left") {
+      return setInput(state.input, state.cursor - 1);
+    }
+    if (key.name === "right") {
+      return setInput(state.input, state.cursor + 1);
+    }
+    if (key.name === "home") return setInput(state.input, 0);
+    if (key.name === "end") return setInput(state.input, state.input.length);
+    if (key.name === "backspace") {
+      if (!state.cursor) return;
+      return setInput(
+        state.input.slice(0, state.cursor - 1) + state.input.slice(state.cursor),
+        state.cursor - 1
+      );
+    }
+    if (key.name === "delete") {
+      if (state.cursor >= state.input.length) return;
+      return setInput(
+        state.input.slice(0, state.cursor) + state.input.slice(state.cursor + 1),
+        state.cursor
+      );
+    }
+    if (key.ctrl && key.name === "u") return setInput("");
+    if (key.ctrl && key.name === "w") {
+      const before = state.input.slice(0, state.cursor).replace(/\s*\S*$/, "");
+      return setInput(before + state.input.slice(state.cursor), before.length);
+    }
+    if (key.ctrl && key.name === "l") {
+      write("\x1b[H\x1b[2J");
+      return render();
+    }
+
+    if (str && !key.ctrl && !key.meta) {
+      const text = str.replace(/[\x00-\x1f\x7f]/g, "");
+      if (!text) return;
+      setInput(
+        state.input.slice(0, state.cursor) + text + state.input.slice(state.cursor),
+        state.cursor + text.length
+      );
+    }
+  }
+
+  function quit() {
+    if (closed) return;
+    closed = true;
+    if (spinner) clearInterval(spinner);
+    stdin.removeListener("keypress", onKey);
+    stdout.removeListener("resize", render);
+    try {
+      stdin.setRawMode(false);
+    } catch {}
+    leaveScreen();
+    write("\n");
+    process.exit(0);
+  }
+
+  enterScreen();
+  if (stdin.isTTY) stdin.setRawMode(true);
+  stdin.resume();
+  readline.emitKeypressEvents(stdin);
+  stdin.on("keypress", onKey);
+  stdout.on("resize", render);
+
+  await refreshAccount();
+  render();
+
+  spinner = setInterval(() => {
+    if (!state.busy || closed) return;
+    state.frame += 1;
+    render();
+  }, 110);
+  spinner.unref?.();
+
+  return { state, quit, render, submit };
+}
+
+module.exports = { runTUI, buildFrame, wrap, initialState, filteredCommands };