@mpgd/cli 0.5.0 → 0.7.0

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/src/runtime/gameContext.ts

@@ -1,6 +1,6 @@
 import type { AnalyticsReporter, BufferedAnalyticsSink } from '@mpgd/analytics';
 import type { Locale } from '@mpgd/i18n';
-import type { PlayerIdentity } from '@mpgd/platform';
+import type { IdentitySession, LaunchIntent, PlayerIdentity } from '@mpgd/platform';
 import type {
   TargetConfiguredGateway,
   TargetRuntimeSnapshot,
@@ -16,6 +16,8 @@ export interface StarterContext {
   readonly runtime: TargetRuntimeSnapshot;
   readonly viewport: TargetViewportPlan;
   readonly player: PlayerIdentity;
+  readonly identitySession: IdentitySession;
+  readonly launchIntent: LaunchIntent;
   readonly locale: Locale;
   readonly gameServices: StarterGameServices;
   readonly analytics: AnalyticsReporter;

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,8 +1,25 @@
+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: './',
@@ -12,11 +29,20 @@ export default defineConfig(({ mode }) => {
         plugins: false,
       }),
     ],
+    resolve: {
+      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'),
       __DEBUG_BUILD__: JSON.stringify(!isProduction),
     },
     build: {
@@ -26,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]',
         },
@@ -35,3 +69,128 @@ 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);
+
+  if ((productCatalogFile === undefined) !== (adPlacementsFile === undefined)) {
+    throw new Error(
+      'MPGD_PRODUCT_CATALOG_FILE and MPGD_AD_PLACEMENTS_FILE must be configured together.',
+    );
+  }
+
+  if (productCatalogFile === undefined || adPlacementsFile === undefined) {
+    return {};
+  }
+
+  return {
+    '@mpgd/catalog/catalog.json': resolveCatalogPath(productCatalogFile, adPlacementsFile),
+    '@mpgd/catalog/placements.json': resolveCatalogPath(adPlacementsFile, productCatalogFile),
+  };
+}
+
+function readConfiguredPath(value: string | undefined): string | undefined {
+  const normalized = value?.trim();
+  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);
+}
+
+function resolveCatalogBaseDir(path: string, pairedPath: string): string {
+  const fallbackBaseDir = process.cwd();
+  const candidates = [
+    fallbackBaseDir,
+    readConfiguredPath(process.env.INIT_CWD),
+    readConfiguredPath(process.env.PWD),
+  ];
+
+  for (const candidate of candidates) {
+    if (
+      candidate !== undefined
+      && existsSync(resolve(candidate, path))
+      && existsSync(resolve(candidate, pairedPath))
+    ) {
+      return candidate;
+    }
+  }
+
+  return fallbackBaseDir;
+}