@mauricode/token-derby 0.1.0

package/dist/bin.js

@@ -0,0 +1,1216 @@
+#!/usr/bin/env node
+
+// src/commands/stable-create.ts
+import React2 from "react";
+import { render } from "ink";
+
+// src/ui/HorseCreator.tsx
+import { useState } from "react";
+import { Box as Box2, Text as Text2, useInput } from "ink";
+import TextInput from "ink-text-input";
+
+// src/ui/HorseSprite.tsx
+import { Box, Text } from "ink";
+
+// src/ui/sprite.ts
+var FIXED_COLORS = {
+  E: "#000000",
+  H: "#1F1108"
+};
+var MAIN_ROWS = [
+  "................................",
+  "................................",
+  "..........................MMM...",
+  "..........................MMM...",
+  ".........................MBBEBB.",
+  ".........................MBBEBB.",
+  "........................MBBBBBBB",
+  "........................MBBBBBBB",
+  "..................MMMMMMMBBB....",
+  "..................MMMMMMMBBB....",
+  "....BBBBBBBBSSSSSSMMBBBBBB......",
+  "...BBBBBBBBBSSSSSSMMBBBBBB......",
+  ".TTBBBBBBBBBSSSSSSBBBBBBBB......",
+  ".TTBBBBBBBBBSSSSSSBBBBBBBB......",
+  "TTTBBBBBBBBBBBBBBBBBBBBBBB......",
+  "TTTBBBBBBBBBBBBBBBBBBBBB........",
+  "...BBB.BBB.....BBB.BBB..........",
+  "...BBB.BBB.....BBB.BBB..........",
+  "....BB..BB......BB..BB..........",
+  "....BB..BB......BB..BB..........",
+  "....BB..BB......BB..BB..........",
+  "....BB..BB......BB..BB..........",
+  "....BB..BB......BB..BB..........",
+  "...HHH.HHH.....HHH.HHH.........."
+];
+var MINI_ROWS = [
+  ".BBSSMBB",
+  ".BBSSMBB",
+  "TBBBBBB.",
+  "THH..HH."
+];
+var MAIN_SPRITE = parse(MAIN_ROWS, 32, 24);
+var MINI_SPRITE = parse(MINI_ROWS, 8, 4);
+function parse(rows, width, height) {
+  if (rows.length !== height) {
+    throw new Error(`sprite has ${rows.length} rows, expected ${height}`);
+  }
+  return rows.map((row, y) => {
+    if (row.length !== width) {
+      throw new Error(`sprite row ${y} has length ${row.length}, expected ${width}`);
+    }
+    return [...row].map((c) => toTag(c));
+  });
+}
+function toTag(c) {
+  switch (c) {
+    case "B":
+      return "B";
+    case "M":
+      return "M";
+    case "T":
+      return "T";
+    case "S":
+      return "S";
+    case "E":
+      return "E";
+    case "H":
+      return "H";
+    case ".":
+      return null;
+    default:
+      throw new Error(`unknown sprite char: ${c}`);
+  }
+}
+
+// src/ui/sprite-render.ts
+function renderSprite(sprite, colors) {
+  const out = [];
+  for (let y = 0; y + 1 < sprite.length || y < sprite.length; y += 2) {
+    const topRow = sprite[y];
+    const bottomRow = sprite[y + 1];
+    if (!topRow) break;
+    const row = [];
+    for (let x = 0; x < topRow.length; x++) {
+      row.push({
+        top: tagColor(topRow[x] ?? null, colors),
+        bottom: tagColor(bottomRow?.[x] ?? null, colors)
+      });
+    }
+    out.push(row);
+    if (!bottomRow) break;
+  }
+  return out;
+}
+function tagColor(tag, colors) {
+  if (tag === null) return null;
+  if (tag === "E") return FIXED_COLORS.E;
+  if (tag === "H") return FIXED_COLORS.H;
+  if (tag === "B") return colors.body;
+  if (tag === "M") return colors.mane;
+  if (tag === "T") return colors.tail;
+  if (tag === "S") return colors.saddle;
+  return null;
+}
+
+// src/ui/HorseSprite.tsx
+import { jsx } from "react/jsx-runtime";
+function HorseSprite({ sprite, colors }) {
+  const grid = renderSprite(sprite, colors);
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: grid.map((row, y) => /* @__PURE__ */ jsx(Text, { children: rowToAnsi(row) }, y)) });
+}
+function rowToAnsi(row) {
+  let out = "";
+  for (const cell of row) {
+    if (cell.top === null && cell.bottom === null) {
+      out += " ";
+    } else if (cell.top !== null && cell.bottom !== null) {
+      out += ansiFg(cell.top) + ansiBg(cell.bottom) + "\u2580" + RESET;
+    } else if (cell.top !== null) {
+      out += ansiFg(cell.top) + "\u2580" + RESET;
+    } else {
+      out += ansiFg(cell.bottom) + "\u2584" + RESET;
+    }
+  }
+  return out;
+}
+var RESET = "\x1B[0m";
+function hexToRgb(hex) {
+  const h = hex.replace("#", "");
+  return [
+    parseInt(h.slice(0, 2), 16),
+    parseInt(h.slice(2, 4), 16),
+    parseInt(h.slice(4, 6), 16)
+  ];
+}
+function ansiFg(hex) {
+  const [r, g, b] = hexToRgb(hex);
+  return `\x1B[38;2;${r};${g};${b}m`;
+}
+function ansiBg(hex) {
+  const [r, g, b] = hexToRgb(hex);
+  return `\x1B[48;2;${r};${g};${b}m`;
+}
+
+// src/ui/palette.ts
+var SLOTS = ["body", "mane", "tail", "saddle"];
+var PALETTES = {
+  body: [
+    "#8B4513",
+    "#A0522D",
+    "#D2691E",
+    "#CD853F",
+    "#DEB887",
+    "#F5DEB3",
+    "#FFFFFF",
+    "#000000",
+    "#4A2C2A",
+    "#5D3A1A",
+    "#704214",
+    "#9C5919",
+    "#B87333",
+    "#E5B783",
+    "#F0E1C9",
+    "#2F1B0C"
+  ],
+  mane: [
+    "#000000",
+    "#1C1C1C",
+    "#2F1B0C",
+    "#4A2C2A",
+    "#5D3A1A",
+    "#8B4513",
+    "#FFFFFF",
+    "#F5F5DC",
+    "#DEB887",
+    "#CD853F",
+    "#FF4500",
+    "#B22222",
+    "#191970",
+    "#4B0082",
+    "#2E8B57",
+    "#FFD700"
+  ],
+  tail: [
+    "#000000",
+    "#1C1C1C",
+    "#2F1B0C",
+    "#4A2C2A",
+    "#5D3A1A",
+    "#8B4513",
+    "#FFFFFF",
+    "#F5F5DC",
+    "#DEB887",
+    "#CD853F",
+    "#FF4500",
+    "#B22222",
+    "#191970",
+    "#4B0082",
+    "#2E8B57",
+    "#FFD700"
+  ],
+  saddle: [
+    "#C0392B",
+    "#922B21",
+    "#7B241C",
+    "#641E16",
+    "#1F618D",
+    "#21618C",
+    "#1B4F72",
+    "#0E6655",
+    "#117A65",
+    "#196F3D",
+    "#7D6608",
+    "#9A7D0A",
+    "#6E2C00",
+    "#4D5656",
+    "#212F3D",
+    "#000000"
+  ]
+};
+function nextColor(slot, current) {
+  const palette = PALETTES[slot];
+  const idx = palette.indexOf(current);
+  return palette[(idx + 1 + palette.length) % palette.length] ?? palette[0];
+}
+function prevColor(slot, current) {
+  const palette = PALETTES[slot];
+  const idx = palette.indexOf(current);
+  if (idx < 0) return palette[0];
+  return palette[(idx - 1 + palette.length) % palette.length];
+}
+function defaultColors() {
+  return {
+    body: PALETTES.body[0],
+    mane: PALETTES.mane[0],
+    tail: PALETTES.tail[0],
+    saddle: PALETTES.saddle[0]
+  };
+}
+
+// src/ui/HorseCreator.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function HorseCreator({ onSubmit, onCancel, initialColors, initialName }) {
+  const [colors, setColors] = useState(initialColors ?? defaultColors());
+  const [slotIdx, setSlotIdx] = useState(0);
+  const [namingMode, setNamingMode] = useState(false);
+  const [name, setName] = useState(initialName ?? "");
+  const [error, setError] = useState(null);
+  const slot = SLOTS[slotIdx];
+  useInput((input, key) => {
+    if (namingMode) return;
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.upArrow) {
+      setSlotIdx((slotIdx - 1 + SLOTS.length) % SLOTS.length);
+      return;
+    }
+    if (key.downArrow) {
+      setSlotIdx((slotIdx + 1) % SLOTS.length);
+      return;
+    }
+    if (key.leftArrow) {
+      setColors({ ...colors, [slot]: prevColor(slot, colors[slot]) });
+      return;
+    }
+    if (key.rightArrow) {
+      setColors({ ...colors, [slot]: nextColor(slot, colors[slot]) });
+      return;
+    }
+    if (key.return) {
+      setNamingMode(true);
+      return;
+    }
+  });
+  const handleNameSubmit = (value) => {
+    if (!value.trim()) {
+      setError("Name required");
+      return;
+    }
+    onSubmit(value.trim(), colors);
+  };
+  return /* @__PURE__ */ jsxs(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Box2, { marginBottom: 1, children: /* @__PURE__ */ jsx2(HorseSprite, { sprite: MAIN_SPRITE, colors }) }),
+    /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: SLOTS.map((s, i) => /* @__PURE__ */ jsxs(Text2, { children: [
+      i === slotIdx ? "\u25BA" : " ",
+      " ",
+      s.padEnd(7),
+      " ",
+      /* @__PURE__ */ jsx2(Text2, { color: colors[s], children: "\u2588\u2588" }),
+      " ",
+      colors[s]
+    ] }, s)) }),
+    !namingMode && /* @__PURE__ */ jsx2(Box2, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2191/\u2193 select slot \xB7 \u2190/\u2192 cycle color \xB7 Enter accept \xB7 Esc cancel" }) }),
+    namingMode && /* @__PURE__ */ jsxs(Box2, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Text2, { children: "Name your horse: " }),
+      /* @__PURE__ */ jsx2(TextInput, { value: name, onChange: (v) => {
+        setName(v);
+        setError(null);
+      }, onSubmit: handleNameSubmit }),
+      error && /* @__PURE__ */ jsx2(Text2, { color: "red", children: error })
+    ] })
+  ] });
+}
+
+// src/stable/stable.ts
+import * as fs from "fs/promises";
+
+// src/paths.ts
+import * as os from "os";
+import * as path from "path";
+function homeDir() {
+  return process.env.TOKEN_DERBY_HOME ?? path.join(os.homedir(), ".token-derby");
+}
+function stableFile() {
+  return path.join(homeDir(), "stable.json");
+}
+function activeRaceFile(joinCode) {
+  return path.join(homeDir(), "active-races", `${joinCode}.json`);
+}
+function activeRacesDir() {
+  return path.join(homeDir(), "active-races");
+}
+function claudeProjectsDir() {
+  return process.env.TOKEN_DERBY_CLAUDE_DIR ?? path.join(os.homedir(), ".claude", "projects");
+}
+
+// src/stable/stable.ts
+async function loadStable() {
+  try {
+    const raw = await fs.readFile(stableFile(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.horses)) return { horses: [] };
+    return parsed;
+  } catch (e) {
+    if (e?.code === "ENOENT") return { horses: [] };
+    if (e instanceof SyntaxError) return { horses: [] };
+    throw e;
+  }
+}
+async function saveStable(stable) {
+  await fs.mkdir(homeDir(), { recursive: true });
+  await fs.writeFile(stableFile(), JSON.stringify(stable, null, 2) + "\n", "utf8");
+}
+async function upsertHorse(horse) {
+  const stable = await loadStable();
+  const idx = stable.horses.findIndex((h) => h.name === horse.name);
+  if (idx >= 0) stable.horses[idx] = horse;
+  else stable.horses.push(horse);
+  await saveStable(stable);
+}
+async function removeHorse(name) {
+  const stable = await loadStable();
+  stable.horses = stable.horses.filter((h) => h.name !== name);
+  await saveStable(stable);
+}
+function findHorse(stable, name) {
+  return stable.horses.find((h) => h.name === name);
+}
+
+// src/commands/stable-create.ts
+import * as readline from "readline/promises";
+import { stdin, stdout } from "process";
+async function stableCreateCommand() {
+  let exitCode = 0;
+  const app = render(
+    React2.createElement(HorseCreator, {
+      onSubmit: async (name, colors) => {
+        const stable = await loadStable();
+        const existing = findHorse(stable, name);
+        if (existing) {
+          app.unmount();
+          const rl = readline.createInterface({ input: stdin, output: stdout });
+          const answer = (await rl.question(`Horse "${name}" already exists. Overwrite? [y/N] `)).trim().toLowerCase();
+          rl.close();
+          if (answer !== "y" && answer !== "yes") {
+            console.log("Cancelled.");
+            exitCode = 1;
+            return;
+          }
+        }
+        await upsertHorse({ name, colors, created_at: (/* @__PURE__ */ new Date()).toISOString() });
+        app.unmount();
+        console.log(`\u2713 Saved "${name}" to your stable.`);
+      },
+      onCancel: () => {
+        app.unmount();
+        console.log("Cancelled.");
+        exitCode = 1;
+      }
+    })
+  );
+  await app.waitUntilExit();
+  return exitCode;
+}
+
+// src/commands/stable-list.tsx
+import React3 from "react";
+import { render as render2, Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+async function stableListCommand() {
+  const stable = await loadStable();
+  if (stable.horses.length === 0) {
+    console.log("Your stable is empty. Run `token-derby stable create` to add a horse.");
+    return 0;
+  }
+  const app = render2(
+    React3.createElement(StableList, { horses: stable.horses })
+  );
+  await app.waitUntilExit();
+  return 0;
+}
+function StableList({ horses }) {
+  React3.useEffect(() => {
+    setImmediate(() => process.exit(0));
+  }, []);
+  return /* @__PURE__ */ jsxs2(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Text3, { bold: true, children: [
+      "Your stable (",
+      horses.length,
+      "):"
+    ] }),
+    horses.map((h) => /* @__PURE__ */ jsxs2(Box3, { flexDirection: "row", marginTop: 1, children: [
+      /* @__PURE__ */ jsx3(HorseSprite, { sprite: MINI_SPRITE, colors: h.colors }),
+      /* @__PURE__ */ jsxs2(Text3, { children: [
+        "  ",
+        h.name
+      ] })
+    ] }, h.name))
+  ] });
+}
+
+// src/commands/stable-delete.ts
+import * as readline2 from "readline/promises";
+import { stdin as stdin2, stdout as stdout2 } from "process";
+
+// src/stable/active-race.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+async function loadActiveRace(joinCode) {
+  try {
+    const raw = await fs2.readFile(activeRaceFile(joinCode), "utf8");
+    return JSON.parse(raw);
+  } catch (e) {
+    if (e?.code === "ENOENT") return null;
+    throw e;
+  }
+}
+async function saveActiveRace(active) {
+  await fs2.mkdir(activeRacesDir(), { recursive: true });
+  await fs2.writeFile(
+    activeRaceFile(active.join_code),
+    JSON.stringify(active, null, 2) + "\n",
+    "utf8"
+  );
+}
+async function listActiveRaces() {
+  try {
+    const entries = await fs2.readdir(activeRacesDir());
+    return entries.filter((f) => f.endsWith(".json")).map((f) => path2.basename(f, ".json"));
+  } catch (e) {
+    if (e?.code === "ENOENT") return [];
+    throw e;
+  }
+}
+
+// src/commands/stable-delete.ts
+async function stableDeleteCommand(name) {
+  if (!name) {
+    console.error("Usage: token-derby stable delete <name>");
+    return 2;
+  }
+  const stable = await loadStable();
+  const horse = findHorse(stable, name);
+  if (!horse) {
+    console.error(`No horse named "${name}" in your stable.`);
+    return 1;
+  }
+  const codes = await listActiveRaces();
+  for (const code of codes) {
+    const active = await loadActiveRace(code);
+    if (active?.horse_name === name) {
+      console.error(`"${name}" is currently running in race ${code}. Close that terminal first.`);
+      return 1;
+    }
+  }
+  const rl = readline2.createInterface({ input: stdin2, output: stdout2 });
+  const answer = (await rl.question(`Delete "${name}" from your stable? [y/N] `)).trim().toLowerCase();
+  rl.close();
+  if (answer !== "y" && answer !== "yes") {
+    console.log("Cancelled.");
+    return 1;
+  }
+  await removeHorse(name);
+  console.log(`\u2713 Deleted "${name}".`);
+  return 0;
+}
+
+// src/commands/create.ts
+import * as readline3 from "readline/promises";
+import { stdin as stdin3, stdout as stdout3 } from "process";
+
+// src/config.ts
+var DEFAULT_API_BASE = "https://token-derby.mauricode.co.uk/api";
+function apiBase() {
+  return process.env.TOKEN_DERBY_API_BASE ?? DEFAULT_API_BASE;
+}
+var HEARTBEAT_INTERVAL_MS = 6e4;
+var POLL_INTERVAL_MS = 3e3;
+var HEARTBEAT_RETRY_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 15e3];
+
+// src/api/client.ts
+var ApiError = class extends Error {
+  constructor(code, message, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "ApiError";
+  }
+  code;
+  status;
+};
+async function request(method, path4, body, authToken, fetchImpl = fetch) {
+  const url = path4.startsWith("http") ? path4 : `${apiBase()}${path4}`;
+  const headers = {};
+  if (authToken) headers["authorization"] = `Bearer ${authToken}`;
+  if (body !== void 0) headers["content-type"] = "application/json";
+  let res;
+  try {
+    res = await fetchImpl(url, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  } catch (e) {
+    throw new ApiError("NETWORK_ERROR", e?.message ?? "fetch failed", 0);
+  }
+  const text = await res.text();
+  const contentType = res.headers.get("content-type") ?? "";
+  let parsed = null;
+  if (contentType.includes("application/json") && text.length > 0) {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = null;
+    }
+  }
+  if (!res.ok) {
+    if (parsed && typeof parsed.code === "string") {
+      throw new ApiError(parsed.code, parsed.message ?? "API error", res.status);
+    }
+    throw new ApiError("NETWORK_ERROR", `HTTP ${res.status}`, res.status);
+  }
+  return parsed;
+}
+
+// src/api/endpoints.ts
+function createRace(body) {
+  return request("POST", "/races", body, void 0);
+}
+function getRace(joinCode) {
+  return request("GET", `/races/${encodeURIComponent(joinCode)}`, void 0, void 0);
+}
+function joinRace(joinCode, body) {
+  return request("POST", `/races/${encodeURIComponent(joinCode)}/join`, body, void 0);
+}
+function heartbeat(joinCode, horseId, token, body) {
+  return request(
+    "POST",
+    `/races/${encodeURIComponent(joinCode)}/horses/${encodeURIComponent(horseId)}/heartbeat`,
+    body,
+    token
+  );
+}
+function endRace(adminCode) {
+  return request("DELETE", `/races/admin/${encodeURIComponent(adminCode)}`, void 0, void 0);
+}
+
+// src/commands/create.ts
+var DEFAULT_TZ = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+async function createRaceCommand() {
+  const rl = readline3.createInterface({ input: stdin3, output: stdout3 });
+  try {
+    const name = (await rl.question("Race name: ")).trim();
+    if (!name) {
+      console.error("Name required.");
+      return 1;
+    }
+    const start = (await rl.question("Start time (ISO 8601, e.g. 2026-04-23T15:00:00Z): ")).trim();
+    if (!isIso(start)) {
+      console.error("Invalid start time.");
+      return 1;
+    }
+    const end = (await rl.question("End time (ISO 8601): ")).trim();
+    if (!isIso(end)) {
+      console.error("Invalid end time.");
+      return 1;
+    }
+    if (new Date(end).getTime() <= new Date(start).getTime()) {
+      console.error("End time must be after start time.");
+      return 1;
+    }
+    const tz = (await rl.question(`Time zone [${DEFAULT_TZ}]: `)).trim() || DEFAULT_TZ;
+    const maxRaw = (await rl.question("Max participants [30]: ")).trim();
+    const max = maxRaw ? parseInt(maxRaw, 10) : void 0;
+    if (max !== void 0 && (!Number.isFinite(max) || max < 1)) {
+      console.error("Max participants must be a positive number.");
+      return 1;
+    }
+    const resp = await createRace({
+      name,
+      start_time: start,
+      end_time: end,
+      tz,
+      ...max !== void 0 ? { max_participants: max } : {}
+    });
+    console.log("");
+    console.log("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+    console.log(`  \u2551   JOIN CODE:  ${resp.join_code.padEnd(23)}\u2551`);
+    console.log("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+    console.log("");
+    console.log(`  Admin code:  ${resp.admin_code}`);
+    console.log("  \u26A0  Save the admin code \u2014 you need it to end the race early.");
+    console.log("");
+    console.log(`  Share with participants:  token-derby join ${resp.join_code}`);
+    return 0;
+  } catch (e) {
+    if (e instanceof ApiError) {
+      console.error(`Error: ${e.code} ${e.message}`);
+      return 1;
+    }
+    throw e;
+  } finally {
+    rl.close();
+  }
+}
+function isIso(s) {
+  if (!s) return false;
+  const d = new Date(s);
+  return !Number.isNaN(d.getTime());
+}
+
+// src/commands/join.ts
+import React6 from "react";
+import { render as render3 } from "ink";
+
+// src/ui/HorsePicker.tsx
+import { useState as useState2 } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function HorsePicker({ horses, onPick, onCancel }) {
+  const [idx, setIdx] = useState2(0);
+  useInput2((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (horses.length === 0) return;
+    if (key.upArrow) {
+      setIdx((idx - 1 + horses.length) % horses.length);
+      return;
+    }
+    if (key.downArrow) {
+      setIdx((idx + 1) % horses.length);
+      return;
+    }
+    if (key.return) {
+      onPick(horses[idx]);
+      return;
+    }
+  });
+  if (horses.length === 0) {
+    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(Text4, { children: "No horses in your stable." }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Run `token-derby stable create` to make one." })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Text4, { children: "Pick a horse to race:" }),
+    horses.map((h, i) => /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(Box4, { flexDirection: "row", children: /* @__PURE__ */ jsxs3(Text4, { children: [
+        i === idx ? "\u25BA" : " ",
+        " ",
+        h.name
+      ] }) }),
+      /* @__PURE__ */ jsxs3(Box4, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsx4(Text4, { children: "  " }),
+        /* @__PURE__ */ jsx4(HorseSprite, { sprite: MINI_SPRITE, colors: h.colors })
+      ] })
+    ] }, h.name)),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2191/\u2193 choose \xB7 Enter pick \xB7 Esc cancel" }) })
+  ] });
+}
+
+// src/runtime/run-race.tsx
+import { useEffect, useRef, useState as useState3 } from "react";
+import { useApp } from "ink";
+
+// src/ui/StatusScreen.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function StatusScreen(props) {
+  const { race, ownHorseId, ownHorseName, ownColors, lastHeartbeatAgoSec, lastHeartbeatOk } = props;
+  if (!race) {
+    return /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", children: /* @__PURE__ */ jsx5(Text5, { children: "Joining race\u2026" }) });
+  }
+  const own = race.horses.find((h) => h.horse_id === ownHorseId);
+  const leader = race.horses[0];
+  const elapsedPct = elapsed(race);
+  const timeLeft = formatDuration(race.time_left_seconds);
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs4(Text5, { children: [
+      "\u{1F3C7} TOKEN DERBY \u2500\u2500\u2500 ",
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: race.name }),
+      " \u2500\u2500\u2500 status: ",
+      /* @__PURE__ */ jsx5(Text5, { color: statusColor(race.status), children: race.status })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box5, { marginTop: 1, flexDirection: "row", children: [
+      /* @__PURE__ */ jsx5(HorseSprite, { sprite: MINI_SPRITE, colors: ownColors }),
+      /* @__PURE__ */ jsxs4(Text5, { children: [
+        "  ",
+        ownHorseName
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs4(Text5, { children: [
+        "Tokens (race):  ",
+        own?.current_tokens ?? 0
+      ] }),
+      /* @__PURE__ */ jsxs4(Text5, { children: [
+        "Position:       ",
+        own?.rank ?? "\u2014",
+        " of ",
+        race.horses.length
+      ] }),
+      /* @__PURE__ */ jsxs4(Text5, { children: [
+        "Leader:         ",
+        leader ? `${leader.name} (${leader.current_tokens})` : "\u2014"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text5, { children: [
+        "Race elapsed:   ",
+        (elapsedPct * 100).toFixed(0),
+        "%  ",
+        bar(elapsedPct, 20)
+      ] }),
+      /* @__PURE__ */ jsxs4(Text5, { children: [
+        "Time left:      ",
+        timeLeft
+      ] }),
+      /* @__PURE__ */ jsxs4(Text5, { children: [
+        "Last heartbeat: ",
+        lastHeartbeatAgoSec === null ? "\u2014" : `${lastHeartbeatAgoSec}s ago`,
+        " ",
+        /* @__PURE__ */ jsx5(Text5, { color: lastHeartbeatOk ? "green" : "yellow", children: lastHeartbeatOk ? "\u2713" : "\u26A0" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Press Ctrl+C to crash out of the race." }) })
+  ] });
+}
+function elapsed(race) {
+  const start = new Date(race.start_time).getTime();
+  const end = new Date(race.end_time).getTime();
+  const now = new Date(race.server_time).getTime();
+  if (end <= start) return 0;
+  const v = (now - start) / (end - start);
+  return Math.max(0, Math.min(1, v));
+}
+function bar(pct, width) {
+  const filled = Math.round(pct * width);
+  return "\u2593".repeat(filled) + "\u2591".repeat(width - filled);
+}
+function statusColor(status) {
+  if (status === "live") return "green";
+  if (status === "pending") return "yellow";
+  return "gray";
+}
+function formatDuration(seconds) {
+  const s = Math.max(0, Math.floor(seconds));
+  const h = Math.floor(s / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  const ss = s % 60;
+  return `${h.toString().padStart(2, "0")}:${m.toString().padStart(2, "0")}:${ss.toString().padStart(2, "0")}`;
+}
+
+// src/runtime/heartbeat-loop.ts
+function runHeartbeatLoop(opts) {
+  let timer = null;
+  let retryIndex = 0;
+  let stopped = false;
+  const stop = () => {
+    stopped = true;
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+  opts.abortSignal.addEventListener("abort", stop, { once: true });
+  const schedule = (delay) => {
+    if (stopped) return;
+    timer = setTimeout(tick, delay);
+  };
+  const tick = async () => {
+    if (stopped) return;
+    try {
+      const tokens = opts.getCurrentTokens();
+      const resp = await opts.sendHeartbeat(tokens);
+      retryIndex = 0;
+      opts.onSuccess(resp);
+      if (resp.race_status === "finished") {
+        opts.onFinished();
+        stop();
+        return;
+      }
+      schedule(opts.intervalMs);
+    } catch (err) {
+      opts.onError(err);
+      const delay = opts.retryDelaysMs[Math.min(retryIndex, opts.retryDelaysMs.length - 1)] ?? 1e3;
+      retryIndex += 1;
+      schedule(delay);
+    }
+  };
+  schedule(0);
+}
+
+// src/runtime/poll-loop.ts
+function runPollLoop(opts) {
+  let timer = null;
+  let stopped = false;
+  const stop = () => {
+    stopped = true;
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+  opts.abortSignal.addEventListener("abort", stop, { once: true });
+  const tick = async () => {
+    if (stopped) return;
+    try {
+      const race = await opts.fetchRace();
+      if (!stopped) opts.onSnapshot(race);
+    } catch (err) {
+      if (!stopped) opts.onError(err);
+    }
+    if (!stopped) timer = setTimeout(tick, opts.intervalMs);
+  };
+  timer = setTimeout(tick, 0);
+}
+
+// src/tokens/transcripts.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+async function sumOutputTokens() {
+  const root = claudeProjectsDir();
+  const files = await listJsonlFiles(root);
+  let total = 0;
+  for (const file of files) {
+    total += await sumFile(file);
+  }
+  return total;
+}
+async function listJsonlFiles(root) {
+  let projects;
+  try {
+    projects = await fs3.readdir(root);
+  } catch (e) {
+    if (e?.code === "ENOENT") return [];
+    throw e;
+  }
+  const out = [];
+  for (const project of projects) {
+    const projectDir = path3.join(root, project);
+    let stat2;
+    try {
+      stat2 = await fs3.stat(projectDir);
+    } catch {
+      continue;
+    }
+    if (!stat2.isDirectory()) continue;
+    const entries = await fs3.readdir(projectDir);
+    for (const entry of entries) {
+      if (entry.endsWith(".jsonl")) out.push(path3.join(projectDir, entry));
+    }
+  }
+  return out;
+}
+async function sumFile(file) {
+  let raw;
+  try {
+    raw = await fs3.readFile(file, "utf8");
+  } catch {
+    return 0;
+  }
+  let sum = 0;
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const tokens = parsed?.message?.usage?.output_tokens;
+    if (typeof tokens === "number" && Number.isFinite(tokens)) sum += tokens;
+  }
+  return sum;
+}
+
+// src/tokens/baseline.ts
+function initialBaseline(args) {
+  return args.runningTotal;
+}
+
+// src/runtime/run-race.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+function RunRace({ active, startingBaseline, pendingMode }) {
+  const { exit } = useApp();
+  const [race, setRace] = useState3(null);
+  const [lastHbAt, setLastHbAt] = useState3(null);
+  const [lastHbOk, setLastHbOk] = useState3(true);
+  const [tickNow, setTickNow] = useState3(/* @__PURE__ */ new Date());
+  const baselineRef = useRef(startingBaseline);
+  const pendingRef = useRef(pendingMode);
+  const lastTokenSampleRef = useRef(startingBaseline);
+  const ctrl = useRef(new AbortController());
+  useEffect(() => {
+    const t = setInterval(() => setTickNow(/* @__PURE__ */ new Date()), 1e3);
+    return () => clearInterval(t);
+  }, []);
+  useEffect(() => {
+    if (pendingRef.current && race?.status === "live") {
+      sumOutputTokens().then((total) => {
+        baselineRef.current = total;
+        pendingRef.current = false;
+      });
+    }
+  }, [race?.status]);
+  useEffect(() => {
+    runPollLoop({
+      fetchRace: () => getRace(active.join_code),
+      intervalMs: POLL_INTERVAL_MS,
+      onSnapshot: (r) => setRace(r),
+      onError: () => {
+      },
+      abortSignal: ctrl.current.signal
+    });
+    runHeartbeatLoop({
+      sendHeartbeat: async (currentTokens) => {
+        const resp = await heartbeat(
+          active.join_code,
+          active.horse_id,
+          active.heartbeat_token,
+          { current_tokens: currentTokens }
+        );
+        const updated = {
+          ...active,
+          last_race_tokens: currentTokens,
+          last_heartbeat_at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await saveActiveRace(updated);
+        return resp;
+      },
+      getCurrentTokens: () => {
+        if (pendingRef.current) return 0;
+        return Math.max(0, lastTokenSampleRef.current - baselineRef.current);
+      },
+      intervalMs: HEARTBEAT_INTERVAL_MS,
+      retryDelaysMs: HEARTBEAT_RETRY_DELAYS_MS,
+      onSuccess: (resp) => {
+        setLastHbAt(/* @__PURE__ */ new Date());
+        setLastHbOk(true);
+        if (resp.race_status === "finished") exit();
+      },
+      onError: () => setLastHbOk(false),
+      onFinished: () => exit(),
+      abortSignal: ctrl.current.signal
+    });
+    const sampler = setInterval(async () => {
+      try {
+        lastTokenSampleRef.current = await sumOutputTokens();
+      } catch {
+      }
+    }, 5e3);
+    sumOutputTokens().then((t) => {
+      lastTokenSampleRef.current = t;
+    }).catch(() => {
+    });
+    const controller = ctrl.current;
+    return () => {
+      clearInterval(sampler);
+      controller.abort();
+    };
+  }, []);
+  const lastHeartbeatAgoSec = lastHbAt ? Math.max(0, Math.floor((tickNow.getTime() - lastHbAt.getTime()) / 1e3)) : null;
+  return /* @__PURE__ */ jsx6(
+    StatusScreen,
+    {
+      race,
+      ownHorseId: active.horse_id,
+      ownHorseName: active.horse_name,
+      ownColors: active.horse_colors,
+      lastHeartbeatAgoSec,
+      lastHeartbeatOk: lastHbOk
+    }
+  );
+}
+async function buildInitialState(args) {
+  const runningTotal = await sumOutputTokens();
+  if (args.rejoin) {
+    return {
+      startingBaseline: Math.max(0, runningTotal - args.active.last_race_tokens),
+      pendingMode: args.raceStatus === "pending"
+    };
+  }
+  return {
+    startingBaseline: initialBaseline({ runningTotal, status: args.raceStatus }),
+    pendingMode: args.raceStatus === "pending"
+  };
+}
+
+// src/commands/join.ts
+async function joinCommand(joinCode) {
+  if (!joinCode) {
+    console.error("Usage: token-derby join <join-code>");
+    return 2;
+  }
+  const code = joinCode.toUpperCase();
+  const stable = await loadStable();
+  if (stable.horses.length === 0) {
+    console.error("Your stable is empty. Run `token-derby stable create` first.");
+    return 1;
+  }
+  const picked = await pickHorse(stable.horses);
+  if (!picked) {
+    console.log("Cancelled.");
+    return 1;
+  }
+  let joinResp;
+  try {
+    joinResp = await joinRace(code, { horse: { name: picked.name, colors: picked.colors } });
+  } catch (e) {
+    if (e instanceof ApiError) {
+      if (e.code === "RACE_FULL") console.error(`This race is full.`);
+      else if (e.code === "RACE_FINISHED") console.error("This race has ended.");
+      else if (e.code === "RACE_NOT_FOUND") console.error(`No race with join code ${code}.`);
+      else console.error(`Error: ${e.code} ${e.message}`);
+      return 1;
+    }
+    throw e;
+  }
+  const race = await getRace(code);
+  if (race.status === "finished") {
+    console.error("Race finished after join. Exiting.");
+    return 1;
+  }
+  const status = race.status;
+  const active = {
+    join_code: code,
+    race_id: race.race_id,
+    horse_id: joinResp.horse_id,
+    heartbeat_token: joinResp.heartbeat_token,
+    horse_name: picked.name,
+    horse_colors: picked.colors,
+    joined_at: (/* @__PURE__ */ new Date()).toISOString(),
+    last_race_tokens: 0,
+    last_heartbeat_at: (/* @__PURE__ */ new Date(0)).toISOString()
+  };
+  await saveActiveRace(active);
+  const initial = await buildInitialState({ active, raceStatus: status, rejoin: false });
+  const app = render3(React6.createElement(RunRace, { active, ...initial }));
+  await app.waitUntilExit();
+  return 0;
+}
+async function pickHorse(horses) {
+  return new Promise((resolve) => {
+    const app = render3(
+      React6.createElement(HorsePicker, {
+        horses,
+        onPick: (h) => {
+          app.unmount();
+          resolve(h);
+        },
+        onCancel: () => {
+          app.unmount();
+          resolve(null);
+        }
+      })
+    );
+  });
+}
+
+// src/commands/rejoin.ts
+import React7 from "react";
+import { render as render4 } from "ink";
+async function rejoinCommand(joinCode) {
+  if (!joinCode) {
+    console.error("Usage: token-derby rejoin <join-code>");
+    return 2;
+  }
+  const code = joinCode.toUpperCase();
+  const active = await loadActiveRace(code);
+  if (!active) {
+    console.error(`No saved active-race state for ${code}. Use \`token-derby join ${code}\` to enter as a new horse.`);
+    return 1;
+  }
+  let race;
+  try {
+    race = await getRace(code);
+  } catch (e) {
+    if (e instanceof ApiError) {
+      console.error(`Error: ${e.code} ${e.message}`);
+      return 1;
+    }
+    throw e;
+  }
+  if (race.status === "finished") {
+    console.error("Race already finished.");
+    return 1;
+  }
+  const status = race.status;
+  const initial = await buildInitialState({ active, raceStatus: status, rejoin: true });
+  const app = render4(React7.createElement(RunRace, { active, ...initial }));
+  await app.waitUntilExit();
+  return 0;
+}
+
+// src/commands/end.ts
+import * as readline4 from "readline/promises";
+import { stdin as stdin4, stdout as stdout4 } from "process";
+async function endCommand(adminCode) {
+  if (!adminCode) {
+    console.error("Usage: token-derby end <admin-code>");
+    return 2;
+  }
+  const rl = readline4.createInterface({ input: stdin4, output: stdout4 });
+  const answer = (await rl.question("End the race now and freeze final tokens? [y/N] ")).trim().toLowerCase();
+  rl.close();
+  if (answer !== "y" && answer !== "yes") {
+    console.log("Cancelled.");
+    return 1;
+  }
+  try {
+    await endRace(adminCode);
+    console.log("\u2713 Race ended.");
+    return 0;
+  } catch (e) {
+    if (e instanceof ApiError) {
+      if (e.code === "RACE_NOT_FOUND") console.error("No race with that admin code.");
+      else console.error(`Error: ${e.code} ${e.message}`);
+      return 1;
+    }
+    throw e;
+  }
+}
+
+// src/bin.ts
+var VERSION = "0.1.0";
+var HELP = `token-derby v${VERSION}
+
+Stable management:
+  token-derby stable create               Make a new horse (interactive)
+  token-derby stable list                 Show your saved horses
+  token-derby stable delete <name>        Remove a horse from your stable
+
+Races:
+  token-derby create                      Create a new race (interactive)
+  token-derby join <join-code>            Pick a horse and join a race
+  token-derby rejoin <join-code>          Resume a race after a disconnect
+  token-derby end <admin-code>            End a race early
+
+Environment:
+  TOKEN_DERBY_API_BASE                    Override API base URL (default: production)
+`;
+async function main() {
+  const argv = process.argv.slice(2);
+  const cmd = argv[0];
+  if (!cmd || cmd === "--help" || cmd === "-h") {
+    console.log(HELP);
+    return 0;
+  }
+  if (cmd === "--version" || cmd === "-v") {
+    console.log(VERSION);
+    return 0;
+  }
+  if (cmd === "stable") {
+    const sub = argv[1];
+    if (sub === "create") return stableCreateCommand();
+    if (sub === "list") return stableListCommand();
+    if (sub === "delete") return stableDeleteCommand(argv[2]);
+    console.error(`Unknown stable subcommand: ${sub ?? "(none)"}`);
+    console.error("Try: stable create | stable list | stable delete <name>");
+    return 2;
+  }
+  if (cmd === "create") return createRaceCommand();
+  if (cmd === "join") return joinCommand(argv[1]);
+  if (cmd === "rejoin") return rejoinCommand(argv[1]);
+  if (cmd === "end") return endCommand(argv[1]);
+  console.error(`Unknown command: ${cmd}`);
+  console.error(HELP);
+  return 2;
+}
+main().then(
+  (code) => process.exit(code),
+  (err) => {
+    console.error(err?.stack ?? err);
+    process.exit(1);
+  }
+);
+//# sourceMappingURL=bin.js.map