@mpgd/cli 0.6.0 → 0.7.0

package/templates/phaser-game/src/platform/devvitEntrypoint.ts

@@ -0,0 +1,57 @@
+import {
+  requestDevvitExpandedMode,
+  startDevvitWebSurface,
+} from '@mpgd/adapter-devvit/web';
+
+await startDevvitWebSurface({
+  async mountInlinePreview() {
+    await import('./devvitInlinePreview.css');
+    renderInlinePreview();
+  },
+  async loadExpandedGame() {
+    await import('../main');
+  },
+  onModeUnavailable(error) {
+    if (!(error instanceof ReferenceError)) {
+      console.warn('[devvit] web view mode unavailable; loading the game surface.', error);
+    }
+  },
+});
+
+function renderInlinePreview(): void {
+  const preview = document.createElement('main');
+  preview.className = 'devvit-preview';
+
+  const eyebrow = document.createElement('p');
+  eyebrow.className = 'devvit-preview__eyebrow';
+  eyebrow.textContent = 'Ready to play';
+
+  const title = document.createElement('h1');
+  title.textContent = '__GAME_TITLE__';
+
+  const description = document.createElement('p');
+  description.className = 'devvit-preview__description';
+  description.textContent = 'Open the expanded view to start the game.';
+
+  const button = document.createElement('button');
+  button.className = 'devvit-preview__button';
+  button.type = 'button';
+  button.textContent = 'Play';
+  button.addEventListener('click', async (event) => {
+    try {
+      await requestDevvitExpandedMode(event, 'game');
+    } catch (error) {
+      console.error('[devvit] expanded game surface request failed.', error);
+    }
+  });
+
+  preview.append(eyebrow, title, description, button);
+  const body = document.body;
+
+  if (body === null) {
+    throw new Error('Devvit inline preview requires a document body.');
+  }
+
+  body.classList.add('devvit-preview-host');
+  body.replaceChildren(preview);
+}

package/templates/phaser-game/src/platform/devvitInlinePreview.css

