dreamboard 0.1.21 → 0.1.23

package/dist/dev-host/dev-host-session-transport.ts

@@ -0,0 +1,52 @@
+import {
+  defaultHostSessionTransport,
+  type HostSessionTransport,
+} from "@dreamboard/ui-host-runtime/runtime";
+
+type HostSessionSnapshot = Awaited<
+  ReturnType<HostSessionTransport["loadSessionSnapshot"]>
+>;
+
+type DevHostSessionSnapshot = HostSessionSnapshot & {
+  context: HostSessionSnapshot["context"] & { seed?: number | null };
+};
+
+async function requestSnapshot(
+  path: string,
+  init: RequestInit,
+): Promise<DevHostSessionSnapshot> {
+  const response = await fetch(path, init);
+  const contentType = response.headers.get("content-type") ?? "";
+  const payload = contentType.includes("application/json")
+    ? await response.json()
+    : await response.text();
+  if (!response.ok) {
+    throw payload;
+  }
+  return payload as DevHostSessionSnapshot;
+}
+
+export function createDevHostSessionTransport(): HostSessionTransport {
+  return {
+    ...defaultHostSessionTransport,
+    loadSessionSnapshot: async (input) =>
+      requestSnapshot(
+        input.requestedPlayerId?.trim()
+          ? `/__dreamboard_dev/session/snapshot?playerId=${encodeURIComponent(input.requestedPlayerId.trim())}`
+          : "/__dreamboard_dev/session/snapshot",
+        { method: "GET" },
+      ),
+    startSession: async () =>
+      requestSnapshot("/__dreamboard_dev/session/start", {
+        method: "POST",
+        body: undefined,
+        headers: undefined,
+      }),
+    createDevSessionSnapshot: async (input) =>
+      requestSnapshot("/__dreamboard_dev/session/new", {
+        method: "POST",
+        body: JSON.stringify({ seed: input.seed }),
+        headers: { "content-type": "application/json" },
+      }),
+  };
+}

package/dist/dev-host/dev-host-storage.ts

