@mpgd/cli 0.6.0 → 0.8.0

package/templates/phaser-game/src/main.ts

@@ -1,7 +1,7 @@
 import './styles.css';
 
 import { createAnalyticsReporter, createBufferedAnalyticsSink } from '@mpgd/analytics';
-import { resolveMpgdLocale, type Locale } from '@mpgd/i18n';
+import { resolveTargetMpgdLocale, type Locale } from '@mpgd/i18n';
 import type { IdentitySession, LaunchIntent, PlatformGateway } from '@mpgd/platform';
 import {
   resolveTargetViewportPlan,
@@ -14,11 +14,13 @@ import { createStarterGame } from './runtime/createGame';
 import { detectRuntime } from './platform/runtimeDetector';
 import { createStarterGameServices } from './platform/gameServices';
 import { installPlatform } from './platform/installPlatform';
+import { installMicrosoftStorePwa } from './platform/microsoftStorePwa';
 
 await bootstrap();
 
 async function bootstrap(): Promise<void> {
   let locale: Locale = 'en';
+  let disposeMicrosoftStorePwa: (() => void) | undefined;
 
   try {
     if (__APP_TARGET__ === 'ait') {
@@ -27,6 +29,7 @@ async function bootstrap(): Promise<void> {
     }
 
     const runtimeConfig = detectRuntime();
+    disposeMicrosoftStorePwa = installMicrosoftStorePwa(runtimeConfig);
     const platform = await installPlatform(runtimeConfig);
     const runtime = await platform.getTargetRuntime();
     const orientationPolicy = {
@@ -46,7 +49,12 @@ async function bootstrap(): Promise<void> {
       resolveIdentitySession(platform, player.playerId),
       resolveLaunchIntent(platform),
     ]);
-    locale = resolveMpgdLocale(runtime.capabilities);
+    locale = resolveTargetMpgdLocale({
+      capabilities: runtime.capabilities,
+      fallbackLocale:
+        runtime.effectiveConfig?.localization.fallbackLocale
+        ?? runtime.config.localization.fallbackLocale,
+    });
     const analyticsSink = createBufferedAnalyticsSink();
     const analytics = createAnalyticsReporter({
       target: platform.target,
@@ -82,6 +90,7 @@ async function bootstrap(): Promise<void> {
       },
     });
   } catch (error) {
+    disposeMicrosoftStorePwa?.();
     renderBootstrapError(error, locale);
     console.error('[bootstrap]', error);
   }

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

@@ -0,0 +1,5 @@
+declare module '#mpgd-platform-gateway' {
+  export function createBuildGateway(
+    runtime: import('./runtimeDetector').RuntimeConfig,
+  ): Promise<import('@mpgd/platform').PlatformGateway>;
+}

package/templates/phaser-game/src/platform/buildGateways/ait.ts

@@ -0,0 +1,11 @@
+import { createAitPlatformGateway } from '@mpgd/adapter-ait';
+import type { PlatformGateway } from '@mpgd/platform';
+
+import type { RuntimeConfig } from '../runtimeDetector';
+
+export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {
+  return createAitPlatformGateway({
+    appVersion: runtime.appVersion,
+    buildId: runtime.buildId,
+  });
+}

package/templates/phaser-game/src/platform/buildGateways/aitSandbox.ts

@@ -0,0 +1,12 @@
+import { createAitPlatformGateway, createAitSandboxBridge } from '@mpgd/adapter-ait';
+import type { PlatformGateway } from '@mpgd/platform';
+
+import type { RuntimeConfig } from '../runtimeDetector';
+
+export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {
+  return createAitPlatformGateway({
+    appVersion: runtime.appVersion,
+    buildId: runtime.buildId,
+    fallbackBridge: createAitSandboxBridge(),
+  });
+}

package/templates/phaser-game/src/platform/buildGateways/browser.ts

@@ -0,0 +1,8 @@
+import { createBrowserPlatformGateway } from '@mpgd/adapter-browser';
+import type { PlatformGateway } from '@mpgd/platform';
+
+import type { RuntimeConfig } from '../runtimeDetector';
+
+export async function createBuildGateway(_runtime: RuntimeConfig): Promise<PlatformGateway> {
+  return createBrowserPlatformGateway();
+}

package/templates/phaser-game/src/platform/buildGateways/capacitorAndroid.ts

@@ -0,0 +1,12 @@
+import { createCapacitorPlatformGateway } from '@mpgd/adapter-capacitor';
+import type { PlatformGateway } from '@mpgd/platform';
+
+import type { RuntimeConfig } from '../runtimeDetector';
+
+export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {
+  return createCapacitorPlatformGateway({
+    target: 'android',
+    appVersion: runtime.appVersion,
+    buildId: runtime.buildId,
+  });
+}

package/templates/phaser-game/src/platform/buildGateways/capacitorIos.ts

@@ -0,0 +1,12 @@
+import { createCapacitorPlatformGateway } from '@mpgd/adapter-capacitor';
+import type { PlatformGateway } from '@mpgd/platform';
+
+import type { RuntimeConfig } from '../runtimeDetector';
+
+export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {
+  return createCapacitorPlatformGateway({
+    target: 'ios',
+    appVersion: runtime.appVersion,
+    buildId: runtime.buildId,
+  });
+}

package/templates/phaser-game/src/platform/buildGateways/reddit.ts

@@ -0,0 +1,11 @@
+import { createDevvitPlatformGateway } from '@mpgd/adapter-devvit';
+import type { PlatformGateway } from '@mpgd/platform';
+
+import type { RuntimeConfig } from '../runtimeDetector';
+
+export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {
+  return createDevvitPlatformGateway({
+    appVersion: runtime.appVersion,
+    buildId: runtime.buildId,
+  });
+}

package/templates/phaser-game/src/platform/buildGateways/redditSandbox.ts

@@ -0,0 +1,15 @@
+import {
+  createDevvitPlatformGateway,
+  createDevvitSandboxBridge,
+} from '@mpgd/adapter-devvit';
+import type { PlatformGateway } from '@mpgd/platform';
+
+import type { RuntimeConfig } from '../runtimeDetector';
+
+export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {
+  return createDevvitPlatformGateway({
+    appVersion: runtime.appVersion,
+    buildId: runtime.buildId,
+    fallbackBridge: createDevvitSandboxBridge(),
+  });
+}

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),
+]);