@mpgd/cli 0.5.0 → 0.6.0

package/dist/index.js

@@ -949,6 +949,7 @@ function toTemplatePath(value) {
 }
 function createTargetCommandEnv(values) {
     const targetsFile = path.resolve(readOptionalString(values['targets-file']) ?? 'mpgd.targets.json');
+    const gameRoot = path.dirname(targetsFile);
     const kitPath = resolveKitPathForTarget(values);
     const resolvedTargetsFile = readOptionalString(values['resolved-targets-file']);
     const preparedTargetsFile = preparePlatformTargetsFile({
@@ -960,10 +961,75 @@ function createTargetCommandEnv(values) {
     });
     return {
         ...process.env,
+        ...createGameOwnedReleaseEnv(gameRoot, process.env),
         MPGD_KIT_PATH: kitPath,
         MPGD_PLATFORM_TARGETS_FILE: preparedTargetsFile,
     };
 }
+function createGameOwnedReleaseEnv(gameRoot, baseEnv) {
+    const monetizationFiles = resolveGameOwnedMonetizationFiles(gameRoot, baseEnv);
+    const sourceGitSha = readOptionalString(baseEnv.MPGD_SOURCE_GIT_SHA)
+        ?? readSourceGitSha(gameRoot);
+    const appVersion = readOptionalString(baseEnv.APP_VERSION)
+        ?? readGamePackageVersion(gameRoot);
+    return {
+        ...monetizationFiles,
+        MPGD_SOURCE_GIT_SHA: sourceGitSha,
+        ...(appVersion === undefined ? {} : { APP_VERSION: appVersion }),
+    };
+}
+function resolveGameOwnedMonetizationFiles(gameRoot, baseEnv) {
+    const configuredCatalog = readConfiguredPath(baseEnv.MPGD_PRODUCT_CATALOG_FILE);
+    const configuredPlacements = readConfiguredPath(baseEnv.MPGD_AD_PLACEMENTS_FILE);
+    if ((configuredCatalog === undefined) !== (configuredPlacements === undefined)) {
+        throw new Error('MPGD_PRODUCT_CATALOG_FILE and MPGD_AD_PLACEMENTS_FILE must be configured together.');
+    }
+    if (configuredCatalog !== undefined && configuredPlacements !== undefined) {
+        return {
+            MPGD_PRODUCT_CATALOG_FILE: path.resolve(gameRoot, configuredCatalog),
+            MPGD_AD_PLACEMENTS_FILE: path.resolve(gameRoot, configuredPlacements),
+        };
+    }
+    const catalogFile = path.join(gameRoot, 'mpgd.catalog.json');
+    const placementsFile = path.join(gameRoot, 'mpgd.ad-placements.json');
+    const hasCatalog = existsSync(catalogFile);
+    const hasPlacements = existsSync(placementsFile);
+    if (hasCatalog !== hasPlacements) {
+        throw new Error(`Game target builds must provide both mpgd.catalog.json and mpgd.ad-placements.json: ${gameRoot}`);
+    }
+    if (!hasCatalog) {
+        return {};
+    }
+    return {
+        MPGD_PRODUCT_CATALOG_FILE: catalogFile,
+        MPGD_AD_PLACEMENTS_FILE: placementsFile,
+    };
+}
+function readConfiguredPath(value) {
+    const normalized = value?.trim();
+    return normalized === undefined || normalized.length === 0 ? undefined : normalized;
+}
+function readSourceGitSha(gameRoot) {
+    const result = spawnSync('git', ['-C', gameRoot, 'rev-parse', '--short', 'HEAD'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    if (result.error !== undefined || result.status !== 0) {
+        return 'uncommitted';
+    }
+    return result.stdout.trim() || 'uncommitted';
+}
+function readGamePackageVersion(gameRoot) {
+    const packageFile = path.join(gameRoot, 'package.json');
+    if (!existsSync(packageFile)) {
+        return undefined;
+    }
+    const packageJson = readJsonForCli(packageFile);
+    if (typeof packageJson !== 'object' || packageJson === null || Array.isArray(packageJson)) {
+        return undefined;
+    }
+    return readOptionalString(packageJson.version);
+}
 function preparePlatformTargetsFile(input) {
     const parsed = readJsonForCli(input.targetsFile);
     const gameRoot = path.dirname(input.targetsFile);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/cli",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Gunshi CLI for mpgd-kit starter generation and target workflow orchestration.",
   "license": "MIT",
   "repository": {
@@ -49,18 +49,18 @@
     "@types/node": "^24.0.0",
     "ttsc": "0.16.9",
     "typescript": "7.0.1-rc",
-    "@mpgd/adapter-ait": "0.3.3",
-    "@mpgd/adapter-browser": "0.3.2",
-    "@mpgd/adapter-capacitor": "0.3.3",
-    "@mpgd/adapter-devvit": "0.3.3",
-    "@mpgd/analytics": "0.3.2",
-    "@mpgd/bridge": "0.4.0",
-    "@mpgd/catalog": "0.3.2",
-    "@mpgd/game-services": "0.3.3",
+    "@mpgd/adapter-browser": "0.4.0",
+    "@mpgd/adapter-devvit": "0.4.0",
+    "@mpgd/adapter-capacitor": "0.4.0",
+    "@mpgd/analytics": "0.3.3",
+    "@mpgd/adapter-ait": "0.4.0",
+    "@mpgd/bridge": "0.5.0",
+    "@mpgd/catalog": "0.3.3",
+    "@mpgd/i18n": "0.4.1",
+    "@mpgd/game-services": "0.4.0",
     "@mpgd/phaser-assets": "0.4.0",
-    "@mpgd/i18n": "0.4.0",
-    "@mpgd/target-config": "0.4.0",
-    "@mpgd/platform": "0.3.2"
+    "@mpgd/platform": "0.4.0",
+    "@mpgd/target-config": "0.5.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/templates/phaser-game/agent/acceptance.md

@@ -12,6 +12,8 @@ pnpm --dir ../mpgd-kit mpgd target doctor --targets-file "$PWD/mpgd.targets.json
 
 For Apps in Toss changes, use the apps-in-toss MCP before implementation and
 keep SDK calls inside adapters or target wrappers.
+Resolve identity and launch intents during bootstrap, treat inbound share data as
+untrusted, and keep notification delivery on the server.
 
 For Reddit Devvit changes, keep Devvit SDK calls inside the target wrapper and
 continue to expose game-facing behavior through `PlatformGateway`. The Devvit

package/templates/phaser-game/agent/game-manifest.json

@@ -25,6 +25,10 @@
       "id": "runtime.platform.gateway",
       "owner": "src/platform/installPlatform.ts"
     },
+    {
+      "id": "platform.gateway.bootstrap-intents",
+      "owner": "src/main.ts"
+    },
     {
       "id": "runtime.viewport.orientation-policy",
       "owner": "src/main.ts"

package/templates/phaser-game/apps/target-devvit/src/server/index.ts

@@ -168,7 +168,7 @@ async function handleBridgeRequest(input: BridgeRequest): Promise<BridgeResponse
         nativeLeaderboard: true,
         achievements: false,
         cloudSave: true,
-        socialShare: true,
+        socialShare: false,
         haptics: false,
         localizedContent: true,
       });
@@ -186,6 +186,51 @@ async function handleBridgeRequest(input: BridgeRequest): Promise<BridgeResponse
       });
     }
 
