solrouter 0.2.4 → 0.3.1

package/bin/proxy.js

@@ -15,9 +15,33 @@ import { rmSync, existsSync } from "node:fs";
 import { join } from "node:path";
 
 const [, , cmdRaw, ...rest] = process.argv;
-const cmd = cmdRaw || "start";
+const cmd = cmdRaw || "run";
 const flag = name => { const i = rest.indexOf(name); return i >= 0 ? (rest[i + 1] ?? true) : undefined; };
 
+// Start the proxy in-process, then launch the chosen tool through it (Claude Code),
+// or — for GUI tools — keep the proxy up and print how to point the tool at it.
+async function startProxyAndLaunch(cfg, tool, launch, passThru = []) {
+  const { spawn } = await import("node:child_process");
+  const base = `http://127.0.0.1:${cfg.port}`;
+  startServer(cfg);
+  if ((tool === "claude" || tool === "code") && launch !== false) {
+    console.log(`\nLaunching Claude Code through the proxy…\n`);
+    const child = spawn("claude", passThru, {
+      stdio: "inherit",
+      env: { ...process.env, ANTHROPIC_BASE_URL: base, OPENAI_BASE_URL: base + "/v1" },
+    });
+    child.on("error", e => { console.error(e.code === "ENOENT" ? "Couldn't find `claude` on your PATH." : e.message); process.exit(1); });
+    child.on("exit", c => process.exit(c ?? 0));
+    return;
+  }
+  // GUI / other tools: proxy stays running; tell them where to point it.
+  console.log("\nProxy is running. Point your tool here:");
+  if (tool === "cursor") console.log(`  Cursor → Settings → Models → OpenAI Base URL:  ${base}/v1  (+ your API key)`);
+  else if (tool === "cline") console.log(`  Cline → API Provider → OpenAI Compatible → Base URL:  ${base}/v1`);
+  else { console.log(`  OpenAI-style:    ${base}/v1`); console.log(`  Anthropic-style: ${base}`); }
+  console.log("");
+}
+
 async function main() {
   switch (cmd) {
     case "login": {
@@ -110,14 +134,39 @@ async function main() {
       return;
     }
 
-    case "start":
+    case "setup": {
+      const { runSetup } = await import("../src/setup.js");
+      let res;
+      try { res = await runSetup(); }
+      catch (e) { console.log(e.message === "cancelled" ? "Setup cancelled." : "Setup: " + e.message); return; }
+      const cfg = loadConfig();
+      if (res.launch) return startProxyAndLaunch(cfg, res.tool, true);
+      console.log(paintDone(cfg, res.tool));
+      return;
+    }
+
+    case "run":       // bare `solrouter`: first run → setup; after that → launch
     default: {
+      let cfg = loadConfig();
+      if (!cfg.setupComplete && process.stdin.isTTY) {
+        const { runSetup } = await import("../src/setup.js");
+        let res;
+        try { res = await runSetup(); }
+        catch (e) { console.log(e.message === "cancelled" ? "\nSetup cancelled — run `solrouter setup` any time." : "Setup: " + e.message); return; }
+        cfg = loadConfig();
+        if (res.launch) return startProxyAndLaunch(cfg, res.tool, true);
+        console.log(paintDone(cfg, res.tool));
+        return;
+      }
+      // already set up → launch the saved tool through the proxy
+      return startProxyAndLaunch(cfg, cfg.tool || "claude", true);
+    }
+
+    case "start": {   // just the proxy, no tool launch
       const cfg = loadConfig({ port: flag("--port") ? Number(flag("--port")) : undefined,
                               mode: flag("--mode") || undefined });
       const { banner } = await import("../src/banner.js");
-      console.log(banner({ menu: false }));
-      // Pass-through supplies frontier creds per request, so login is not required
-      // to start — it only unlocks the private/uncensored leg.
+      console.log(banner());
       if (!isLoggedIn()) {
         console.warn("Note: not logged in — the private/uncensored leg is unavailable.");
         console.warn("      The frontier leg uses your tool's own credentials. Run `login` to enable both.\n");
@@ -128,4 +177,10 @@ async function main() {
   }
 }
 
+function paintDone(cfg, tool) {
+  const base = `http://127.0.0.1:${cfg.port}`;
+  return `\nYou're set up. Run  solrouter  to launch ${tool === "claude" ? "Claude Code" : tool} through the proxy.\n` +
+    (tool && tool !== "claude" ? `Or point ${tool} at ${base}/v1 manually.\n` : "");
+}
+
 main().catch(e => { console.error(e); process.exit(1); });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solrouter",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "description": "Local privacy router for coding tools: pseudonymises every request before it leaves your machine, and sends work a frontier model would refuse to an uncensored open-weight model you control.",
   "type": "module",
   "bin": {

package/src/banner.js

@@ -1,18 +1,23 @@
-// banner.js — the terminal splash, rendered as real pixels using truecolor
-// half-block characters (▀). Each character cell packs two vertical pixels (top =
-// foreground colour, bottom = background), so the art is twice as tall as the grid.
-// Transparent cells fall through to the terminal's own background.
-//
-// The cat wears a hoodie with the wave mark rendered in pixels. On image-capable
-// terminals we could show the literal PNG instead; this is the universal fallback.
+// banner.js — pixel art for the terminal, rendered with truecolor half-blocks (▀).
+// Exports the cat (wearing the real wave mark on its hoodie) and the mark alone,
+// plus helpers the interactive setup uses to compose the full-width screen.
 
-const C = {
-  bg: "#0a0908", cream: "#F5E6D3", out: "#050403", eye: "#0a0908",
-  nose: "#c98f7f", hood: "#15130f", accent: "#F5E6D3", muted: "#b5ac9f", faint: "#78746b",
+import { MARK_LG, MARK_SM } from "./mark.js";
+
+export const PAL = {
+  bg: "#0a0908", raised: "#161412", accent: "#F5E6D3", ink: "#e8e0d4",
+  muted: "#b5ac9f", faint: "#78746b", rule: "#2a2723",
+  cream: "#F5E6D3", out: "#050403", eye: "#0a0908", nose: "#c98f7f", hood: "#050403",
 };
 
-// 26-wide sprite. .=transparent o=outline b=body e=eye n=nose p=ear-pink H=hoodie v=logo-wave
-const GRID = [
+const rgb = (h) => [parseInt(h.slice(1, 3), 16), parseInt(h.slice(3, 5), 16), parseInt(h.slice(5, 7), 16)];
+export const fg = (h) => { const [r, g, b] = rgb(h); return `\x1b[38;2;${r};${g};${b}m`; };
+export const bgc = (h) => { const [r, g, b] = rgb(h); return `\x1b[48;2;${r};${g};${b}m`; };
+export const RESET = "\x1b[0m";
+export const paint = (h, t, bold = false) => fg(h) + (bold ? "\x1b[1m" : "") + t + RESET;
+
+// Base cat, clean hoodie. .=transparent o=outline b=body e=eye n=nose p=ear H=hoodie
+const CAT = [
   "...oo................oo....",
   "..obbo..............obbo..",
   "..obpbo............obpbo..",
@@ -29,34 +34,41 @@ const GRID = [
   "....obbbbbbbbbbbbbbbbo....",
   "...oHHHHHHHHHHHHHHHHHHo...",
   "..oHHHHHHHHHHHHHHHHHHHHo..",
-  "..oHHHvvHHvvHHvvHHvvHHHo..",
-  "..oHHvHHvvHHvvHHvvHHvHHo..",
   "..oHHHHHHHHHHHHHHHHHHHHo..",
-  "..oHHHvvHHvvHHvvHHvvHHHo..",
-  "..oHHvHHvvHHvvHHvvHHvHHo..",
+  "..oHHHHHHHHHHHHHHHHHHHHo..",
+  "..oHHHHHHHHHHHHHHHHHHHHo..",
+  "..oHHHHHHHHHHHHHHHHHHHHo..",
+  "..oHHHHHHHHHHHHHHHHHHHHo..",
   "..obbHHHHHHHHHHHHHHHHbbo..",
   "..obbboHHHHHHHHHHHHobbbo..",
   "...oooo.oooooooooo.oooo...",
 ];
-const CMAP = { o: C.out, b: C.cream, e: C.eye, n: C.nose, p: C.nose, H: C.hood, v: C.cream };
 
-const rgb = (h) => [parseInt(h.slice(1, 3), 16), parseInt(h.slice(3, 5), 16), parseInt(h.slice(5, 7), 16)];
-const fg = (h) => { const [r, g, b] = rgb(h); return `\x1b[38;2;${r};${g};${b}m`; };
-const bgc = (h) => { const [r, g, b] = rgb(h); return `\x1b[48;2;${r};${g};${b}m`; };
-const RESET = "\x1b[0m";
-const DIM = (h, t) => fg(h) + t + RESET;
+// Overlay the real mark (SM) onto the hoodie, centred.
+function catWithMark() {
+  const g = CAT.map(r => r.split(""));
+  const mw = MARK_SM[0].length, mh = MARK_SM.length;
+  const c0 = Math.round((CAT[0].length - mw) / 2);  // centre horizontally
+  const r0 = 16;                                     // centred on the black hoodie
+  for (let y = 0; y < mh; y++) for (let x = 0; x < mw; x++) {
+    if (MARK_SM[y][x] === "v" && g[r0 + y] && g[r0 + y][c0 + x] === "H") g[r0 + y][c0 + x] = "v";
+  }
+  return g.map(r => r.join(""));
+}
 
-/** Render the sprite to an array of ANSI lines (indented `pad` spaces). */
-function sprite(pad = 0) {
+const CMAP = { o: PAL.out, b: PAL.cream, e: PAL.eye, n: PAL.nose, p: PAL.nose, H: PAL.hood, v: PAL.cream };
+
+/** Render a pixel grid to ANSI half-block lines. Display width = grid width in chars. */
+export function renderGrid(grid, cmap = CMAP) {
   const lines = [];
-  for (let y = 0; y < GRID.length; y += 2) {
-    let line = " ".repeat(pad);
-    for (let x = 0; x < GRID[y].length; x++) {
-      const top = CMAP[GRID[y][x]];
-      const bot = GRID[y + 1] ? CMAP[GRID[y + 1][x]] : undefined;
+  for (let y = 0; y < grid.length; y += 2) {
+    let line = "";
+    for (let x = 0; x < grid[y].length; x++) {
+      const top = cmap[grid[y][x]];
+      const bot = grid[y + 1] ? cmap[grid[y + 1][x]] : undefined;
       if (top && bot) line += fg(top) + bgc(bot) + "▀" + RESET;
-      else if (top) line += fg(top) + "▀" + RESET;          // bottom transparent
-      else if (bot) line += fg(bot) + "▄" + RESET;          // top transparent
+      else if (top) line += fg(top) + "▀" + RESET;
+      else if (bot) line += fg(bot) + "▄" + RESET;
       else line += " ";
     }
     lines.push(line);
@@ -64,25 +76,16 @@ function sprite(pad = 0) {
   return lines;
 }
 
-/** The full splash string. */
-export function banner({ menu = true } = {}) {
-  const art = sprite(4);
-  const L = [];
-  L.push("");
-  L.push("  " + fg(C.accent) + "≈≈" + RESET + "  " + fg(C.accent) + "\x1b[1mSOLROUTER" + RESET);
-  L.push("  " + DIM(C.muted, "private routing for your coding agent"));
-  L.push("");
-  art.forEach(a => L.push(a));
-  L.push("      " + DIM(C.faint, "the router, in the hoodie"));
-  if (menu) {
-    L.push("");
-    L.push("  " + DIM(C.cream, "How should the frontier model be paid?"));
-    L.push("  " + fg(C.accent) + "▸ SolRouter subscription" + RESET + DIM(C.faint, "   — just sign in"));
-    L.push("  " + DIM(C.faint, "  My own API key           — paste once"));
-    L.push("  " + DIM(C.faint, "  ↑↓ move   ↵ select   esc quit"));
-  }
-  L.push("");
-  return L.join("\n");
+export const catLines = () => renderGrid(catWithMark());
+export const catWidth = () => CAT[0].length;
+export const markLines = () => renderGrid(MARK_LG, { v: PAL.cream });
+
+/** Legacy one-shot splash (used by the `banner` command). */
+export function banner() {
+  const L = ["", "  " + paint(PAL.accent, "≈≈", true) + "  " + paint(PAL.accent, "SOLROUTER", true),
+    "  " + paint(PAL.muted, "private routing for your coding agent"), ""];
+  catLines().forEach(l => L.push("    " + l));
+  L.push(""); return L.join("\n");
 }
 
-export default { banner };
+export default { banner, catLines, markLines, catWidth, renderGrid, PAL, paint, fg, bgc, RESET };

package/src/mark.js

@@ -0,0 +1,37 @@
+// mark.js — the SolRouter wave mark as pixels, decoded from the real
+// Solrouter-logo-dark.png (not hand-drawn), so the terminal shows the actual logo.
+// 'v' = wave (cream), '.' = transparent. LG for the header, SM for the hoodie patch.
+
+export const MARK_LG = [
+  ".....vvvv........vvvv.....",
+  "....vvvvvv......vvvvvvv...",
+  "..vvv....vvv..vvvv...vvv..",
+  "vvvv......vvvvvv......vvvv",
+  "vv.........vvvv.........vv",
+  ".........................",
+  ".....vvvv........vvvv.....",
+  "....vvvvvv......vvvvvvv...",
+  "..vvvv...vvv...vvv...vvv..",
+  "vvvv......vvvvvv......vvvv",
+  "vvv........vvvv........vvv",
+];
+
+// Nearest-neighbour downsample to a target width/height for the small hoodie patch.
+function downsample(grid, tw, th) {
+  const h = grid.length, w = grid[0].length, out = [];
+  for (let y = 0; y < th; y++) {
+    let row = "";
+    for (let x = 0; x < tw; x++) {
+      const sy = Math.min(h - 1, Math.round(y * (h - 1) / (th - 1)));
+      const sx = Math.min(w - 1, Math.round(x * (w - 1) / (tw - 1)));
+      row += grid[sy][sx] === "v" ? "v" : ".";
+    }
+    out.push(row);
+  }
+  return out;
+}
+
+// Small mark for the hoodie — kept compact so it sits centred with black around it.
+export const MARK_SM = downsample(MARK_LG, 12, 5);
+
+export default { MARK_LG, MARK_SM };

package/src/setup.js

@@ -0,0 +1,215 @@
+// setup.js — the interactive first-run wizard. Full-width TUI: selectable option
+// cards on the left, the cat + a speech bubble on the right that changes per step.
+// Arrow keys move, enter selects, esc/ctrl-c quits.
+//
+// Steps (v1 — API-key only for the frontier leg; no subscription relay):
+//   1. which coding tool
+//   2. how to reach the frontier model (detected key / paste / skip)
+//   3. enable the private uncensored leg (SolRouter sign-in / skip)
+//   4. done — save config, offer to launch
+
+import readline from "node:readline";
+import { catLines, markLines, catWidth, PAL, paint, fg, RESET } from "./banner.js";
+import { loadConfig, saveAuth, loadAuth, isLoggedIn, HOME_DIR } from "./config.js";
+import { browserLogin } from "./auth.js";
+import { writeFileSync, readFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const visLen = (s) => s.replace(/\x1b\[[0-9;]*m/g, "").length;
+const W = () => process.stdout.columns || 100;
+const clear = () => process.stdout.write("\x1b[2J\x1b[H");
+const hideCur = () => process.stdout.write("\x1b[?25l");
+const showCur = () => process.stdout.write("\x1b[?25h");
+
+// A rounded speech bubble in accent with a consistent width, tail pointing to the cat.
+function bubble(lines) {
+  const iw = Math.max(...lines.map(l => l.length));   // inner text width
+  const A = PAL.accent;
+  const out = [];
+  out.push(fg(A) + "╭" + "─".repeat(iw + 2) + "╮" + RESET);
+  for (const l of lines) out.push(fg(A) + "│ " + RESET + paint(PAL.ink, l.padEnd(iw)) + fg(A) + " │" + RESET);
+  out.push(fg(A) + "╰" + "─".repeat(iw + 2) + "╯" + RESET);
+  out.push("      " + fg(A) + "╲" + RESET);           // tail toward the cat below
+  return out;
+}
+
+// Right block = bubble (with the step's question) stacked above the cat, cat indented.
+function rightBlock(question) {
+  const cat = catLines().map(l => "   " + l);
+  const b = bubble(question);
+  return [...b, "", ...cat, "", "   " + paint(PAL.faint, "the router")];
+}
+
+// Left block = header (stacked, no long inline rows) + step + body lines.
+function leftBlock(step, bodyLines) {
+  const L = [];
+  markLines().forEach(m => L.push(m));                 // real wave mark
+  L.push(paint(PAL.accent, "SOLROUTER", true));
+  L.push(paint(PAL.muted, "private routing for your coding agent"));
+  L.push("");
+  L.push(paint(PAL.faint, `STEP ${step} / 3`));
+  L.push("");
+  bodyLines.forEach(l => L.push(l));
+  return L;
+}
+
+// One option card (two lines): selected gets an accent bar + bright text.
+function card(name, desc, selected) {
+  const bar = selected ? fg(PAL.accent) + "▐ " + RESET : "  ";
+  const nm = selected ? paint(PAL.accent, "▸ " + name, true) : paint(PAL.ink, "  " + name);
+  const ds = paint(selected ? PAL.muted : PAL.faint, "    " + desc);
+  return [bar + nm, bar + ds, ""];
+}
+
+function compose(step, question, bodyLines) {
+  const left = leftBlock(step, bodyLines);
+  const right = rightBlock(question);
+  const termW = W();
+  const leftMax = Math.max(...left.map(visLen));
+  const rightW = Math.max(...right.map(visLen));
+  // Pin the right block to a FIXED column near the right edge, so nothing shoves it
+  // around and the bubble stays aligned. Push the cat as far right as fits.
+  const rightCol = Math.max(leftMax + 8, termW - rightW - 3);
+  const rows = Math.max(left.length, right.length);
+  const out = [""];
+  for (let i = 0; i < rows; i++) {
+    let l = left[i] || "";
+    const r = right[i] || "";
+    if (visLen(l) > rightCol - 2) l = l.slice(0, rightCol - 2); // safety clamp
+    const pad = Math.max(2, rightCol - visLen(l));
+    out.push("  " + l + " ".repeat(pad) + r);
+  }
+  out.push("");
+  out.push("  " + paint(PAL.faint, "↑↓ move   ↵ select   esc quit"));
+  return out.join("\n");
+}
+
+function render(step, question, bodyLines) { clear(); process.stdout.write(compose(step, question, bodyLines)); }
+
+function saveSetup(patch) {
+  if (!existsSync(HOME_DIR)) mkdirSync(HOME_DIR, { recursive: true });
+  const path = join(HOME_DIR, "config.json");
+  let cur = {};
+  try { cur = JSON.parse(readFileSync(path, "utf8")); } catch {}
+  writeFileSync(path, JSON.stringify({ ...cur, ...patch, setupComplete: true }, null, 2));
+}
+
+const TOOLS = [
+  { id: "claude", name: "Claude Code", desc: "Anthropic CLI — the default" },
+  { id: "cursor", name: "Cursor", desc: "VS Code fork, custom base URL" },
+  { id: "cline", name: "Cline", desc: "VS Code extension" },
+  { id: "other", name: "Other / OpenAI-compatible", desc: "aider, Zed, Continue, SDKs" },
+];
+
+/** Run the wizard. Resolves { tool, launch } or rejects on quit. */
+export function runSetup() {
+  return new Promise((resolve, reject) => {
+    if (!process.stdin.isTTY) return reject(new Error("setup needs an interactive terminal"));
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    hideCur();
+
+    const finish = (val, err) => {
+      process.stdin.setRawMode(false); process.stdin.pause(); showCur();
+      process.stdout.write("\n");
+      err ? reject(err) : resolve(val);
+    };
+
+    const envKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || "";
+    const state = { step: 1, tool: 0, keyChoice: 0, loginChoice: 0, typing: false, buf: "" };
+
+    function keyOptions() {
+      return envKey
+        ? [`Use detected key (…${envKey.slice(-4)})`, "Paste a different key", "Skip — private leg only"]
+        : ["Paste an Anthropic/OpenAI API key", "Skip — private leg only"];
+    }
+
+    function draw() {
+      if (state.step === 1) {
+        const body = TOOLS.flatMap((t, i) => card(t.name, t.desc, i === state.tool));
+        render(1, ["Which coding tool", "are you using?"], body);
+      } else if (state.step === 2) {
+        if (state.typing) {
+          const masked = "•".repeat(state.buf.length);
+          render(2, ["Paste your API key", "then press ↵"],
+            [paint(PAL.ink, "  Key: ") + paint(PAL.accent, masked || "_"),
+             "", paint(PAL.faint, "  it's stored only on this machine")]);
+        } else {
+          const opts = keyOptions();
+          const body = opts.flatMap((o, i) => card(o, "", i === state.keyChoice));
+          render(2, ["How should I reach", "the frontier model?"], body);
+        }
+      } else if (state.step === 3) {
+        const opts = ["Sign in (opens browser)", "Skip for now"];
+        const body = opts.flatMap((o, i) => card(o,
+          i === 0 ? "the uncensored model, refusals reroute here" : "add it later with `solrouter login`",
+          i === state.loginChoice));
+        render(3, ["Want the uncensored", "model too?"], body);
+      } else if (state.step === 4) {
+        const opts = ["Launch now", "Exit — I'll run it later"];
+        const body = [paint(PAL.muted, "  Tool: ") + paint(PAL.ink, TOOLS[state.tool].name),
+          paint(PAL.muted, "  Frontier: ") + paint(PAL.ink, envKey || state.buf ? "your API key" : "not set"),
+          paint(PAL.muted, "  Private: ") + paint(PAL.ink, isLoggedIn() ? "enabled" : "off"),
+          "", ...opts.flatMap((o, i) => card(o, "", i === state.loginChoice))];
+        render(4, ["You're all set!", "≈"], body);
+      }
+    }
+
+    async function onKey(str, key) {
+      const name = key?.name;
+      if (key?.ctrl && name === "c") return finish(null, new Error("cancelled"));
+      if (name === "escape") return finish(null, new Error("cancelled"));
+
+      if (state.typing) { // API key entry
+        if (name === "return") {
+          if (state.buf) { saveSetup({ tool: TOOLS[state.tool].id, frontier: { apiKey: state.buf } }); }
+          state.typing = false; state.step = 3; draw(); return;
+        }
+        if (name === "backspace") { state.buf = state.buf.slice(0, -1); draw(); return; }
+        if (str && !key.ctrl && str.length === 1 && str >= " ") { state.buf += str; draw(); }
+        return;
+      }
+
+      const move = (cur, len) => name === "up" ? (cur - 1 + len) % len : name === "down" ? (cur + 1) % len : cur;
+
+      if (state.step === 1) {
+        if (name === "up" || name === "down") { state.tool = move(state.tool, TOOLS.length); draw(); }
+        else if (name === "return") { state.step = 2; draw(); }
+      } else if (state.step === 2) {
+        const opts = keyOptions();
+        if (name === "up" || name === "down") { state.keyChoice = move(state.keyChoice, opts.length); draw(); }
+        else if (name === "return") {
+          const choice = opts[state.keyChoice];
+          if (choice.startsWith("Paste")) { state.typing = true; state.buf = ""; draw(); }
+          else { if (envKey && state.keyChoice === 0) saveSetup({ tool: TOOLS[state.tool].id }); state.step = 3; draw(); }
+        }
+      } else if (state.step === 3) {
+        if (name === "up" || name === "down") { state.loginChoice = move(state.loginChoice, 2); draw(); }
+        else if (name === "return") {
+          if (state.loginChoice === 0) {
+            render(3, ["Opening your", "browser…"], [paint(PAL.faint, "  finish signing in, then come back")]);
+            try { await browserLogin(); } catch (e) { /* leave private off */ }
+          }
+          state.loginChoice = 0; state.step = 4; draw();
+        }
+      } else if (state.step === 4) {
+        if (name === "up" || name === "down") { state.loginChoice = move(state.loginChoice, 2); draw(); }
+        else if (name === "return") {
+          saveSetup({ tool: TOOLS[state.tool].id });
+          finish({ tool: TOOLS[state.tool].id, launch: state.loginChoice === 0 });
+        }
+      }
+    }
+
+    process.stdin.on("keypress", (s, k) => { onKey(s, k).catch(err => finish(null, err)); });
+    draw();
+  });
+}
+
+/** For previewing the layout without a TTY (testing only). */
+export function previewFrame() {
+  const body = TOOLS.flatMap((t, i) => card(t.name, t.desc, i === 0));
+  return compose(1, ["Which coding tool", "are you using?"], body);
+}
+
+export default { runSetup, previewFrame };