@trolleroof/tui 0.2.4 → 0.2.6

package/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "tui-gamepigeon",
+  "version": "0.2.6",
+  "description": "Play in a lightweight HTML overlay while Claude Code works.",
+  "author": {
+    "name": "Trolleroof"
+  },
+  "repository": "https://github.com/Trolleroof/tui-gamepigeon",
+  "license": "MIT"
+}

package/.codex-plugin/plugin.json

@@ -0,0 +1,21 @@
+{
+  "name": "tui-gamepigeon",
+  "version": "0.2.6",
+  "description": "Play in a lightweight HTML overlay while Codex works.",
+  "author": {
+    "name": "Trolleroof"
+  },
+  "repository": "https://github.com/Trolleroof/tui-gamepigeon",
+  "license": "MIT",
+  "keywords": ["arcade", "2048", "tetris", "terminal", "game"],
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "Tui Arcade",
+    "shortDescription": "Play 2048 or Tetris while Codex works",
+    "longDescription": "Open or restore a lightweight 2048 HTML overlay without leaving the active Codex task.",
+    "developerName": "Trolleroof",
+    "category": "Developer Tools",
+    "capabilities": ["Interactive"],
+    "defaultPrompt": ["Open the Arcade."]
+  }
+}

package/README.md

@@ -57,7 +57,7 @@ To open the overlay directly without a harness:
 ```bash
 bun run start            # menu
 bun run start 2048       # a specific game
-bun run preview:overlay  # browser preview at 470×650 (no Tauri)
+bun run preview:overlay  # browser preview at 520×740 (no Tauri)
 bun run dev:overlay      # rebuild web bundle + debug shell, then show
 ```
 
@@ -71,7 +71,7 @@ bun run preview:overlay
 bun run preview:overlay -- --game=connect4
 ```
 
-The preview frames the real overlay UI at the production sizes (**470×650** compact, **720×780** expanded). Titlebar **↗ / ↙** toggles the frame; Hide and Shutdown are no-ops in the browser. Open a game from the menu, or pass `--game=<id>` / use `?game=<id>` (optional `&variation=classic`).
+The preview frames the real overlay UI at the production sizes (**520×740** compact, **720×780** expanded). Titlebar **↗ / ↙** toggles the frame; Hide and Shutdown are no-ops in the browser. Open a game from the menu, or pass `--game=<id>` / use `?game=<id>` (optional `&variation=classic`).
 
 ### Global (installed once, works everywhere)
 
@@ -82,7 +82,9 @@ npx -y bun x @trolleroof/tui@latest install --codex
 ```
 
 Replace `--codex` with `--claude`, `--opencode`, `--hermes`, `--openclaw`, or
-`--all`. This uses npm to fetch Bun for the command, then writes the harness adapter.
+`--antigravity`, or `--all`. For Antigravity, run it from the project directory;
+it writes that project's `.agents/plugins/tui-gamepigeon` plugin. This uses npm to
+fetch Bun for the command, then writes the harness adapter.
 Restart the harness when it finishes.
 
 Install the plugin from the GitHub marketplace so the normal `claude` command runs
@@ -123,7 +125,7 @@ Production defaults to `https://runretroarcade.com/login.html`, `https://auth.ru
 
 ## Coding harness adapters
 
-The bundled adapters give Codex CLI, Claude Code, and OpenCode the same Arcade launcher. GamePigeon opens a centered, borderless HTML overlay above the active desktop. It uses the operating system's installed webview through a small Tauri shell, not Chrome or Electron.
+The bundled adapters give Codex CLI, Claude Code, and OpenCode the same Arcade launcher. Tui opens a centered, borderless HTML overlay above the active desktop. It uses the operating system's installed webview through a small Tauri shell, not Chrome or Electron.
 
 Requirements:
 
@@ -255,7 +257,7 @@ export GAMEPIGEON_BACKEND_TOKEN=retro_...
 # export GAMEPIGEON_BACKEND_URL=http://127.0.0.1:8787
 ```
 