+    case 'identity.getSession': {
+      const playerId = currentPlayerId();
+
+      return ok(
+        input,
+        playerId === undefined
+          ? {
+              identityLevel: 'guest',
+              trustLevel: 'local',
+            }
+          : {
+              identityLevel: 'authenticated',
+              playerId,
+              trustLevel: 'server-verified',
+            },
+      );
+    }
+
+    case 'identity.requestUpgrade': {
+      const authenticated = currentPlayerId() !== undefined;
+
+      return ok(input, {
+        status: authenticated ? 'completed' : 'unavailable',
+        reloadExpected: false,
+      });
+    }
+
+    case 'presentation.getLaunchIntent':
+      return ok(input, { entry: 'home' });
+
+    case 'presentation.requestGameSurface':
+      return ok(input, 'unavailable');
+
+    case 'share.share':
+      return ok(input, { status: 'unavailable' });
+
+    case 'share.readInboundShare':
+      return ok(input, null);
+
+    case 'notifications.getStatus':
+      return ok(input, 'approval-required');
+
+    case 'notifications.requestSubscription':
+      return ok(input, 'unavailable');
+
     case 'commerce.getProducts':
     case 'commerce.getEntitlements':
       return ok(input, []);

package/templates/phaser-game/apps/target-devvit/vite.server.config.ts

