@trolleroof/tui 0.2.4 → 0.2.6

package/src/results/uploader.ts

@@ -0,0 +1,84 @@
+import { TransportError } from "../recording/transport.js";
+import { ResultStore } from "./store.js";
+import type { ResultTransport } from "./transport.js";
+
+export interface ResultUploadResult {
+  acknowledged: number;
+  failed: number;
+  pending: number;
+}
+
+export interface ResultUploaderOptions {
+  maxAttempts?: number;
+  random?: () => number;
+  delay?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
+}
+
+const sleep = (milliseconds: number, signal?: AbortSignal) =>
+  new Promise<void>((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    const timer = setTimeout(finish, milliseconds);
+    timer.unref?.();
+    signal?.addEventListener("abort", finish, { once: true });
+    function finish() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", finish);
+      resolve();
+    }
+  });
+
+export class ResultUploader {
+  private readonly maxAttempts: number;
+  private readonly random: () => number;
+  private readonly delay: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
+
+  constructor(
+    private readonly store: ResultStore,
+    private readonly transport: ResultTransport,
+    options: ResultUploaderOptions = {},
+  ) {
+    this.maxAttempts = options.maxAttempts ?? 5;
+    this.random = options.random ?? Math.random;
+    this.delay = options.delay ?? sleep;
+  }
+
+  async uploadPending(userId: string, signal?: AbortSignal): Promise<ResultUploadResult> {
+    if (signal?.aborted) return { acknowledged: 0, failed: 0, pending: 0 };
+    const initial = this.store.listPending(userId);
+    let acknowledged = 0;
+    let failed = 0;
+    for (const result of initial) {
+      if (signal?.aborted) break;
+      for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+        if (signal?.aborted) break;
+        try {
+          await this.transport.send(result, signal);
+          this.store.acknowledge(result);
+          acknowledged++;
+          break;
+        } catch (error) {
+          if (signal?.aborted) break;
+          if (error instanceof TransportError && !error.retryable) {
+            if (error.quarantine) {
+              this.store.markFailed(result, error.message);
+              failed++;
+            }
+            break;
+          }
+          if (attempt === this.maxAttempts) break;
+          const exponential = 1_000 * 2 ** (attempt - 1);
+          const jittered = Math.round(exponential * (0.5 + this.random()));
+          await this.delay(Math.min(jittered, 60_000), signal);
+        }
+      }
+    }
+    return {
+      acknowledged,
+      failed,
+      pending: this.store.listPending(userId).length,
+    };
+  }
+}

package/src/sync/config.test.ts