-The HTML overlay journals each seeded action sequence in local storage, rebuilds replay-safe schema-v2 engine-state traces at episode end, and hands immutable chunks plus completed-game results to Tauri. Tauri validates and durably queues them before any network call, then resolves the canonical `/v1/me` user and drains both outboxes in the background. Chunks live under `~/.tui-gamepigeon/recordings/overlay-pending/` until `/v1/game-event-chunks` accepts them; results live under `~/.tui-gamepigeon/recordings/results/overlay-pending/` until `/v1/game-results` accepts them. Interrupted and offline sessions recover on the next launch, while cloud-acknowledged payloads move to the matching `overlay-completed/` directory.
+The HTML overlay journals each seeded action sequence in local storage, rebuilds replay-safe schema-v2 engine-state traces at episode end, and hands immutable chunks plus completed-game results to Tauri. Tauri validates and durably queues them before any network call, then resolves the canonical `/v1/me` user and drains both outboxes in the background. Chunks live under `~/.tui-gamepigeon/recordings/overlay-pending/` until `/v1/game-event-chunks` accepts them; results live under `~/.tui-gamepigeon/recordings/results/overlay-pending/` until `/v1/game-results` accepts them. Interrupted and offline sessions recover on the next launch, while cloud-acknowledged payloads move to the matching `overlay-completed/` directory. A payload the backend refuses outright — a non-retryable HTTP status, or an acknowledgment that does not match what was sent — moves to the matching `overlay-failed/` directory with a reason logged to stderr and a sync error raised, so one rejected chunk never blocks the rest of the queue. Sign-in and backend-URL failures are not rejections: those keep the payload queued for the next launch. Nothing deletes those files; pass them to the exporter with `--input` if you want them back.
 
 Export policy-visible human demonstrations into leakage-safe BC splits:
 
@@ -297,7 +299,7 @@ Product events use a CloudEvents 1.0 envelope with `specversion`, `id`, `source`
 
 The website owns `site.visited`; invite and payment services own their corresponding events. Until those producers exist, the names above reserve the shared contract without fabricating client events. Analytics must never include terminal frames, trajectories, prompts, repository contents, credentials, email addresses, or raw provider payloads.
 