@@ -22,6 +22,7 @@ export default defineConfig({
     ssr: 'src/server/index.ts',
     outDir: 'dist/server',
     target: 'node22',
+    minify: 'esbuild',
     sourcemap: false,
     emptyOutDir: true,
     rollupOptions: {
@@ -29,7 +30,7 @@ export default defineConfig({
       output: {
         format: 'cjs',
         entryFileNames: 'index.cjs',
-        inlineDynamicImports: true,
+        codeSplitting: false,
       },
     },
   },

package/templates/phaser-game/src/env.d.ts

@@ -4,6 +4,7 @@ declare const __APP_TARGET__: string;
 declare const __MPGD_CONFIG_TARGET__: string;
 declare const __APP_VERSION__: string;
 declare const __BUILD_ID__: string;
+declare const __SOURCE_GIT_SHA__: string;
 declare const __DEBUG_BUILD__: boolean;
 
 interface ImportMetaEnv {

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

@@ -2,6 +2,7 @@ import './styles.css';
 
 import { createAnalyticsReporter, createBufferedAnalyticsSink } from '@mpgd/analytics';
 import { resolveMpgdLocale, type Locale } from '@mpgd/i18n';
+import type { IdentitySession, LaunchIntent, PlatformGateway } from '@mpgd/platform';
 import {
   resolveTargetViewportPlan,
   type TargetViewportOrientationPolicy,
@@ -41,6 +42,10 @@ async function bootstrap(): Promise<void> {
         playerId: 'local-player',
         displayName: 'Local Player',
       };
+    const [identitySession, launchIntent] = await Promise.all([
+      resolveIdentitySession(platform, player.playerId),
+      resolveLaunchIntent(platform),
+    ]);
     locale = resolveMpgdLocale(runtime.capabilities);
     const analyticsSink = createBufferedAnalyticsSink();
     const analytics = createAnalyticsReporter({
@@ -50,7 +55,7 @@ async function bootstrap(): Promise<void> {
     });
     const gameServices = createStarterGameServices({
       gateway: platform,
-      playerId: player.playerId,
+      playerId: identitySession.playerId ?? player.playerId,
     });
 
     await analytics.track({
@@ -68,6 +73,8 @@ async function bootstrap(): Promise<void> {
         runtime,
         viewport,
         player,
+        identitySession,
+        launchIntent,
         locale,
         gameServices,
         analytics,
@@ -80,6 +87,35 @@ async function bootstrap(): Promise<void> {
   }
 }
 
+async function resolveIdentitySession(
+  platform: PlatformGateway,
+  fallbackPlayerId: string,
+): Promise<IdentitySession> {
+  try {
+    return (await platform.identity.getSession?.()) ?? createGuestSession(fallbackPlayerId);
+  } catch (error) {
+    console.warn('[platform] identity session unavailable; using guest fallback.', error);
+    return createGuestSession(fallbackPlayerId);
+  }
+}
+
+async function resolveLaunchIntent(platform: PlatformGateway): Promise<LaunchIntent> {
+  try {
+    return (await platform.presentation?.getLaunchIntent()) ?? { entry: 'home' };
+  } catch (error) {
+    console.warn('[platform] launch intent unavailable; using home fallback.', error);
+    return { entry: 'home' };
+  }
+}
+
+function createGuestSession(playerId: string): IdentitySession {
+  return {
+    identityLevel: 'guest',
+    playerId,
+    trustLevel: 'local',
+  };
+}
+
 function renderBootstrapError(error: unknown, locale: Locale): void {
   const message = error instanceof Error ? error.message : String(error);
   const root = document.querySelector<HTMLDivElement>('#game');

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/vite.config.ts

@@ -1,3 +1,6 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+
 import ttsc from '@ttsc/unplugin/vite';
 import { defineConfig } from 'vite';
 
@@ -12,11 +15,15 @@ export default defineConfig(({ mode }) => {
         plugins: false,
       }),
     ],
+    resolve: {
+      alias: createCatalogAliases(),
+    },
     define: {
       __APP_TARGET__: JSON.stringify(process.env.APP_TARGET ?? 'browser'),
       __MPGD_CONFIG_TARGET__: JSON.stringify(process.env.MPGD_CONFIG_TARGET ?? ''),
       __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: {
@@ -35,3 +42,53 @@ export default defineConfig(({ mode }) => {
     },
   };
 });
+
+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 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;
+}