@@ -0,0 +1,75 @@
+body.devvit-preview-host {
+  min-width: 320px;
+  min-height: 100vh;
+  margin: 0;
+  background: #0f172a;
+}
+
+.devvit-preview,
+.devvit-preview * {
+  box-sizing: border-box;
+}
+
+.devvit-preview {
+  min-height: 100vh;
+  display: grid;
+  place-content: center;
+  justify-items: start;
+  gap: 0.75rem;
+  padding: clamp(1.25rem, 5vw, 3rem);
+  background:
+    radial-gradient(circle at 85% 15%, rgb(56 189 248 / 0.2), transparent 38%),
+    linear-gradient(145deg, #0f172a, #172554);
+  color: #f8fafc;
+  font-family: Inter, ui-sans-serif, system-ui, sans-serif;
+}
+
+.devvit-preview__eyebrow,
+.devvit-preview__description,
+.devvit-preview h1 {
+  margin: 0;
+}
+
+.devvit-preview__eyebrow {
+  color: #7dd3fc;
+  font-size: 0.75rem;
+  font-weight: 700;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+
+.devvit-preview h1 {
+  max-width: 18ch;
+  font-size: clamp(2rem, 9vw, 4.5rem);
+  line-height: 0.95;
+}
+
+.devvit-preview__description {
+  max-width: 36rem;
+  color: #cbd5e1;
+  line-height: 1.5;
+}
+
+.devvit-preview__button {
+  min-height: 2.75rem;
+  margin-top: 0.5rem;
+  padding: 0.65rem 1.25rem;
+  border: 0;
+  border-radius: 999px;
+  color: #082f49;
+  background: #7dd3fc;
+  font: inherit;
+  font-weight: 800;
+  cursor: pointer;
+}
+
+.devvit-preview__button:focus-visible {
+  outline: 3px solid #f8fafc;
+  outline-offset: 3px;
+}
+
+@media (hover: hover) {
+  .devvit-preview__button:hover {
+    filter: brightness(1.1);
+  }
+}

package/templates/phaser-game/src/platform/gameServices.ts

@@ -1,70 +1,27 @@
 import {
-  createGameServicesClient,
-  createGameServicesFetchBackendTransport,
-  createGameServicesHttpBackendApi,
-  createGameServicesOrpcBackendApi,
-  createGameServicesOrpcClient,
-  type GameServicesClient,
-  type GameServicesStoreTarget,
+  createGameServicesRuntime,
+  resolveGameServicesAuthorityMode,
+  resolveGameServicesTransport,
+  type GameServicesRuntime,
+  type GameServicesRuntimeMode,
 } from '@mpgd/game-services';
-import type { PlatformGateway, PlatformTarget } from '@mpgd/platform';
+import type { PlatformGateway } from '@mpgd/platform';
 
-export type StarterBackendMode = 'disabled' | 'http' | 'orpc';
-
-export interface StarterGameServices {
-  readonly mode: StarterBackendMode;
-  readonly baseUrl?: string;
-  readonly target?: GameServicesStoreTarget;
-  readonly client?: GameServicesClient;
-}
+export type StarterBackendMode = GameServicesRuntimeMode;
+export type StarterGameServices = GameServicesRuntime;
 
 export function createStarterGameServices(input: {
   readonly gateway: PlatformGateway;
   readonly playerId: string;
 }): StarterGameServices {
-  const baseUrl = import.meta.env.VITE_MPGD_GAME_SERVICES_URL;
-  const requestedMode = import.meta.env.VITE_MPGD_GAME_SERVICES_TRANSPORT;
-  const storeTarget = readStoreTarget(
-    import.meta.env.VITE_MPGD_GAME_SERVICES_TARGET ?? input.gateway.target,
-  );
-
-  if (baseUrl === undefined || baseUrl.length === 0 || storeTarget === null) {
-    return {
-      mode: 'disabled',
-    };
-  }
-
-  const mode = requestedMode === 'orpc' ? 'orpc' : 'http';
-  const backend =
-    mode === 'orpc'
-      ? createGameServicesOrpcBackendApi(
-          createGameServicesOrpcClient({
-            url: baseUrl,
-          }),
-        )
-      : createGameServicesHttpBackendApi({
-          transport: createGameServicesFetchBackendTransport({
-            baseUrl,
-          }),
-        });
-
-  return {
-    mode,
-    baseUrl,
-    target: storeTarget,
-    client: createGameServicesClient({
-      gateway: input.gateway,
-      backend,
-      playerId: input.playerId,
-      target: storeTarget,
-    }),
-  };
-}
-
-function readStoreTarget(target: PlatformTarget | string): GameServicesStoreTarget | null {
-  if (target === 'android' || target === 'ios' || target === 'ait') {
-    return target;
-  }
-
-  return null;
+  return createGameServicesRuntime({
+    gateway: input.gateway,
+    playerId: input.playerId,
+    authorityMode: resolveGameServicesAuthorityMode(import.meta.env.MODE),
+    target: import.meta.env.VITE_MPGD_GAME_SERVICES_TARGET ?? input.gateway.target,
+    ...(import.meta.env.VITE_MPGD_GAME_SERVICES_URL === undefined
+      ? {}
+      : { baseUrl: import.meta.env.VITE_MPGD_GAME_SERVICES_URL }),
+    transport: resolveGameServicesTransport(import.meta.env.VITE_MPGD_GAME_SERVICES_TRANSPORT),
+  });
 }

package/templates/phaser-game/src/platform/installPlatform.ts

@@ -1,7 +1,8 @@
+import { createBuildGateway } from '#mpgd-platform-gateway';
+
 import type { AdPlacements, ProductCatalog } from '@mpgd/catalog';
 import productCatalogJson from '@mpgd/catalog/catalog.json';
 import adPlacementsJson from '@mpgd/catalog/placements.json';
-import type { PlatformGateway } from '@mpgd/platform';
 import {
   createEffectiveTargetConfig,
   getTargetConfig,
@@ -14,7 +15,6 @@ import targetConfigMatrixJson from '@mpgd/target-config/targets.json';
 
 import type { RuntimeConfig } from './runtimeDetector';
 
-const devvitSandboxBuildId = 'devvit-sandbox';
 const targetConfigMatrix = targetConfigMatrixJson as TargetConfigMatrix;
 const productCatalog = productCatalogJson as ProductCatalog;
 const adPlacements = adPlacementsJson as AdPlacements;
@@ -27,50 +27,7 @@ const adPlacementTypes = new Map<string, 'rewarded' | 'interstitial'>(
 );
 
 export async function installPlatform(runtime: RuntimeConfig): Promise<TargetConfiguredGateway> {
-  let gateway: PlatformGateway;
-
-  switch (runtime.target) {
-    case 'android':
-    case 'ios': {
-      const { createCapacitorPlatformGateway } = await import('@mpgd/adapter-capacitor');
-      gateway = createCapacitorPlatformGateway({
-        target: runtime.target,
-        appVersion: runtime.appVersion,
-        buildId: runtime.buildId,
-      });
-      break;
-    }
-
-    case 'ait': {
-      const { createAitPlatformGateway, createAitSandboxBridge } = await import(
-        '@mpgd/adapter-ait'
-      );
-      gateway = createAitPlatformGateway({
-        appVersion: runtime.appVersion,
-        buildId: runtime.buildId,
-        ...(runtime.debug ? { fallbackBridge: createAitSandboxBridge() } : {}),
-      });
-      break;
-    }
-
-    case 'reddit': {
-      const { createDevvitPlatformGateway, createDevvitSandboxBridge } = await import(
-        '@mpgd/adapter-devvit'
-      );
-      gateway = createDevvitPlatformGateway({
-        appVersion: runtime.appVersion,
-        buildId: runtime.buildId,
-        ...(shouldUseDevvitSandbox(runtime) ? { fallbackBridge: createDevvitSandboxBridge() } : {}),
-      });
-      break;
-    }
-
-    default: {
-      const { createBrowserPlatformGateway } = await import('@mpgd/adapter-browser');
-      gateway = createBrowserPlatformGateway();
-    }
-  }
-
+  const gateway = await createBuildGateway(runtime);
   const configTarget = runtime.configTarget || targetConfigKeyForPlatform(runtime.target);
   const targetConfig = getTargetConfig(targetConfigMatrix, configTarget);
   const effectiveConfig = createEffectiveTargetConfig({
@@ -79,6 +36,9 @@ export async function installPlatform(runtime: RuntimeConfig): Promise<TargetCon
     config: targetConfig,
     catalog: productCatalog,
     adPlacements,
+    ...(__MPGD_PLATFORM_TARGET__ === undefined
+      ? {}
+      : { platformTarget: __MPGD_PLATFORM_TARGET__ }),
   });
 
   return withTargetAvailability(gateway, targetConfig, {
@@ -90,7 +50,3 @@ export async function installPlatform(runtime: RuntimeConfig): Promise<TargetCon
     },
   });
 }
-
-function shouldUseDevvitSandbox(runtime: RuntimeConfig): boolean {
-  return runtime.debug && runtime.buildId === devvitSandboxBuildId;
-}

package/templates/phaser-game/src/platform/microsoftStorePwa.ts

@@ -0,0 +1,99 @@
+export const microsoftStorePwaUpdateReadyEvent = 'mpgd:pwa-update-ready';
+
+export interface MicrosoftStorePwaUpdateReadyDetail {
+  readonly registration: ServiceWorkerRegistration;
+}
+
+export function shouldInstallMicrosoftStorePwa(input: {
+  readonly configTarget: string;
+  readonly debug: boolean;
+}): boolean {
+  return input.configTarget === 'microsoft-store' && !input.debug;
+}
+
+export function installMicrosoftStorePwa(input: {
+  readonly configTarget: string;
+  readonly debug: boolean;
+  readonly onUpdateReady?: (detail: MicrosoftStorePwaUpdateReadyDetail) => void;
+  readonly onRegistrationError?: (error: unknown) => void;
+}): () => void {
+  if (
+    !shouldInstallMicrosoftStorePwa(input)
+    || typeof navigator === 'undefined'
+    || !('serviceWorker' in navigator)
+    || typeof document === 'undefined'
+  ) {
+    return () => {};
+  }
+
+  let disposed = false;
+  let registration: ServiceWorkerRegistration | null = null;
+  let installingWorker: ServiceWorker | null = null;
+  const announceWaitingUpdate = () => {
+    if (
+      disposed
+      || registration === null
+      || registration.waiting === null
+      || navigator.serviceWorker.controller === null
+    ) {
+      return;
+    }
+
+    const detail = { registration } satisfies MicrosoftStorePwaUpdateReadyDetail;
+
+    if (input.onUpdateReady !== undefined) {
+      input.onUpdateReady(detail);
+      return;
+    }
+
+    globalThis.dispatchEvent(new CustomEvent(microsoftStorePwaUpdateReadyEvent, { detail }));
+  };
+  const handleInstallingStateChange = () => {
+    if (installingWorker?.state === 'installed') {
+      announceWaitingUpdate();
+    }
+  };
+  const handleUpdateFound = () => {
+    installingWorker?.removeEventListener('statechange', handleInstallingStateChange);
+    installingWorker = registration?.installing ?? null;
+    installingWorker?.addEventListener('statechange', handleInstallingStateChange);
+  };
+  const register = async () => {
+    try {
+      registration = await navigator.serviceWorker.register('./service-worker.js', {
+        scope: './',
+        updateViaCache: 'none',
+      });
+
+      if (disposed) {
+        return;
+      }
+
+      registration.addEventListener('updatefound', handleUpdateFound);
+      handleUpdateFound();
+      announceWaitingUpdate();
+    } catch (error) {
+      if (input.onRegistrationError !== undefined) {
+        input.onRegistrationError(error);
+      } else {
+        console.warn('[mpgd] Microsoft Store service worker registration failed.', error);
+      }
+    }
+  };
+  const handleWindowLoad = () => {
+    void register();
+  };
+
+  if (document.readyState === 'complete') {
+    void register();
+  } else {
+    globalThis.addEventListener('load', handleWindowLoad, { once: true });
+  }
+
+  return () => {
+    disposed = true;
+    globalThis.removeEventListener('load', handleWindowLoad);
+    installingWorker?.removeEventListener('statechange', handleInstallingStateChange);
+    registration?.removeEventListener('updatefound', handleUpdateFound);
+  };
+}

package/templates/phaser-game/tools/run-game-acceptance.mjs

@@ -0,0 +1,22 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { runMpgdCli } from '@mpgd/cli';
+
+const gameRoot = fileURLToPath(new URL('../', import.meta.url));
+const configuredKitPath = process.env.MPGD_KIT_PATH;
+const kitPath = path.resolve(
+  gameRoot,
+  configuredKitPath === undefined || configuredKitPath.length === 0
+    ? '__DEFAULT_KIT_PATH__'
+    : configuredKitPath,
+);
+
+await runMpgdCli([
+  'game',
+  'accept',
+  gameRoot,
+  '--kit-path',
+  kitPath,
+  ...process.argv.slice(2),
+]);

package/templates/phaser-game/vite.config.ts

@@ -1,11 +1,25 @@
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 
 import ttsc from '@ttsc/unplugin/vite';
 import { defineConfig } from 'vite';
 
+interface RuntimePlatformTargetMetadata {
+  readonly kind: string;
+  readonly adapter: string;
+  readonly integrations?: Record<string, unknown>;
+}
+
 export default defineConfig(({ mode }) => {
   const isProduction = mode === 'production';
+  const platformTarget = readRuntimePlatformTarget();
+  const appTarget = process.env.APP_TARGET ?? 'browser';
+  const isDevvitBuild = appTarget === 'reddit';
+  const buildGatewayModule = resolveBuildGatewayModule({
+    target: appTarget,
+    debug: !isProduction,
+    buildId: process.env.BUILD_ID ?? 'local',
+  });
 
   return {
     base: './',
@@ -16,11 +30,16 @@ export default defineConfig(({ mode }) => {
       }),
     ],
     resolve: {
-      alias: createCatalogAliases(),
+      alias: {
+        ...createCatalogAliases(),
+        '#mpgd-platform-gateway': resolve(buildGatewayModule),
+      },
     },
     define: {
-      __APP_TARGET__: JSON.stringify(process.env.APP_TARGET ?? 'browser'),
+      __APP_TARGET__: JSON.stringify(appTarget),
       __MPGD_CONFIG_TARGET__: JSON.stringify(process.env.MPGD_CONFIG_TARGET ?? ''),
+      __MPGD_PLATFORM_TARGET__:
+        platformTarget === undefined ? 'undefined' : JSON.stringify(platformTarget),
       __APP_VERSION__: JSON.stringify(process.env.APP_VERSION ?? '0.0.0-dev'),
       __BUILD_ID__: JSON.stringify(process.env.BUILD_ID ?? 'local'),
       __SOURCE_GIT_SHA__: JSON.stringify(process.env.MPGD_SOURCE_GIT_SHA ?? 'uncommitted'),
@@ -33,8 +52,16 @@ export default defineConfig(({ mode }) => {
       assetsDir: 'assets',
       emptyOutDir: true,
       rolldownOptions: {
+        ...(isDevvitBuild
+          ? {
+              input: {
+                preview: resolve('index.html'),
+                game: resolve('game.html'),
+              },
+            }
+          : {}),
         output: {
-          entryFileNames: 'assets/game.js',
+          entryFileNames: isDevvitBuild ? 'assets/[name].js' : 'assets/game.js',
           chunkFileNames: 'assets/[name].js',
           assetFileNames: 'assets/[name][extname]',
         },
@@ -43,6 +70,29 @@ export default defineConfig(({ mode }) => {
   };
 });
 
+export function resolveBuildGatewayModule(input: {
+  readonly target: string;
+  readonly debug: boolean;
+  readonly buildId: string;
+}): string {
+  switch (input.target) {
+    case 'android':
+      return 'src/platform/buildGateways/capacitorAndroid.ts';
+    case 'ios':
+      return 'src/platform/buildGateways/capacitorIos.ts';
+    case 'ait':
+      return input.debug
+        ? 'src/platform/buildGateways/aitSandbox.ts'
+        : 'src/platform/buildGateways/ait.ts';
+    case 'reddit':
+      return input.debug && input.buildId === 'devvit-sandbox'
+        ? 'src/platform/buildGateways/redditSandbox.ts'
+        : 'src/platform/buildGateways/reddit.ts';
+    default:
+      return 'src/platform/buildGateways/browser.ts';
+  }
+}
+
 function createCatalogAliases(): Record<string, string> {
   const productCatalogFile = readConfiguredPath(process.env.MPGD_PRODUCT_CATALOG_FILE);
   const adPlacementsFile = readConfiguredPath(process.env.MPGD_AD_PLACEMENTS_FILE);
@@ -68,6 +118,58 @@ function readConfiguredPath(value: string | undefined): string | undefined {
   return normalized === undefined || normalized.length === 0 ? undefined : normalized;
 }
 
+function readRuntimePlatformTarget(): RuntimePlatformTargetMetadata | undefined {
+  const targetsFile = readConfiguredPath(process.env.MPGD_PLATFORM_TARGETS_FILE);
+  const configTarget = readConfiguredPath(process.env.MPGD_CONFIG_TARGET);
+
+  if (targetsFile === undefined || configTarget === undefined) {
+    return undefined;
+  }
+
+  const resolvedTargetsFile = resolve(targetsFile);
+  let parsed: unknown;
+
+  try {
+    parsed = JSON.parse(readFileSync(resolvedTargetsFile, 'utf8'));
+  } catch (error) {
+    throw new Error(
+      `Failed to read or parse MPGD_PLATFORM_TARGETS_FILE at ${resolvedTargetsFile}: ${formatError(error)}`,
+    );
+  }
+
+  if (!isRecord(parsed) || !isRecord(parsed.targets)) {
+    throw new Error('MPGD_PLATFORM_TARGETS_FILE must contain a targets object.');
+  }
+
+  const target = parsed.targets[configTarget];
+
+  if (!isRecord(target)) {
+    throw new Error(`Missing platform target metadata for ${configTarget}.`);
+  }
+
+  if (typeof target.kind !== 'string' || typeof target.adapter !== 'string') {
+    throw new Error(`Platform target ${configTarget} must define kind and adapter.`);
+  }
+
+  if (target.integrations !== undefined && !isRecord(target.integrations)) {
+    throw new Error(`Platform target ${configTarget} integrations must be an object.`);
+  }
+
+  return {
+    kind: target.kind,
+    adapter: target.adapter,
+    ...(target.integrations === undefined ? {} : { integrations: target.integrations }),
+  };
+}
+
+function isRecord(input: unknown): input is Record<string, unknown> {
+  return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+
+function formatError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 function resolveCatalogPath(path: string, pairedPath: string): string {
   return resolve(resolveCatalogBaseDir(path, pairedPath), path);
 }