-The live [GamePigeon AARRR client dashboard](https://us.posthog.com/project/434929/dashboard/1866662) covers the client-owned acquisition, activation, and retention signals. See [`docs/analytics.md`](docs/analytics.md) for event ownership, saved insights, and the CLI verification runbook.
+The live [Tui AARRR client dashboard](https://us.posthog.com/project/434929/dashboard/1866662) covers the client-owned acquisition, activation, and retention signals. See [`docs/analytics.md`](docs/analytics.md) for event ownership, saved insights, and the CLI verification runbook.
 
 ## Architecture
 
@@ -322,7 +324,7 @@ bun run test:launcher
 bun run typecheck
 bun run build              # emits dist/, exposes the `gamepigeon` bin
 bun run build:overlay:web  # overlay bundle only
-bun run preview:overlay    # browser preview (470×650 / 720×780 frame)
+bun run preview:overlay    # browser preview (520×740 / 720×780 frame)
 bun run dev:overlay        # debug Tauri shell + show overlay
 ```
 
@@ -344,6 +346,28 @@ bun run version:bump --no-commit
 
 The version lives in four manifests — `package.json`, `.claude-plugin/plugin.json`, `.codex-plugin/plugin.json`, and `.claude-plugin/marketplace.json` — and the script rewrites all of them together. Bump by hand and they drift, which is why `scripts/version-bump.test.ts` asserts they agree.
 
-The script commits but never pushes; publishing stays an explicit action. On the next push to `main`, CI builds the binaries, publishes them as `overlay-v<version>`, and commits an `overlay-release.json` pointing at that tag, which is what installed plugins download on their next session.
+The script commits but never pushes; publishing stays an explicit action. Push `main`, then tag:
+
+```bash
+git push origin main
+git tag overlay-v<version> && git push origin overlay-v<version>
+```
+
+That tag triggers the Overlay workflow: it builds macOS/Windows binaries, creates the GitHub release `overlay-v<version>`, commits `overlay-release.json` on `main`, and publishes **`tui-gamepigeon@<version>` to npm** when `NPM_TOKEN` is configured (skips gracefully if the version already exists or the secret is missing). Installed plugins and npm installs both use the same manifest to download the native overlay on the next launch.
+
+### npm install (launcher only)
+
+Requires [Bun](https://bun.sh) 1.3+. The CLI opens the same HTML overlay and games as the Claude marketplace plugin; the native shell is downloaded on first run from the matching GitHub release.
+
+```bash
+npm i -g tui-gamepigeon
+gamepigeon              # arcade menu
+gamepigeon 2048         # jump into a game
+gamepigeon auth status
+```
+
+Harness hooks and auto-open on prompt still come from the [GitHub marketplace plugin](#coding-harness-adapters); npm is an alternate way to install the launcher without cloning the repo.
+
+Maintainers: add an npm automation token as the repository secret **`NPM_TOKEN`** (write publish). Rotate it in npm account settings if compromised; never commit tokens.
 
 Adding a new file that carries the version means adding it to `VERSION_FILES` in `scripts/version-bump.ts`, or it silently stops being bumped.

package/dist/index.js

@@ -16,8 +16,8 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import { join as join4, dirname as dirname3 } from "path";
-import { fileURLToPath } from "url";
+import { join as join5, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/recording/ids.ts
 import { randomUUID } from "crypto";
@@ -6835,6 +6835,20 @@ async function signInWithOAuth(provider, options = {}) {
     callback.close();
   }
 }
+async function refreshSessionIfPresent() {
+  const session = readSession();
+  if (!session)
+    return null;
+  try {
+    const user = await resolveUser(session.sessionToken);
+    saveSession(session.sessionToken, user);
+    return user;
+  } catch {
+    rmSync2(sessionFile(), { force: true });
+    clearBackendSession();
+    return null;
+  }
+}
 async function signOutLocal() {
   const session = readSession();
   try {
@@ -8322,8 +8336,271 @@ function findGame(id) {
   return REGISTRY.find((e) => e.id === norm);
 }
 
+// scripts/overlay.ts
+import {
+  accessSync,
+  chmodSync as chmodSync3,
+  constants,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync4,
+  readdirSync,
+  renameSync as renameSync2,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { homedir as homedir4, tmpdir } from "os";
+import { dirname as dirname3, join as join4 } from "path";
+import { fileURLToPath } from "url";
+var ROOT_DIR = join4(dirname3(fileURLToPath(import.meta.url)), "..");
+var DEFAULT_REPO = "Trolleroof/tui-gamepigeon";
+var SHUTDOWN_FLAG = join4(tmpdir(), ".gamepigeon-overlay.off");
+var OVERLAY_LEASE_FILE = join4(tmpdir(), ".gamepigeon-overlay.alive");
+var PAUSED_FLAG = join4(tmpdir(), ".gamepigeon-overlay.paused");
+var ANALYTICS_QUEUE = join4(homedir4(), ".tui-gamepigeon", "analytics-events.jsonl");
+async function flushAnalyticsQueue() {
+  if (!process.env.POSTHOG_API_KEY || !existsSync3(ANALYTICS_QUEUE))
+    return;
+  try {
+    const events = readFileSync4(ANALYTICS_QUEUE, "utf8").trim().split(`
+`).filter(Boolean).map((line) => JSON.parse(line));
+    for (const event of events)
+      analytics.capture(event);
+    const flushed = await Promise.race([
+      analytics.shutdown().then(() => true),
+      Bun.sleep(2000).then(() => false)
+    ]);
+    if (flushed)
+      rmSync3(ANALYTICS_QUEUE, { force: true });
+  } catch {}
+}
+function isShutDown() {
+  return existsSync3(SHUTDOWN_FLAG);
+}
+function clearShutdown() {
+  try {
+    rmSync3(SHUTDOWN_FLAG, { force: true });
+  } catch {}
+}
+function setOverlayLease(active, path = OVERLAY_LEASE_FILE) {
+  if (active)
+    writeFileSync4(path, "", { mode: 384 });
+  else
+    rmSync3(path, { force: true });
+}
+function overlayExecutableName() {
+  return process.platform === "win32" ? "gamepigeon-overlay.exe" : "gamepigeon-overlay";
+}
+function overlayReleaseAsset() {
+  const platform = process.platform === "darwin" ? "macos" : process.platform === "win32" ? "windows" : process.platform;
+  const extension = process.platform === "win32" ? ".exe" : "";
+  return `gamepigeon-overlay-${platform}-${process.arch}${extension}`;
+}
+function managedBinDir() {
+  return process.env.GAMEPIGEON_OVERLAY_HOME ?? join4(homedir4(), ".gamepigeon", "bin");
+}
+function managedBinaryPath(version2) {
+  return join4(managedBinDir(), version2, overlayExecutableName());
+}
+function readReleaseManifest(root = ROOT_DIR) {
+  try {
+    const parsed = JSON.parse(readFileSync4(join4(root, "overlay-release.json"), "utf8"));
+    if (typeof parsed.tag === "string" && typeof parsed.version === "string") {
+      return { tag: parsed.tag, version: parsed.version };
+    }
+  } catch {}
+  return null;
+}
+function repoSlug(root = ROOT_DIR) {
+  try {
+    const parsed = JSON.parse(readFileSync4(join4(root, ".claude-plugin", "plugin.json"), "utf8"));
+    const match = /github\.com\/([^/]+\/[^/.]+)/.exec(parsed.repository ?? "");
+    if (match?.[1])
+      return match[1];
+  } catch {}
+  return DEFAULT_REPO;
+}
+function overlayBinaryCandidates(root = ROOT_DIR, manifest = readReleaseManifest(root)) {
+  const executable = overlayExecutableName();
+  const platform = process.platform === "darwin" ? "macos" : process.platform;
+  const current = manifest ? readCurrentVersion() : null;
+  return [
+    process.env.GAMEPIGEON_OVERLAY_BIN,
+    manifest ? managedBinaryPath(manifest.version) : undefined,
+    join4(root, "bin", `${platform}-${process.arch}`, executable),
+    join4(root, "tauri", "target", "release", executable),
+    join4(root, "tauri", "target", "debug", executable),
+    current && current !== manifest?.version ? managedBinaryPath(current) : undefined
+  ].filter((candidate) => Boolean(candidate));
+}
+function isLaunchable(candidate) {
+  try {
+    accessSync(candidate, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveOverlayBinary(root = ROOT_DIR, manifest = readReleaseManifest(root)) {
+  for (const candidate of overlayBinaryCandidates(root, manifest)) {
+    if (isLaunchable(candidate))
+      return candidate;
+  }
+  throw new Error("Tui overlay binary was not found. Run `bun run build:overlay` or install a packaged release.");
+}
+async function downloadReleaseBinary(manifest, root) {
+  const destination = managedBinaryPath(manifest.version);
+  const staging = `${destination}.download`;
+  mkdirSync4(dirname3(destination), { recursive: true });
+  const asset = overlayReleaseAsset();
+  const slug = repoSlug(root);
+  let downloaded = false;
+  try {
+    const gh = Bun.spawn(["gh", "release", "download", manifest.tag, "--repo", slug, "--pattern", asset, "--output", staging, "--clobber"], { stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+    downloaded = await gh.exited === 0;
+  } catch {
+    downloaded = false;
+  }
+  if (!downloaded) {
+    const response = await fetch(`https://github.com/${slug}/releases/download/${manifest.tag}/${asset}`);
+    if (!response.ok) {
+      throw new Error(`Overlay download failed (${response.status}) for ${manifest.tag}/${asset}`);
+    }
+    writeFileSync4(staging, new Uint8Array(await response.arrayBuffer()));
+  }
+  if (process.platform !== "win32")
+    chmodSync3(staging, 493);
+  renameSync2(staging, destination);
+}
+function pruneManagedBinaries(keepVersion) {
+  try {
+    for (const entry of readdirSync(managedBinDir())) {
+      if (entry !== keepVersion && entry !== "current") {
+        rmSync3(join4(managedBinDir(), entry), { recursive: true, force: true });
+      }
+    }
+  } catch {}
+}
+function readCurrentVersion() {
+  try {
+    return readFileSync4(join4(managedBinDir(), "current"), "utf8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+function quitOverlay(binary, wait = true) {
+  const child = Bun.spawn([binary, "--quit"], {
+    detached: true,
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "ignore"
+  });
+  child.unref();
+  if (!wait)
+    return Promise.resolve();
+  return Promise.race([child.exited, Bun.sleep(2000)]);
+}
+async function ensureOverlayBinary(root = ROOT_DIR) {
+  const manifest = readReleaseManifest(root);
+  if (!manifest)
+    return;
+  const destination = managedBinaryPath(manifest.version);
+  if (!isLaunchable(destination)) {
+    try {
+      await downloadReleaseBinary(manifest, root);
+    } catch {
+      return;
+    }
+  }
+  const previous = readCurrentVersion();
+  if (previous && previous !== manifest.version) {
+    const stale = managedBinaryPath(previous);
+    if (isLaunchable(stale))
+      await quitOverlay(stale);
+  }
+  writeFileSync4(join4(managedBinDir(), "current"), manifest.version);
+  pruneManagedBinaries(manifest.version);
+}
+function applyOverlayLease(action, leasePath = OVERLAY_LEASE_FILE) {
+  if (action === "quit")
+    setOverlayLease(false, leasePath);
+  else if (action === "show" || action === "enable")
+    setOverlayLease(true, leasePath);
+}
+function overlaySpawnArgs(action, options = {}) {
+  const args = [`--${action}`];
+  if (options.gameId)
+    args.push("--game", options.gameId);
+  if (options.variationId)
+    args.push("--variation", options.variationId);
+  return args;
+}
+async function launchOverlay(action, root = ROOT_DIR, options = {}) {
+  if (action !== "quit")
+    await flushAnalyticsQueue();
+  if ((action === "show" || action === "enable") && process.env.GAMEPIGEON_OVERLAY_DRY_RUN !== "1") {
+    await refreshSessionIfPresent();
+  }
+  applyOverlayLease(action);
+  if (action === "quit") {
+    try {
+      rmSync3(PAUSED_FLAG, { force: true });
+    } catch {}
+  }
+  if (action === "reset" || action === "enable")
+    clearShutdown();
+  else if ((action === "show" || action === "pause") && isShutDown())
+    return;
+  if (action === "pause") {
+    if (!existsSync3(OVERLAY_LEASE_FILE) || existsSync3(PAUSED_FLAG))
+      return;
+    try {
+      writeFileSync4(PAUSED_FLAG, "", { mode: 384 });
+    } catch {}
+  } else if (action === "show" || action === "enable") {
+    try {
+      rmSync3(PAUSED_FLAG, { force: true });
+    } catch {}
+  }
+  if (action !== "quit" && process.env.GAMEPIGEON_OVERLAY_DRY_RUN !== "1" && !process.env.GAMEPIGEON_OVERLAY_BIN) {
+    await ensureOverlayBinary(root);
+  }
+  let binary;
+  try {
+    binary = resolveOverlayBinary(root);
+  } catch (error) {
+    if (action === "quit")
+      return;
+    throw error;
+  }
+  const spawnArgs = overlaySpawnArgs(action, options);
+  if (process.env.GAMEPIGEON_OVERLAY_DRY_RUN === "1") {
+    console.log(JSON.stringify([binary, ...spawnArgs]));
+    return;
+  }
+  if (action === "quit") {
+    await quitOverlay(binary, false);
+    return;
+  }
+  const child = Bun.spawn([binary, ...spawnArgs], {
+    cwd: root,
+    detached: true,
+    env: {
+      ...process.env,
+      GAMEPIGEON_OVERLAY_LEASE: OVERLAY_LEASE_FILE,
+      ...options.gameId ? { GAMEPIGEON_GAME: options.gameId } : {},
+      ...options.variationId ? { GAMEPIGEON_VARIATION: options.variationId } : {}
+    },
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "ignore"
+  });
+  child.unref();
+}
+if (false) {}
+
 // src/index.ts
-var ROOT = join4(dirname3(fileURLToPath(import.meta.url)), "..");
+var ROOT = join5(dirname4(fileURLToPath2(import.meta.url)), "..");
 function captureAuthSuccess(result) {
   if (result.userId)
     analytics.setDistinctId(result.userId);
@@ -8334,14 +8611,15 @@ function printUsage() {
   console.log("usage: gamepigeon [game]");
   console.log("       gamepigeon auth [signup|login|oauth|status|logout]");
   console.log("       gamepigeon auth oauth <google|github>");
-  console.log("       gamepigeon install [--codex|--claude|--opencode|--hermes|--openclaw|--all]");
+  console.log("       gamepigeon install [--codex|--claude|--opencode|--hermes|--openclaw|--antigravity|--all]");
   console.log("");
   console.log("With no argument, opens the arcade overlay menu.");
   console.log(`Available games: ${ids}`);
 }
 async function installAdapters(target) {
-  const proc = Bun.spawn(["bash", join4(ROOT, "scripts/install-adapters.sh"), target ?? "--all"], {
+  const proc = Bun.spawn(["bash", join5(ROOT, "scripts/install-adapters.sh"), target ?? "--all"], {
     cwd: ROOT,
+    env: { ...process.env, GAMEPIGEON_WORKSPACE_DIR: process.cwd() },
     stdin: "ignore",
     stdout: "inherit",
     stderr: "inherit"
@@ -8350,19 +8628,8 @@ async function installAdapters(target) {
   if (proc.exitCode !== 0)
     process.exit(proc.exitCode ?? 1);
 }
-async function launchOverlay(gameId) {
-  const args = ["bun", join4(ROOT, "scripts/overlay.ts"), "--show"];
-  if (gameId)
-    args.push("--game", gameId);
-  const proc = Bun.spawn(args, {
-    cwd: ROOT,
-    stdin: "ignore",
-    stdout: "inherit",
-    stderr: "inherit"
-  });
-  await proc.exited;
-  if (proc.exitCode !== 0)
-    process.exit(proc.exitCode ?? 1);
+async function launchOverlay2(gameId) {
+  await launchOverlay("show", ROOT, { gameId });
 }
 async function main() {
   let arg = process.argv[2];
@@ -8396,7 +8663,7 @@ async function main() {
     }
     gameId = entry.id;
   }
-  await launchOverlay(gameId);
+  await launchOverlay2(gameId);
 }
 main().catch((error) => {
   console.error(error instanceof Error ? error.message : String(error));