@mangomagic/cli 0.1.0

package/README.md

@@ -0,0 +1,45 @@
+# @mangomagic/cli
+
+The MangoMagic command-line companion.
+
+```bash
+npx -y @mangomagic/cli login
+```
+
+You'll get a short code, your browser will open, you approve the device, and
+the CLI plays the MangoMagic splash to confirm you're in. The token is cached
+at `~/.mangomagic/credentials.json` (mode 0600) so the next runs skip auth.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `mangomagic login` | Browser-based device-code sign-in + splash. |
+| `mangomagic logout` | Forget the cached token. |
+| `mangomagic whoami` | Show the cached identity. |
+| `mangomagic splash` | Replay the splash animation. `--static`, `--loop` supported. |
+| `mangomagic mcp` | Run as a stdio MCP server. Wire into Claude Desktop / Cursor. |
+| `mangomagic mcp-config` | Print MCP client JSON for copy-paste. |
+
+## Use as an MCP server
+
+Add to Claude Desktop's `claude_desktop_config.json` (or Cursor's MCP settings):
+
+```json
+{
+  "mcpServers": {
+    "mangomagic": {
+      "command": "npx",
+      "args": ["-y", "@mangomagic/cli", "mcp"]
+    }
+  }
+}
+```
+
+The MCP server uses the same token cached by `mangomagic login`, so make sure
+you sign in first.
+
+## Requirements
+
+Node 18 or later. The splash uses true-color ANSI; on terminals without it,
+the CLI falls back to a plain banner.

package/bin/mangomagic.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// MangoMagic CLI entrypoint. Pure-Node, ESM, zero deps (MCP server uses
+// @modelcontextprotocol/sdk loaded lazily on demand).
+import { run } from "../src/index.mjs";
+run(process.argv.slice(2)).catch((err) => {
+  process.stderr.write(`\nmangomagic: ${err?.message ?? err}\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@mangomagic/cli",
+  "version": "0.1.0",
+  "description": "MangoMagic CLI — sign in, manage episodes, and expose MangoMagic to MCP clients (Claude Desktop, Cursor).",
+  "type": "module",
+  "bin": {
+    "mangomagic": "bin/mangomagic.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "node ./bin/mangomagic.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4"
+  },
+  "keywords": ["mangomagic", "cli", "mcp", "podcast"],
+  "license": "MIT"
+}

package/src/api.mjs

@@ -0,0 +1,27 @@
+import { FN_BASE, SUPABASE_ANON_KEY } from "./config.mjs";
+import { loadToken, clearToken } from "./auth/token-store.mjs";
+
+// Helper: call any Supabase edge function with the user's PAT.
+export async function apiCall(path, { method = "POST", body, query } = {}) {
+  const creds = loadToken();
+  if (!creds) throw new Error("Not signed in. Run `mangomagic login` first.");
+  const qs = query ? "?" + new URLSearchParams(query).toString() : "";
+  const res = await fetch(`${FN_BASE}/${path}${qs}`, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${creds.token}`,
+      "apikey": SUPABASE_ANON_KEY,
+      "x-mangomagic-cli": "1",
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await res.text();
+  let json; try { json = JSON.parse(text); } catch { json = { raw: text }; }
+  if (res.status === 401) {
+    clearToken();
+    throw new Error("Your CLI token was rejected. Run `mangomagic login` again.");
+  }
+  if (!res.ok) throw new Error(json.error ?? `HTTP ${res.status}`);
+  return json;
+}

package/src/auth/device-flow.mjs

@@ -0,0 +1,73 @@
+// Browser-device OAuth-style flow against the cli-device-authorize / cli-device-poll edge fns.
+import { FN_BASE, SUPABASE_ANON_KEY } from "../config.mjs";
+import { spawn } from "node:child_process";
+import { hostname, platform } from "node:os";
+
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open"
+            : process.platform === "win32"  ? "cmd"
+            : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function call(path, body) {
+  const res = await fetch(`${FN_BASE}/${path}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${SUPABASE_ANON_KEY}`,
+      "apikey": SUPABASE_ANON_KEY,
+    },
+    body: JSON.stringify(body ?? {}),
+  });
+  const text = await res.text();
+  let json; try { json = JSON.parse(text); } catch { json = { error: text }; }
+  if (!res.ok) throw new Error(json.error ?? `HTTP ${res.status}`);
+  return json;
+}
+
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+
+export async function deviceLogin({ onCode, onWaiting, openInBrowser = true } = {}) {
+  const client_name = `${hostname()} (${platform()})`;
+  const start = await call("cli-device-authorize", { client_name });
+
+  onCode?.(start);
+  if (openInBrowser) openBrowser(start.verification_uri_complete);
+
+  const deadline = Date.now() + (start.expires_in ?? 600) * 1000;
+  let interval = (start.interval ?? 2) * 1000;
+
+  while (Date.now() < deadline) {
+    await sleep(interval);
+    onWaiting?.();
+    let poll;
+    try {
+      poll = await call("cli-device-poll", { device_code: start.device_code });
+    } catch (e) {
+      // transient — back off slightly
+      interval = Math.min(interval + 1000, 8000);
+      continue;
+    }
+    if (poll.status === "approved") {
+      return {
+        token: poll.token,
+        userId: poll.user_id,
+        patId: poll.pat_id,
+        approvedAt: new Date().toISOString(),
+      };
+    }
+    if (poll.status === "expired" || poll.status === "denied" || poll.status === "unknown") {
+      throw new Error(`device flow ${poll.status}. Run \`mangomagic login\` again.`);
+    }
+    // pending → keep polling
+  }
+  throw new Error("device flow timed out. Run `mangomagic login` again.");
+}