@@ -0,0 +1,108 @@
+import { chmodSync, mkdtempSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  backendConfigPath,
+  clearBackendSession,
+  loadBackendConfig,
+  resolveBackendConfig,
+  saveBackendSession,
+} from "./config.js";
+
+const roots: string[] = [];
+afterEach(() => {
+  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+describe("resolveBackendConfig", () => {
+  it("uses the sync backend by default when only a token is configured", () => {
+    expect(resolveBackendConfig({
+      GAMEPIGEON_BACKEND_TOKEN: "retro_user_token",
+    })).toEqual({
+      baseUrl: "https://api.runretroarcade.com",
+      token: "retro_user_token",
+      meUrl: "https://api.runretroarcade.com/v1/me",
+      eventChunksUrl: "https://api.runretroarcade.com/v1/game-event-chunks",
+      gameResultsUrl: "https://api.runretroarcade.com/v1/game-results",
+    });
+  });
+
+  it("prefers the backend URL and opaque token", () => {
+    expect(resolveBackendConfig({
+      GAMEPIGEON_BACKEND_URL: "https://retro.example/",
+      GAMEPIGEON_BACKEND_TOKEN: "retro_user_token",
+      GAMEPIGEON_INGEST_URL: "https://legacy.example/v1/game-event-chunks",
+      GAMEPIGEON_INGEST_API_KEY: "legacy-token",
+    })).toEqual({
+      baseUrl: "https://retro.example",
+      token: "retro_user_token",
+      meUrl: "https://retro.example/v1/me",
+      eventChunksUrl: "https://retro.example/v1/game-event-chunks",
+      gameResultsUrl: "https://retro.example/v1/game-results",
+    });
+  });
+
+  it("supports the temporary ingest aliases as a bearer-token pair", () => {
+    expect(resolveBackendConfig({
+      GAMEPIGEON_INGEST_URL: "http://127.0.0.1:8000/v1/game-event-chunks",
+      GAMEPIGEON_INGEST_API_KEY: "retro_legacy_user_token",
+    }))?.toMatchObject({
+      baseUrl: "http://127.0.0.1:8000",
+      token: "retro_legacy_user_token",
+      gameResultsUrl: "http://127.0.0.1:8000/v1/game-results",
+    });
+  });
+
+  it("keeps remote sync disabled for incomplete configuration", () => {
+    expect(resolveBackendConfig({ GAMEPIGEON_BACKEND_URL: "https://retro.example" }))
+      .toBeNull();
+    expect(resolveBackendConfig({})).toBeNull();
+  });
+
+  it("reloads and tightens the private backend config file", () => {
+    const home = mkdtempSync(join(tmpdir(), "gamepigeon-backend-config-"));
+    roots.push(home);
+    const path = backendConfigPath(home);
+    writeFileSync(path, "https://retro.example\nfirst-token\n", { mode: 0o666 });
+    chmodSync(join(home, ".tui-gamepigeon"), 0o777);
+    expect(loadBackendConfig({}, path)?.token).toBe("first-token");
+    expect(statSync(join(home, ".tui-gamepigeon")).mode & 0o777).toBe(0o700);
+    expect(statSync(path).mode & 0o777).toBe(0o600);
+
+    writeFileSync(path, "https://retro.example\nrotated-token\n", { mode: 0o600 });
+    expect(loadBackendConfig({}, path)?.token).toBe("rotated-token");
+  });
+
+  it("allows direct environment overrides while launcher processes prefer the file", () => {
+    const home = mkdtempSync(join(tmpdir(), "gamepigeon-backend-priority-"));
+    roots.push(home);
+    const path = backendConfigPath(home);
+    writeFileSync(path, "https://file.example\nfile-token\n", { mode: 0o600 });
+    const environment = {
+      GAMEPIGEON_BACKEND_URL: "https://direct.example",
+      GAMEPIGEON_BACKEND_TOKEN: "direct-token",
+    };
+    expect(loadBackendConfig(environment, path)?.token).toBe("direct-token");
+    expect(loadBackendConfig({
+      ...environment,
+      GAMEPIGEON_BACKEND_CONFIG_PREFER_FILE: "1",
+    }, path)?.token).toBe("file-token");
+  });
+
+  it("atomically stores and clears a private backend session", () => {
+    const home = mkdtempSync(join(tmpdir(), "gamepigeon-backend-session-"));
+    roots.push(home);
+    const path = backendConfigPath(home);
+
+    saveBackendSession("session-token", "https://retro.example/", path);
+    expect(loadBackendConfig({}, path)).toMatchObject({
+      baseUrl: "https://retro.example",
+      token: "session-token",
+    });
+    expect(statSync(path).mode & 0o777).toBe(0o600);
+
+    clearBackendSession(path);
+    expect(loadBackendConfig({}, path)).toBeNull();
+  });
+});

package/src/sync/config.ts

@@ -0,0 +1,115 @@
+import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { ensurePrivateDirectory, ensurePrivateFile } from "../recording/permissions.js";
+
+export interface BackendConfig {
+  baseUrl: string;
+  token: string;
+  meUrl: string;
+  eventChunksUrl: string;
+  gameResultsUrl: string;
+}
+
+export const defaultBackendBaseUrl = "https://api.runretroarcade.com";
+
+function normalizedBaseUrl(value: string): string {
+  const parsed = new URL(value);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("GAMEPIGEON_BACKEND_URL must use HTTP or HTTPS");
+  }
+  parsed.pathname = parsed.pathname.replace(/\/$/, "");
+  return parsed.toString().replace(/\/$/, "");
+}
+
+function baseFromLegacyEndpoint(value: string): string {
+  const parsed = new URL(value);
+  parsed.pathname = parsed.pathname.replace(/\/v1\/game-event-chunks\/?$/, "");
+  parsed.search = "";
+  parsed.hash = "";
+  return normalizedBaseUrl(parsed.toString());
+}
+
+export function resolveBackendConfig(
+  environment: Record<string, string | undefined> = process.env,
+): BackendConfig | null {
+  const configuredBase = environment.GAMEPIGEON_BACKEND_URL?.trim();
+  const configuredToken = environment.GAMEPIGEON_BACKEND_TOKEN?.trim();
+  const legacyEndpoint = environment.GAMEPIGEON_INGEST_URL?.trim();
+  const legacyToken = environment.GAMEPIGEON_INGEST_API_KEY?.trim();
+
+  const token = configuredToken || legacyToken;
+  const baseUrl = configuredBase
+    ? normalizedBaseUrl(configuredBase)
+    : legacyEndpoint
+    ? baseFromLegacyEndpoint(legacyEndpoint)
+    // Only the modern token opts into the default backend; a lone legacy key
+    // was issued for a legacy endpoint and must not be sent elsewhere.
+    : configuredToken
+    ? defaultBackendBaseUrl
+    : null;
+  if (!baseUrl || !token) return null;
+
+  return {
+    baseUrl,
+    token,
+    meUrl: `${baseUrl}/v1/me`,
+    eventChunksUrl: `${baseUrl}/v1/game-event-chunks`,
+    gameResultsUrl: `${baseUrl}/v1/game-results`,
+  };
+}
+
+export function backendConfigPath(home = process.env.HOME ?? homedir()): string {
+  const directory = join(home, ".tui-gamepigeon");
+  ensurePrivateDirectory(directory);
+  return join(directory, "backend.conf");
+}
+
+export function saveBackendSession(
+  token: string,
+  baseUrl?: string,
+  path = backendConfigPath(),
+): void {
+  if (!token) throw new Error("Backend session token is required");
+  const normalized = normalizedBaseUrl(baseUrl ?? defaultBackendBaseUrl);
+  ensurePrivateDirectory(dirname(path));
+  const temporary = `${path}.tmp-${process.pid}`;
+  try {
+    writeFileSync(temporary, `${normalized}\n${token}\n`, { mode: 0o600 });
+    renameSync(temporary, path);
+    ensurePrivateFile(path);
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}
+
+export function clearBackendSession(path = backendConfigPath()): void {
+  rmSync(path, { force: true });
+}
+
+function configFromFile(path: string): BackendConfig | null {
+  if (!existsSync(path)) return null;
+  ensurePrivateDirectory(dirname(path));
+  ensurePrivateFile(path);
+  const [baseUrl, token] = readFileSync(path, "utf8").split("\n");
+  if (!baseUrl?.trim() || !token?.trim()) return null;
+  try {
+    return resolveBackendConfig({
+      GAMEPIGEON_BACKEND_URL: baseUrl,
+      GAMEPIGEON_BACKEND_TOKEN: token,
+    });
+  } catch {
+    return null;
+  }
+}
+
+export function loadBackendConfig(
+  environment: Record<string, string | undefined> = process.env,
+  path = backendConfigPath(),
+): BackendConfig | null {
+  const fromEnvironment = () => resolveBackendConfig(environment);
+  if (environment.GAMEPIGEON_BACKEND_CONFIG_PREFER_FILE === "1") {
+    return configFromFile(path) ?? fromEnvironment();
+  }
+  return fromEnvironment() ?? configFromFile(path);
+}