@@ -0,0 +1,56 @@
+export type ActiveSession = {
+  sessionId: string;
+  shortCode: string;
+  gameId: string;
+  seed: number | null;
+};
+
+export interface DevHostStorage {
+  loadSidebarOpen(): boolean;
+  persistSidebarOpen(open: boolean): void;
+  loadPreferredPlayerId(): string | null;
+  persistPreferredPlayerId(playerId: string | null): void;
+}
+
+const SIDEBAR_STORAGE_KEY = "dreamboard-dev-sidebar";
+const PREFERRED_PLAYER_STORAGE_KEY = "dreamboard-dev-preferred-player";
+
+export class SessionStorageDevHostStorage implements DevHostStorage {
+  constructor(private readonly storage: Storage) {}
+
+  loadSidebarOpen(): boolean {
+    try {
+      return this.storage.getItem(SIDEBAR_STORAGE_KEY) === "true";
+    } catch {
+      return false;
+    }
+  }
+
+  persistSidebarOpen(open: boolean): void {
+    try {
+      this.storage.setItem(SIDEBAR_STORAGE_KEY, String(open));
+    } catch {
+      // Ignore persistence failures in locked-down browser contexts.
+    }
+  }
+
+  loadPreferredPlayerId(): string | null {
+    try {
+      return this.storage.getItem(PREFERRED_PLAYER_STORAGE_KEY)?.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+
+  persistPreferredPlayerId(playerId: string | null): void {
+    try {
+      if (playerId?.trim()) {
+        this.storage.setItem(PREFERRED_PLAYER_STORAGE_KEY, playerId.trim());
+      } else {
+        this.storage.removeItem(PREFERRED_PLAYER_STORAGE_KEY);
+      }
+    } catch {
+      // Ignore persistence failures in locked-down browser contexts.
+    }
+  }
+}

package/dist/dev-host/dev-log-relay-plugin.ts

@@ -0,0 +1,469 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import consola from "consola";
+import type { Plugin } from "vite";
+import type { ResolvedConfig } from "../types.js";
+import { createPersistedDevSession } from "../utils/dev-session.js";
+import { exists, readJsonFile, writeJsonFile } from "../utils/fs.js";
+import { resolveDevBearer } from "./dev-api-proxy-plugin.js";
+import {
+  shouldRelayDevLog,
+  type DevDiagnosticsLevel,
+  type DevLogEnvelope,
+} from "./dev-diagnostics.js";
+import type { DreamboardDevRuntimeConfig } from "./dev-runtime-config.js";
+import type { ActiveSession } from "./dev-host-storage.js";
+
+export function createDevLogRelayPlugin(options: {
+  sessionFilePath: string;
+  runtimeConfig: DreamboardDevRuntimeConfig;
+  config: ResolvedConfig;
+  diagnosticsLevel: DevDiagnosticsLevel;
+}): Plugin {
+  return {
+    name: "dreamboard-dev-log-relay",
+    configureServer(server) {
+      server.middlewares.use("/__dreamboard_dev/log", (req, res) => {
+        if (req.method !== "POST") {
+          res.statusCode = 405;
+          res.setHeader("content-type", "application/json");
+          res.end(JSON.stringify({ error: "Method not allowed" }));
+          return;
+        }
+
+        const chunks: Buffer[] = [];
+        req.on("data", (chunk) => {
+          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        req.on("end", () => {
+          try {
+            const body = Buffer.concat(chunks).toString("utf8");
+            const payload = JSON.parse(body) as Partial<DevLogEnvelope>;
+            const normalizedPayload = {
+              source: coerceLogSource(payload.source),
+              level: coerceLogLevel(payload.level),
+              message:
+                typeof payload.message === "string"
+                  ? payload.message
+                  : "Missing dev log message",
+            } satisfies DevLogEnvelope;
+            if (
+              shouldRelayDevLog(options.diagnosticsLevel, normalizedPayload)
+            ) {
+              relayDevLog(normalizedPayload);
+            }
+            res.statusCode = 204;
+            res.end();
+          } catch (error) {
+            consola.warn(
+              `[dev-host] Failed to decode browser log payload: ${formatUnknown(error)}`,
+            );
+            res.statusCode = 400;
+            res.setHeader("content-type", "application/json");
+            res.end(JSON.stringify({ error: "Invalid dev log payload" }));
+          }
+        });
+      });
+
+      server.middlewares.use(
+        "/__dreamboard_dev/session/snapshot",
+        createSnapshotSessionHandler({
+          sessionFilePath: options.sessionFilePath,
+          runtimeConfig: options.runtimeConfig,
+          config: options.config,
+        }),
+      );
+      server.middlewares.use(
+        "/__dreamboard_dev/session/new",
+        createNewSessionHandler({
+          sessionFilePath: options.sessionFilePath,
+          runtimeConfig: options.runtimeConfig,
+          config: options.config,
+        }),
+      );
+      server.middlewares.use(
+        "/__dreamboard_dev/session/start",
+        createStartSessionHandler({
+          sessionFilePath: options.sessionFilePath,
+          runtimeConfig: options.runtimeConfig,
+          config: options.config,
+        }),
+      );
+    },
+  };
+}
+
+export function createSnapshotSessionHandler(options: {
+  sessionFilePath: string;
+  runtimeConfig: DreamboardDevRuntimeConfig;
+  config: ResolvedConfig;
+}): (req: IncomingMessage, res: ServerResponse) => void {
+  return (req, res) => {
+    void handleSnapshotSessionRequest(req, res, options);
+  };
+}
+
+export function createNewSessionHandler(options: {
+  sessionFilePath: string;
+  runtimeConfig: DreamboardDevRuntimeConfig;
+  config: ResolvedConfig;
+}): (req: IncomingMessage, res: ServerResponse) => void {
+  return (req, res) => {
+    void handleNewSessionRequest(req, res, options);
+  };
+}
+
+export function createStartSessionHandler(options: {
+  sessionFilePath: string;
+  runtimeConfig: DreamboardDevRuntimeConfig;
+  config: ResolvedConfig;
+}): (req: IncomingMessage, res: ServerResponse) => void {
+  return (req, res) => {
+    void handleStartSessionRequest(req, res, options);
+  };
+}
+
+async function handleSnapshotSessionRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  options: {
+    sessionFilePath: string;
+    runtimeConfig: DreamboardDevRuntimeConfig;
+    config: ResolvedConfig;
+  },
+): Promise<void> {
+  if (req.method !== "GET") {
+    respondJson(res, 405, { error: "Method not allowed" });
+    return;
+  }
+
+  try {
+    const session = await loadCurrentSession(options);
+    const requestedPlayerId = extractQueryParam(req, "playerId");
+    let snapshot = await fetchBackendJson(
+      options.config,
+      appendQuery(`/api/sessions/${session.sessionId}/snapshot`, {
+        playerId: requestedPlayerId,
+      }),
+    );
+    if (
+      options.runtimeConfig.autoStartGame &&
+      isStartableLobbySnapshot(snapshot)
+    ) {
+      snapshot = await fetchBackendJson(
+        options.config,
+        `/api/sessions/${session.sessionId}/start`,
+        { method: "POST" },
+      );
+      if (requestedPlayerId) {
+        snapshot = await fetchBackendJson(
+          options.config,
+          appendQuery(`/api/sessions/${session.sessionId}/snapshot`, {
+            playerId: requestedPlayerId,
+          }),
+        );
+      }
+      await persistSessionId(options.sessionFilePath, session.sessionId);
+    }
+    respondJson(res, 200, attachLocalSeed(snapshot, session.seed ?? null));
+  } catch (error) {
+    respondJson(res, statusForError(error), { error: formatUnknown(error) });
+  }
+}
+
+async function handleNewSessionRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  options: {
+    sessionFilePath: string;
+    runtimeConfig: DreamboardDevRuntimeConfig;
+    config: ResolvedConfig;
+  },
+): Promise<void> {
+  if (req.method !== "POST") {
+    respondJson(res, 405, { error: "Method not allowed" });
+    return;
+  }
+
+  try {
+    const body = await readJsonBody(req);
+    const seed = Number.parseInt(String(body.seed ?? ""), 10);
+    if (!Number.isSafeInteger(seed)) {
+      throw new Error("Seed must be a safe integer.");
+    }
+    const created = await fetchBackendJson(
+      options.config,
+      `/api/games/${options.runtimeConfig.gameId}/sessions`,
+      {
+        method: "POST",
+        body: {
+          compiledResultId: options.runtimeConfig.compiledResultId,
+          seed,
+          playerCount: options.runtimeConfig.playerCount,
+          autoAssignSeats: true,
+          setupProfileId: options.runtimeConfig.setupProfileId ?? undefined,
+        },
+      },
+    );
+    const sessionId = requireString(
+      (created as { sessionId?: unknown }).sessionId,
+      "sessionId",
+    );
+    let snapshot = await fetchBackendJson(
+      options.config,
+      `/api/sessions/${sessionId}/snapshot`,
+    );
+    if (
+      options.runtimeConfig.autoStartGame &&
+      isStartableLobbySnapshot(snapshot)
+    ) {
+      snapshot = await fetchBackendJson(
+        options.config,
+        `/api/sessions/${sessionId}/start`,
+        {
+          method: "POST",
+        },
+      );
+    }
+    await persistSessionId(options.sessionFilePath, sessionId);
+    respondJson(res, 200, attachLocalSeed(snapshot, seed));
+  } catch (error) {
+    respondJson(res, statusForError(error), { error: formatUnknown(error) });
+  }
+}
+
+async function handleStartSessionRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  options: {
+    sessionFilePath: string;
+    runtimeConfig: DreamboardDevRuntimeConfig;
+    config: ResolvedConfig;
+  },
+): Promise<void> {
+  if (req.method !== "POST") {
+    respondJson(res, 405, { error: "Method not allowed" });
+    return;
+  }
+
+  try {
+    const session = await loadCurrentSession(options);
+    const snapshot = await fetchBackendJson(
+      options.config,
+      `/api/sessions/${session.sessionId}/start`,
+      { method: "POST" },
+    );
+    await persistSessionId(options.sessionFilePath, session.sessionId);
+    respondJson(res, 200, attachLocalSeed(snapshot, session.seed ?? null));
+  } catch (error) {
+    respondJson(res, statusForError(error), { error: formatUnknown(error) });
+  }
+}
+
+async function readJsonBody(
+  req: IncomingMessage,
+): Promise<Record<string, unknown>> {
+  const chunks: Buffer[] = [];
+  await new Promise<void>((resolve, reject) => {
+    req.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on("end", () => resolve());
+    req.on("error", reject);
+  });
+  const text = Buffer.concat(chunks).toString("utf8");
+  return text ? (JSON.parse(text) as Record<string, unknown>) : {};
+}
+
+function requireString(value: unknown, field: string): string {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Missing required field: ${field}`);
+  }
+  return value;
+}
+
+function extractQueryParam(req: IncomingMessage, name: string): string | null {
+  const rawUrl = req.url ?? "";
+  const value = new URL(rawUrl, "http://dreamboard.local").searchParams.get(
+    name,
+  );
+  return value?.trim() || null;
+}
+
+function appendQuery(
+  path: string,
+  query: Record<string, string | null | undefined>,
+): string {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value) {
+      params.set(key, value);
+    }
+  }
+  const serialized = params.toString();
+  return serialized ? `${path}?${serialized}` : path;
+}
+
+async function loadCurrentSession(options: {
+  sessionFilePath: string;
+  runtimeConfig: DreamboardDevRuntimeConfig;
+}): Promise<ActiveSession> {
+  if (!(await exists(options.sessionFilePath))) {
+    return options.runtimeConfig.initialSession;
+  }
+
+  const payload = await readJsonFile<unknown>(options.sessionFilePath);
+  const session = parsePersistedSessionPointer(payload, options.runtimeConfig);
+  if (!session) {
+    throw new Error("Session file did not contain a valid session pointer.");
+  }
+  return session;
+}
+
+async function persistSessionId(
+  sessionFilePath: string,
+  sessionId: string,
+): Promise<void> {
+  await writeJsonFile(
+    sessionFilePath,
+    createPersistedDevSession({ sessionId }),
+  );
+}
+
+async function fetchBackendJson(
+  config: ResolvedConfig,
+  path: string,
+  options: {
+    method?: "GET" | "POST";
+    body?: Record<string, unknown>;
+  } = {},
+): Promise<unknown> {
+  const bearer = await resolveDevBearer(config);
+  if (bearer.kind === "permanent_invalid") {
+    throw new HttpError(401, bearer.message);
+  }
+
+  const response = await fetch(`${config.apiBaseUrl}${path}`, {
+    method: options.method ?? "GET",
+    headers: {
+      ...(bearer.token ? { authorization: `Bearer ${bearer.token}` } : {}),
+      ...(options.body ? { "content-type": "application/json" } : {}),
+    },
+    body: options.body ? JSON.stringify(options.body) : undefined,
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new HttpError(
+      response.status,
+      text || `Backend request failed with ${response.status}`,
+    );
+  }
+  return response.json();
+}
+
+function attachLocalSeed(snapshot: unknown, seed: number | null): unknown {
+  if (!snapshot || typeof snapshot !== "object") {
+    return snapshot;
+  }
+  const context = (snapshot as { context?: unknown }).context;
+  if (!context || typeof context !== "object") {
+    return snapshot;
+  }
+  return {
+    ...(snapshot as Record<string, unknown>),
+    context: {
+      ...(context as Record<string, unknown>),
+      seed,
+    },
+  };
+}
+
+function isStartableLobbySnapshot(snapshot: unknown): boolean {
+  if (!snapshot || typeof snapshot !== "object") {
+    return false;
+  }
+  const context = (snapshot as { context?: { phase?: unknown } }).context;
+  const lobby = (snapshot as { lobby?: { canStart?: unknown } }).lobby;
+  return context?.phase === "lobby" && lobby?.canStart === true;
+}
+
+function respondJson(
+  res: ServerResponse,
+  statusCode: number,
+  payload: unknown,
+): void {
+  res.statusCode = statusCode;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify(payload));
+}
+
+function statusForError(error: unknown): number {
+  return error instanceof HttpError ? error.statusCode : 500;
+}
+
+class HttpError extends Error {
+  constructor(
+    readonly statusCode: number,
+    message: string,
+  ) {
+    super(message);
+  }
+}
+
+function parsePersistedSessionPointer(
+  value: unknown,
+  runtimeConfig: DreamboardDevRuntimeConfig,
+): DreamboardDevRuntimeConfig["initialSession"] | null {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const sessionId = (value as { sessionId?: unknown }).sessionId;
+  if (typeof sessionId !== "string" || sessionId.length === 0) {
+    return null;
+  }
+  return {
+    sessionId,
+    shortCode: "Unknown",
+    gameId: runtimeConfig.gameId,
+    seed: null,
+  };
+}
+
+function relayDevLog(payload: DevLogEnvelope): void {
+  const formatted = `[dev:${payload.source}] ${payload.message}`;
+  switch (payload.level) {
+    case "error":
+      consola.error(formatted);
+      break;
+    case "warn":
+      consola.warn(formatted);
+      break;
+    case "info":
+      consola.info(formatted);
+      break;
+    default:
+      consola.log(formatted);
+      break;
+  }
+}
+
+function coerceLogSource(value: unknown): DevLogEnvelope["source"] {
+  return value === "host" || value === "plugin" || value === "sse"
+    ? value
+    : "host";
+}
+
+function coerceLogLevel(value: unknown): DevLogEnvelope["level"] {
+  return value === "warn" ||
+    value === "error" ||
+    value === "info" ||
+    value === "log"
+    ? value
+    : "log";
+}
+
+function formatUnknown(value: unknown): string {
+  if (value instanceof Error) {
+    return value.stack ?? value.message;
+  }
+  return typeof value === "string" ? value : JSON.stringify(value);
+}

package/dist/dev-host/dev-runtime-config.ts

@@ -0,0 +1,14 @@
+import type { ActiveSession } from "./dev-host-storage.js";
+
+export interface DreamboardDevRuntimeConfig {
+  apiBaseUrl: string;
+  userId: string | null;
+  gameId: string;
+  compiledResultId: string;
+  setupProfileId: string | null;
+  playerCount: number;
+  debug: boolean;
+  slug: string;
+  autoStartGame: boolean;
+  initialSession: ActiveSession;
+}