package/src/auth/token-store.mjs

@@ -0,0 +1,30 @@
+// Token cache at ~/.mangomagic/credentials.json (mode 0600).
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync, unlinkSync, existsSync, chmodSync } from "node:fs";
+
+const dir = join(homedir(), ".mangomagic");
+const file = join(dir, "credentials.json");
+
+export function loadToken() {
+  if (!existsSync(file)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(file, "utf8"));
+    if (raw && typeof raw.token === "string") return raw;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function saveToken(payload) {
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(file, JSON.stringify(payload, null, 2));
+  try { chmodSync(file, 0o600); } catch { /* windows */ }
+}
+
+export function clearToken() {
+  if (existsSync(file)) unlinkSync(file);
+}
+
+export function credentialsPath() { return file; }

package/src/config.mjs

@@ -0,0 +1,6 @@
+// Public config baked into the CLI. Both values are publishable (anon key + project ref).
+export const SUPABASE_URL = "https://wrjrteflzlknniuluyxh.supabase.co";
+export const SUPABASE_ANON_KEY =
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6IndyanJ0ZWZsemxrbm5pdWx1eXhoIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjY1OTQ1MTQsImV4cCI6MjA4MjE3MDUxNH0.pFYXrSFjeHGXEAui54hoQbU0JQPaarnjAy-GeDIk1qM";
+export const APP_ORIGIN = "https://mangomagic.live";
+export const FN_BASE = `${SUPABASE_URL}/functions/v1`;

package/src/index.mjs

@@ -0,0 +1,98 @@
+import { deviceLogin } from "./auth/device-flow.mjs";
+import { loadToken, saveToken, clearToken, credentialsPath } from "./auth/token-store.mjs";
+import { playSplash } from "./ui/splash.mjs";
+
+const GOLD = "\x1b[38;2;241;171;28m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+
+function help() {
+  process.stdout.write(`
+${BOLD}mangomagic${RESET}  ${DIM}— sign into MangoMagic and bring your account into your terminal.${RESET}
+
+  ${GOLD}mangomagic login${RESET}       Authorize this terminal (opens your browser).
+  ${GOLD}mangomagic logout${RESET}      Forget the token cached on this machine.
+  ${GOLD}mangomagic whoami${RESET}      Show the cached identity.
+  ${GOLD}mangomagic splash${RESET}      Play the MangoMagic splash animation.
+  ${GOLD}mangomagic mcp${RESET}         Run as a stdio MCP server (for Claude Desktop / Cursor).
+  ${GOLD}mangomagic mcp-config${RESET}  Print MCP client config for copy-paste.
+  ${GOLD}mangomagic help${RESET}        This message.
+
+Token cache: ${credentialsPath()}
+`);
+}
+
+async function login() {
+  if (loadToken()) {
+    process.stdout.write(`${DIM}You're already signed in. Run \`mangomagic logout\` first to switch accounts.${RESET}\n`);
+    await playSplash({ greetingLine: "Welcome back to MangoMagic." });
+    return;
+  }
+
+  await deviceLogin({
+    onCode: (start) => {
+      process.stdout.write(`
+${BOLD}Sign in to MangoMagic${RESET}
+
+  Visit:  ${GOLD}${start.verification_uri_complete}${RESET}
+  Code:   ${BOLD}${start.user_code}${RESET}
+
+  ${DIM}Waiting for approval...${RESET}
+`);
+    },
+    onWaiting: () => { process.stdout.write("."); },
+  }).then(async (creds) => {
+    saveToken(creds);
+    process.stdout.write("\n\n");
+    await playSplash({ greetingLine: "You're in. Welcome to MangoMagic." });
+  });
+}
+
+function logout() {
+  clearToken();
+  process.stdout.write("Signed out.\n");
+}
+
+function whoami() {
+  const t = loadToken();
+  if (!t) { process.stdout.write("Not signed in.\n"); return; }
+  process.stdout.write(`Signed in (user ${t.userId ?? "?"}), approved ${t.approvedAt}\n`);
+}
+
+async function mcpServer() {
+  // Lazy-load so users who only run `login` don't pay the import cost.
+  const { startMcpServer } = await import("./mcp/server.mjs");
+  await startMcpServer();
+}
+
+function mcpConfig() {
+  const cfg = {
+    mcpServers: {
+      mangomagic: {
+        command: "npx",
+        args: ["-y", "@mangomagic/cli", "mcp"],
+      },
+    },
+  };
+  process.stdout.write(JSON.stringify(cfg, null, 2) + "\n");
+}
+
+export async function run(argv) {
+  const cmd = argv[0] ?? (loadToken() ? "splash" : "login");
+  switch (cmd) {
+    case "login":      return login();
+    case "logout":     return logout();
+    case "whoami":     return whoami();
+    case "splash":     return playSplash({ mode: argv.includes("--loop") ? "loop" : argv.includes("--static") ? "static" : "anim" });
+    case "mcp":        return mcpServer();
+    case "mcp-config": return mcpConfig();
+    case "help":
+    case "--help":
+    case "-h":         return help();
+    default:
+      process.stderr.write(`Unknown command: ${cmd}\n`);
+      help();
+      process.exit(2);
+  }
+}

package/src/mcp/server.mjs

@@ -0,0 +1,78 @@
+// Stdio MCP server exposing a small set of MangoMagic tools to clients like
+// Claude Desktop and Cursor. All tools call existing edge functions using the
+// user's CLI PAT cached at ~/.mangomagic/credentials.json.
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { apiCall } from "../api.mjs";
+import { loadToken } from "../auth/token-store.mjs";
+
+const TOOLS = [
+  {
+    name: "list_episodes",
+    description: "List the signed-in user's MangoMagic episodes (most recent first).",
+    inputSchema: {
+      type: "object",
+      properties: { limit: { type: "integer", minimum: 1, maximum: 50, default: 10 } },
+    },
+    handler: async ({ limit = 10 }) => apiCall("cli-list-episodes", { body: { limit } }),
+  },
+  {
+    name: "get_episode",
+    description: "Get full details for one episode (transcript, summary, takeaways) by ID or slug.",
+    inputSchema: {
+      type: "object",
+      properties: { episode: { type: "string", description: "Episode id or slug" } },
+      required: ["episode"],
+    },
+    handler: async ({ episode }) => apiCall("cli-get-episode", { body: { episode } }),
+  },
+  {
+    name: "search_episodes",
+    description: "Full-text search across the signed-in user's episodes.",
+    inputSchema: {
+      type: "object",
+      properties: { query: { type: "string" } },
+      required: ["query"],
+    },
+    handler: async ({ query }) => apiCall("cli-search-episodes", { body: { query } }),
+  },
+];
+
+export async function startMcpServer() {
+  if (!loadToken()) {
+    process.stderr.write("MangoMagic MCP: not signed in. Run `npx mangomagic login` first.\n");
+    process.exit(1);
+  }
+
+  const server = new Server(
+    { name: "mangomagic", version: "0.1.0" },
+    { capabilities: { tools: {} } },
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })),
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const tool = TOOLS.find(t => t.name === req.params.name);
+    if (!tool) {
+      return { isError: true, content: [{ type: "text", text: `Unknown tool ${req.params.name}` }] };
+    }
+    try {
+      const result = await tool.handler(req.params.arguments ?? {});
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: err?.message ?? String(err) }],
+      };
+    }
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

