@trolleroof/tui 0.2.3

package/scripts/preview-overlay.ts

@@ -0,0 +1,153 @@
+#!/usr/bin/env bun
+/**
+ * Serve a browser preview of the Arcade overlay at production frame sizes.
+ * Rebuilds the web bundle, then hosts overlay/dist + overlay/preview.html.
+ *
+ *   bun run preview:overlay
+ *   bun run preview:overlay -- --game=connect4
+ *   → http://127.0.0.1:4173/?game=connect4
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, normalize, relative, resolve } from "node:path";
+
+const ROOT = join(import.meta.dir, "..");
+const DIST = join(ROOT, "overlay", "dist");
+const PREVIEW_HTML = join(ROOT, "overlay", "preview.html");
+const HOST = process.env.GAMEPIGEON_PREVIEW_HOST ?? "127.0.0.1";
+const DEFAULT_PORT = Number(process.env.GAMEPIGEON_PREVIEW_PORT ?? 4173);
+
+function parseArgs(argv: string[]): { game?: string; variation?: string; scores?: string; open: boolean; help: boolean } {
+  let game: string | undefined;
+  let variation: string | undefined;
+  let scores: string | undefined;
+  let open = true;
+  let help = false;
+  for (const arg of argv) {
+    if (arg === "--help" || arg === "-h") help = true;
+    else if (arg === "--no-open") open = false;
+    else if (arg === "--open") open = true;
+    else if (arg.startsWith("--game=")) game = arg.slice("--game=".length) || undefined;
+    else if (arg.startsWith("--variation=")) variation = arg.slice("--variation=".length) || undefined;
+    else if (arg.startsWith("--scores=")) scores = arg.slice("--scores=".length) || undefined;
+  }
+  return { game, variation, scores, open, help };
+}
+
+function printHelp(): void {
+  console.log(`Usage: bun run preview:overlay [-- --game=<id>] [-- --variation=<id>] [-- --scores=demo] [-- --no-open]
+
+Rebuilds the overlay web bundle and serves a browser preview at the real
+Tauri frame sizes (520×740 compact / 720×780 expanded).
+
+Options (after --):
+  --game=<id>         Deep-link into a game (e.g. connect4)
+  --variation=<id>    Optional variation id (default: classic)
+  --scores=demo       Populate preview-only sample leaderboard runs
+  --open / --no-open  Open the default browser (default: open)
+  -h, --help          Show this help
+
+Env:
+  GAMEPIGEON_PREVIEW_HOST  bind host (default 127.0.0.1)
+  GAMEPIGEON_PREVIEW_PORT  preferred port (default 4173; falls back if busy)
+`);
+}
+
+function run(command: string, args: string[]): Promise<number> {
+  return new Promise((resolveExit, reject) => {
+    const child = spawn(command, args, { cwd: ROOT, stdio: "inherit" });
+    child.on("error", reject);
+    child.on("exit", (code) => resolveExit(code ?? 1));
+  });
+}
+
+function openBrowser(url: string): void {
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  spawn(opener, args, { stdio: "ignore", detached: true }).unref();
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (args.help) {
+  printHelp();
+  process.exit(0);
+}
+
+const buildCode = await run("bun", ["run", "build:overlay:web"]);
+if (buildCode !== 0) process.exit(buildCode);
+
+if (!existsSync(join(DIST, "index.html"))) {
+  console.error(`Missing ${join(DIST, "index.html")} — expected overlay web assets.`);
+  process.exit(1);
+}
+if (!existsSync(PREVIEW_HTML)) {
+  console.error(`Missing ${PREVIEW_HTML}`);
+  process.exit(1);
+}
+
+const previewBytes = await Bun.file(PREVIEW_HTML).bytes();
+
+function distFile(pathname: string): string | null {
+  const cleaned = normalize(pathname).replace(/^(\.\.[/\\])+/, "");
+  const filePath = resolve(DIST, cleaned.replace(/^[/\\]+/, ""));
+  const rel = relative(DIST, filePath);
+  if (!rel || rel.startsWith("..") || rel.includes("..")) return null;
+  return filePath;
+}
+
+const fetchHandler = {
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    if (url.pathname === "/" || url.pathname === "/preview.html") {
+      return new Response(previewBytes, {
+        headers: {
+          "Content-Type": "text/html; charset=utf-8",
+          "Cache-Control": "no-store",
+        },
+      });
+    }
+
+    const filePath = distFile(url.pathname);
+    if (!filePath) return new Response("Forbidden", { status: 403 });
+    const file = Bun.file(filePath);
+    if (!(await file.exists())) {
+      return new Response("Not found", { status: 404 });
+    }
+    return new Response(file, {
+      headers: { "Cache-Control": "no-store" },
+    });
+  },
+};
+
+function startServer(port: number) {
+  return Bun.serve({
+    hostname: HOST,
+    port,
+    ...fetchHandler,
+  });
+}
+
+let server: ReturnType<typeof Bun.serve>;
+try {
+  server = startServer(DEFAULT_PORT);
+} catch (error) {
+  const code = (error as { code?: string }).code;
+  if (code !== "EADDRINUSE") throw error;
+  console.warn(`Port ${DEFAULT_PORT} is busy — trying the next free port…`);
+  server = startServer(0);
+}
+
+const query = new URLSearchParams();
+if (args.game) query.set("game", args.game);
+if (args.variation) query.set("variation", args.variation);
+if (args.scores) query.set("scores", args.scores);
+const suffix = query.toString() ? `/?${query}` : "/";
+const base = `http://${server.hostname}:${server.port}`;
+const url = `${base}${suffix}`;
+
+console.log(`Arcade browser preview → ${url}`);
+if (!args.game) console.log(`Deep-link example     → ${base}/?game=connect4`);
+console.log("Ctrl+C to stop.");
+
+if (args.open) openBrowser(url);

package/scripts/run-plugin-update.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { runPluginUpgrade } from "./run-plugin-update.js";
+
+describe("runPluginUpgrade", () => {
+  test("reports marketplace failures without throwing", async () => {
+    const originalSpawn = Bun.spawn;
+    Bun.spawn = ((command: string[]) => ({
+      stdout: new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode(""));
+          controller.close();
+        },
+      }),
+      stderr: new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode("network error"));
+          controller.close();
+        },
+      }),
+      exited: Promise.resolve(1),
+    })) as typeof Bun.spawn;
+
+    try {
+      const result = await runPluginUpgrade();
+      expect(result.ok).toBe(false);
+      expect(result.message.length).toBeGreaterThan(0);
+    } finally {
+      Bun.spawn = originalSpawn;
+    }
+  });
+});

package/scripts/run-plugin-update.ts

@@ -0,0 +1,65 @@
+import { resolvePluginUpdatePaths, runPluginUpdateClear } from "./plugin-update.js";
+
+const MARKETPLACE = "tui-gamepigeon";
+const PLUGIN = "tui-gamepigeon@tui-gamepigeon";
+const REPO_URL = "https://github.com/Trolleroof/tui-gamepigeon.git";
+
+export interface PluginUpgradeResult {
+  ok: boolean;
+  message: string;
+}
+
+async function runStep(command: string[], cwd?: string): Promise<{ ok: boolean; output: string }> {
+  const proc = Bun.spawn(command, {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  const code = await proc.exited;
+  const output = `${stdout}${stderr}`.trim();
+  return { ok: code === 0, output };
+}
+
+export async function runPluginUpgrade(): Promise<PluginUpgradeResult> {
+  let marketplace = await runStep(["claude", "plugin", "marketplace", "update", MARKETPLACE]);
+  if (!marketplace.ok) {
+    marketplace = await runStep(["claude", "plugin", "marketplace", "add", REPO_URL]);
+    if (marketplace.ok) {
+      await runStep(["claude", "plugin", "marketplace", "remove", MARKETPLACE]);
+    } else {
+      return {
+        ok: false,
+        message: marketplace.output || "Could not refresh the Arcade marketplace. Check your network and try again.",
+      };
+    }
+  }
+
+  let plugin = await runStep(["claude", "plugin", "update", PLUGIN]);
+  if (!plugin.ok) {
+    plugin = await runStep(["claude", "plugin", "install", PLUGIN, "--scope", "user"]);
+  }
+  if (!plugin.ok) {
+    return {
+      ok: false,
+      message: plugin.output || "Plugin update failed. Please try again or report an issue on GitHub.",
+    };
+  }
+
+  runPluginUpdateClear(resolvePluginUpdatePaths());
+  return {
+    ok: true,
+    message: "Arcade updated. Run /reload-plugins or restart Claude Code to apply the new plugin.",
+  };
+}
+
+if (import.meta.main) {
+  const result = await runPluginUpgrade();
+  if (result.ok) {
+    console.log(result.message);
+  } else {
+    console.error(result.message);
+    process.exitCode = 1;
+  }
+}

package/scripts/version-bump.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { VERSION_FILES, applyVersion, nextVersion } from "./version-bump.ts";
+
+const ROOT_DIR = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+describe("nextVersion", () => {
+  test("bumps each component", () => {
+    expect(nextVersion("0.2.1", "patch")).toBe("0.2.2");
+    expect(nextVersion("0.2.1", "minor")).toBe("0.3.0");
+    expect(nextVersion("0.2.1", "major")).toBe("1.0.0");
+  });
+
+  test("resets lower components", () => {
+    expect(nextVersion("1.9.9", "major")).toBe("2.0.0");
+    expect(nextVersion("1.9.9", "minor")).toBe("1.10.0");
+  });
+
+  test("accepts an explicit version", () => {
+    expect(nextVersion("0.2.1", "1.4.0")).toBe("1.4.0");
+  });
+
+  test("rejects garbage rather than silently patching", () => {
+    expect(() => nextVersion("0.2.1", "latest")).toThrow();
+  });
+});
+
+describe("applyVersion", () => {
+  test("sets the top-level version", () => {
+    const out = applyVersion("package.json", '{"name":"x","version":"0.1.0"}', "0.2.0");
+    expect(JSON.parse(out).version).toBe("0.2.0");
+    expect(JSON.parse(out).name).toBe("x");
+  });
+
+  test("reaches into marketplace plugin entries", () => {
+    const out = applyVersion(
+      ".claude-plugin/marketplace.json",
+      '{"plugins":[{"name":"x","version":"0.1.0"}]}',
+      "0.2.0",
+    );
+    expect(JSON.parse(out).plugins[0].version).toBe("0.2.0");
+  });
+
+  test("preserves surrounding formatting", () => {
+    const source = '{\n  "keywords": ["a", "b"],\n  "version": "0.1.0"\n}\n';
+    expect(applyVersion("package.json", source, "0.2.0")).toBe(
+      '{\n  "keywords": ["a", "b"],\n  "version": "0.2.0"\n}\n',
+    );
+  });
+
+  test("throws when there is no version to bump", () => {
+    expect(() => applyVersion("package.json", '{"name":"x"}', "0.2.0")).toThrow();
+  });
+});
+
+describe("VERSION_FILES", () => {
+  // A version file that drifts out of this list stops being bumped, which is how
+  // .codex-plugin/plugin.json fell a release behind.
+  test("every listed file exists and carries a version", () => {
+    for (const file of VERSION_FILES) {
+      const json = JSON.parse(readFileSync(join(ROOT_DIR, file), "utf8"));
+      const version = file.endsWith("marketplace.json") ? json.plugins?.[0]?.version : json.version;
+      expect(version, `${file} has no version`).toMatch(/^\d+\.\d+\.\d+$/);
+    }
+  });
+
+  test("all version files agree", () => {
+    const versions = VERSION_FILES.map((file) => {
+      const json = JSON.parse(readFileSync(join(ROOT_DIR, file), "utf8"));
+      return file.endsWith("marketplace.json") ? json.plugins[0].version : json.version;
+    });
+    expect(new Set(versions).size, `versions drifted: ${versions.join(", ")}`).toBe(1);
+  });
+});

package/scripts/version-bump.ts

@@ -0,0 +1,89 @@
+/**
+ * Bumps the project version everywhere it is declared, so cutting a release is
+ * one command. This only updates the version and commits it — CI does nothing
+ * until you explicitly push a matching `overlay-v<version>` tag, which is
+ * what actually publishes the release and repoints the update manifest:
+ *
+ *   bun run version:bump            # 0.2.1 -> 0.2.2
+ *   bun run version:bump minor      # 0.2.1 -> 0.3.0
+ *   bun run version:bump 1.0.0      # explicit
+ *   bun run version:bump --no-commit
+ *   git push origin main
+ *   git tag overlay-v<version> && git push origin overlay-v<version>
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT_DIR = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+export type Release = "patch" | "minor" | "major";
+
+const SEMVER = /^(\d+)\.(\d+)\.(\d+)$/;
+
+export function nextVersion(current: string, bump: Release | string): string {
+  if (SEMVER.test(bump)) return bump;
+  const match = SEMVER.exec(current);
+  if (!match) throw new Error(`Current version is not semver: ${current}`);
+  const [major, minor, patch] = match.slice(1, 4).map(Number);
+  if (bump === "major") return `${major + 1}.0.0`;
+  if (bump === "minor") return `${major}.${minor + 1}.0`;
+  if (bump === "patch") return `${major}.${minor}.${patch + 1}`;
+  throw new Error(`Expected patch|minor|major or an explicit x.y.z version, got: ${bump}`);
+}
+
+/** Every file carrying the version. */
+export const VERSION_FILES = [
+  "package.json",
+  ".claude-plugin/plugin.json",
+  ".codex-plugin/plugin.json",
+  ".claude-plugin/marketplace.json",
+] as const;
+
+const VERSION_FIELD = /("version"\s*:\s*")\d+\.\d+\.\d+(")/g;
+
+/**
+ * Rewrites the version in place rather than round-tripping through JSON.parse,
+ * which would reflow every hand-formatted array in these files and bury the one
+ * line that actually changed. `marketplace.json` nests its version inside a
+ * plugin entry, so this replaces every occurrence — none of these files carry a
+ * `version` field that should stay put.
+ */
+export function applyVersion(file: string, source: string, version: string): string {
+  const updated = source.replace(VERSION_FIELD, `$1${version}$2`);
+  if (updated === source && !source.includes(`"${version}"`)) {
+    throw new Error(`No version field found in ${file}`);
+  }
+  return updated;
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const commit = !args.includes("--no-commit");
+  const bump = args.find((arg) => !arg.startsWith("--")) ?? "patch";
+
+  const pkgPath = join(ROOT_DIR, "package.json");
+  const current = JSON.parse(readFileSync(pkgPath, "utf8")).version as string;
+  const version = nextVersion(current, bump);
+
+  for (const file of VERSION_FILES) {
+    const path = join(ROOT_DIR, file);
+    writeFileSync(path, applyVersion(file, readFileSync(path, "utf8"), version));
+  }
+  console.log(`${current} -> ${version}`);
+
+  if (commit) {
+    const git = Bun.spawnSync(
+      ["git", "commit", "-m", `Bump version to ${version}`, "--", ...VERSION_FILES],
+      { cwd: ROOT_DIR, stdout: "inherit", stderr: "inherit" },
+    );
+    if (git.exitCode !== 0) process.exitCode = 1;
+    else {
+      console.log(
+        `Committed. Push to main, then run:\n` +
+          `  git tag overlay-v${version} && git push origin overlay-v${version}\n` +
+          `to publish the release.`,
+      );
+    }
+  }
+}