package/src/ui/splash.mjs

@@ -0,0 +1,243 @@
+// TypeScript-ish JS port of mango_banner.py. Pure-Node, zero deps.
+// Renders to process.stdout. Falls back to a plain banner if the terminal
+// can't do truecolor or isn't a TTY.
+
+const ICON = [
+  "⣀          ",
+  "⣿⣷⣦⣄⡀      ",
+  "⣿⣿⣿⣿⣿⣷⣦⣄⡀  ",
+  "⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣄",
+  "⣿⣿⣿⣿⣿⣿⣿⣿⠿⠛⠁",
+  "⣿⣿⣿⣿⣿⠿⠛⠁   ",
+  "⠿⠛⠁        ",
+];
+
+const WORDMARK = [
+  "███╗   ███╗ █████╗ ███╗   ██╗ ██████╗  ██████╗ ",
+  "████╗ ████║██╔══██╗████╗  ██║██╔════╝ ██╔═══██╗",
+  "██╔████╔██║███████║██╔██╗ ██║██║  ███╗██║   ██║",
+  "██║╚██╔╝██║██╔══██║██║╚██╗██║██║   ██║██║   ██║",
+  "██║ ╚═╝ ██║██║  ██║██║ ╚████║╚██████╔╝╚██████╔╝",
+  "╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝ ╚═════╝  ╚═════╝ ",
+];
+
+const SUBMARK = "M A G I C";
+const TAGLINE = "Amplifying Human Signal  ::  by ManyMangoes";
+
+const ICON_X = 2;
+const ICON_GAP = 3;
+const WORD_X = ICON_X + 11 + ICON_GAP;
+
+const GOLD   = [241, 171, 28];
+const HOT    = [255, 232, 150];
+const DEEP   = [140, 95, 14];
+const WHITEC = [255, 255, 255];
+const DIMC   = [110, 78, 12];
+
+const RESET = "\x1b[0m";
+
+const rgb = (c) => `\x1b[38;2;${c[0]};${c[1]};${c[2]}m`;
+const lerp = (a, b, t) => [
+  Math.round(a[0] + (b[0] - a[0]) * t),
+  Math.round(a[1] + (b[1] - a[1]) * t),
+  Math.round(a[2] + (b[2] - a[2]) * t),
+];
+
+// Chars use codepoints, not byte length.
+const chars = (s) => Array.from(s);
+
+const TAU = Math.PI * 2;
+const rand = (a, b) => a + Math.random() * (b - a);
+const randInt = (a, b) => Math.floor(rand(a, b + 1));
+
+function supportsColor() {
+  if (process.env.NO_COLOR) return false;
+  if (!process.stdout.isTTY) return false;
+  if (process.env.TERM === "dumb") return false;
+  // truecolor support
+  return /(?:truecolor|24bit)/i.test(process.env.COLORTERM ?? "") || true;
+}
+
+class Star {
+  constructor(w, h) {
+    this.x = randInt(0, w - 1);
+    this.y = randInt(0, h - 1);
+    this.depth = Math.random();
+    this.phase = rand(0, TAU);
+    this.ch = "✦✧*+·.".charAt(randInt(0, 5));
+  }
+  colour(frame) {
+    const tw = 0.5 + 0.5 * Math.sin(frame * 0.4 + this.phase);
+    const base = lerp(DIMC, WHITEC, this.depth);
+    return [lerp(DEEP, base, tw), tw > 0.35];
+  }
+}
+
+class Shooter {
+  constructor(w, h) {
+    this.x = randInt(Math.floor(w / 2), w - 1);
+    this.y = randInt(0, Math.max(1, Math.floor(h / 2)));
+    this.life = 0;
+    this.len = randInt(4, 7);
+  }
+}
+
+function shimmer(col, row, frame, lit = false) {
+  const band = (frame * 1.8) % 60;
+  const d = Math.abs((col + row * 1.3) - band);
+  if (lit) {
+    const pulse = 0.5 + 0.5 * Math.sin(frame * 0.5);
+    return lerp(GOLD, HOT, 0.4 + 0.6 * pulse);
+  }
+  if (d < 2.5) return lerp(GOLD, HOT, 1 - d / 2.5);
+  if (d < 6)   return lerp(HOT, GOLD, (d - 2.5) / 3.5);
+  return GOLD;
+}
+
+function layout() {
+  const width = Math.min(process.stdout.columns || 80, 80);
+  const iconH = ICON.length, wordH = WORDMARK.length;
+  const blockH = Math.max(iconH, wordH + 1);
+  const height = blockH + 5;
+  const top = 2;
+  const iconTop = top + Math.floor((blockH - iconH) / 2);
+  const wordTop = top + Math.floor((blockH - (wordH + 1)) / 2);
+  return { width, height, iconTop, wordTop };
+}
+
+function inLogo(col, row, iconTop, wordTop) {
+  if (row >= iconTop && row < iconTop + ICON.length && col >= ICON_X && col < ICON_X + 12) return true;
+  if (row >= wordTop && row < wordTop + WORDMARK.length + 1 && col >= WORD_X && col < WORD_X + 48) return true;
+  return false;
+}
+
+function render(width, height, iconTop, wordTop, stars, shooters, frame) {
+  const grid = Array.from({ length: height }, () => new Array(width).fill(" "));
+  const colr = Array.from({ length: height }, () => new Array(width).fill(null));
+
+  for (const s of stars) {
+    if (inLogo(s.x, s.y, iconTop, wordTop)) continue;
+    const [c, on] = s.colour(frame);
+    if (on) { grid[s.y][s.x] = s.ch; colr[s.y][s.x] = c; }
+  }
+
+  for (const sh of shooters) {
+    for (let k = 0; k < sh.len; k++) {
+      const x = sh.x - k, y = sh.y + Math.floor(k / 2);
+      if (x >= 0 && x < width && y >= 0 && y < height && !inLogo(x, y, iconTop, wordTop)) {
+        const t = 1 - k / sh.len;
+        grid[y][x] = k === 0 ? "✦" : (k % 2 === 0 ? "─" : "╲");
+        colr[y][x] = lerp(GOLD, WHITEC, t);
+      }
+    }
+  }
+
+  for (let r = 0; r < ICON.length; r++) {
+    const line = chars(ICON[r]);
+    const ry = iconTop + r;
+    const lastNonSpace = line.join("").trimEnd().length;
+    for (let c = 0; c < line.length; c++) {
+      const ch = line[c];
+      if (ch === " ") continue;
+      const cx = ICON_X + c;
+      const lit = (c >= lastNonSpace - 3) && (r === 3 || r === 4);
+      grid[ry][cx] = ch;
+      colr[ry][cx] = shimmer(cx, ry, frame, lit);
+    }
+  }
+
+  for (let r = 0; r < WORDMARK.length; r++) {
+    const line = chars(WORDMARK[r]);
+    const ry = wordTop + r;
+    for (let c = 0; c < line.length; c++) {
+      const ch = line[c];
+      if (ch === " ") continue;
+      const cx = WORD_X + c;
+      grid[ry][cx] = ch;
+      colr[ry][cx] = shimmer(cx, ry, frame);
+    }
+  }
+
+  const sy = wordTop + WORDMARK.length;
+  const sx = WORD_X + 30;
+  for (let c = 0; c < SUBMARK.length; c++) {
+    const ch = SUBMARK[c];
+    if (ch === " ") continue;
+    if (sx + c < width) {
+      grid[sy][sx + c] = ch;
+      colr[sy][sx + c] = lerp(GOLD, DEEP, 0.3);
+    }
+  }
+
+  const lines = [];
+  for (let y = 0; y < height; y++) {
+    const buf = [];
+    let last = null;
+    for (let x = 0; x < width; x++) {
+      const ch = grid[y][x];
+      if (ch === " ") { buf.push(" "); last = null; continue; }
+      const c = colr[y][x] ?? GOLD;
+      if (!last || c[0] !== last[0] || c[1] !== last[1] || c[2] !== last[2]) {
+        buf.push(rgb(c));
+        last = c;
+      }
+      buf.push(ch);
+    }
+    buf.push(RESET);
+    lines.push(buf.join(""));
+  }
+  return lines.join("\n");
+}
+
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+
+export async function playSplash({ mode = "anim", greetingLine = null } = {}) {
+  if (!supportsColor()) {
+    for (const l of WORDMARK) process.stdout.write(l + "\n");
+    process.stdout.write("M A G I C\n");
+    process.stdout.write(TAGLINE + "\n");
+    if (greetingLine) process.stdout.write("\n" + greetingLine + "\n");
+    return;
+  }
+
+  const { width, height, iconTop, wordTop } = layout();
+  const stars = Array.from(
+    { length: Math.max(20, Math.floor((width * height) / 26)) },
+    () => new Star(width, height),
+  );
+  let shooters = [];
+  const tag = `  ${rgb(lerp(GOLD, DEEP, 0.25))}${TAGLINE}${RESET}`;
+  const greet = greetingLine ? `\n  ${rgb(lerp(GOLD, HOT, 0.5))}${greetingLine}${RESET}\n` : "";
+
+  const renderSettled = () => render(width, height, iconTop, wordTop, stars, [], 7);
+
+  if (mode === "static") {
+    process.stdout.write(renderSettled() + "\n\n" + tag + greet + "\n");
+    return;
+  }
+
+  const fps = 14;
+  const total = mode === "loop" ? Number.MAX_SAFE_INTEGER : Math.floor(2.8 * fps);
+
+  process.stdout.write("\x1b[?25l"); // hide cursor
+  let interrupted = false;
+  const onSig = () => { interrupted = true; };
+  process.on("SIGINT", onSig);
+
+  try {
+    for (let f = 0; f < total && !interrupted; f++) {
+      if (Math.random() < 0.08 && shooters.length < 2) shooters.push(new Shooter(width, height));
+      for (const sh of shooters) sh.life += 1;
+      shooters = shooters.filter(s => s.life < 6);
+      process.stdout.write("\x1b[H\x1b[2J");
+      process.stdout.write(render(width, height, iconTop, wordTop, stars, shooters, f));
+      process.stdout.write("\n\n" + tag + greet + "\n");
+      await sleep(1000 / fps);
+    }
+  } finally {
+    process.off("SIGINT", onSig);
+    process.stdout.write("\x1b[H\x1b[2J");
+    process.stdout.write(renderSettled());
+    process.stdout.write("\n\n" + tag + greet + "\n\x1b[?25h");
+  }
+}