@mpgd/cli 0.4.1 → 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.4.1",
+  "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/analytics": "0.3.2",
-    "@mpgd/adapter-devvit": "0.3.3",
-    "@mpgd/bridge": "0.4.0",
-    "@mpgd/catalog": "0.3.2",
+    "@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/platform": "0.3.2",
-    "@mpgd/target-config": "0.3.4",
-    "@mpgd/i18n": "0.3.3",
-    "@mpgd/game-services": "0.3.3"
+    "@mpgd/platform": "0.4.0",
+    "@mpgd/target-config": "0.5.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/templates/phaser-game/README.md

@@ -84,6 +84,9 @@ const viewport = resolveTargetViewportPlan({
   height: measured.height,
   source: measured.source,
   runtime: runtime.config.runtime,
+  orientationPolicy: {
+    mode: 'prefer-landscape',
+  },
 });
 ```
 
@@ -104,6 +107,15 @@ Orientation is measured from the container: height greater than width is
 be treated as an embedded webview, so do not assume desktop Reddit always means
 an expanded game surface.
 
+Orientation policy is a runtime contract, not a guarantee that every shell can
+hard-lock the device. Use `responsive` when both orientations are playable,
+`prefer-landscape` or `prefer-portrait` when layout guidance should favor one
+orientation, and `lock-landscape` or `lock-portrait` when the game should show a
+soft rotate prompt on mismatch. The generated PWA manifest also declares
+`"orientation": "landscape"` for installed web and Microsoft Store shells; keep
+that manifest value aligned with the runtime policy if you make a portrait-first
+game.
+
 ## Reddit Devvit
 
 This starter owns its Devvit app root in `apps/target-devvit`. That directory

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
@@ -21,3 +23,6 @@ after login before upload or playtest.
 For Microsoft Store changes, keep the first pass as a PWA/web target that uses
 the browser adapter. Add a dedicated Store commerce adapter only when wiring
 Digital Goods API and Payment Request through backend ledger verification.
+
+Verify the first screen reports the viewport orientation policy, and treat
+locked orientation modes as soft prompts instead of unsafe WebView hard locks.

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

@@ -9,6 +9,8 @@ Boundaries:
 - Purchases, rewarded ad grants, and leaderboard records should go through
   backend ledger APIs before mutating durable game save state.
 - Platform SDK imports belong in adapters or target wrappers.
+- Orientation policy should be chosen before adding resize behavior; treat
+  locked modes as soft prompts unless a platform adapter supports hard locks.
 
 Useful commands:
 

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

@@ -25,6 +25,14 @@
       "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"
+    },
     {
       "id": "platform.devvit.app-root",
       "owner": "apps/target-devvit"

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/i18n/messages.ts

@@ -4,6 +4,8 @@ export type GameMessageKey =
   | 'title'
   | 'target'
   | 'viewport'
+  | 'orientationPolicy'
+  | 'orientationMismatch'
   | 'backend'
   | 'features'
   | 'featuresNone'
@@ -21,6 +23,8 @@ const messages = {
     title: '__GAME_TITLE__',
     target: 'Target: {target}',
     viewport: 'Viewport: {sizeClass} {orientation} - controls {controls}',
+    orientationPolicy: 'Orientation policy: {mode}',
+    orientationMismatch: 'Rotate to {orientation} for {mode}',
     backend: 'Game Services: {mode}',
     features: 'Features: {features}',
     featuresNone: 'none',
@@ -37,6 +41,8 @@ const messages = {
     title: '__GAME_TITLE__',
     target: '타깃: {target}',
     viewport: '뷰포트: {sizeClass} {orientation} - 컨트롤 {controls}',
+    orientationPolicy: '방향 정책: {mode}',
+    orientationMismatch: '{mode}: {orientation} 방향으로 회전',
     backend: 'Game Services: {mode}',
     features: '기능: {features}',
     featuresNone: '없음',

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

@@ -2,7 +2,11 @@ import './styles.css';
 
 import { createAnalyticsReporter, createBufferedAnalyticsSink } from '@mpgd/analytics';
 import { resolveMpgdLocale, type Locale } from '@mpgd/i18n';
-import { resolveTargetViewportPlan } from '@mpgd/target-config';
+import type { IdentitySession, LaunchIntent, PlatformGateway } from '@mpgd/platform';
+import {
+  resolveTargetViewportPlan,
+  type TargetViewportOrientationPolicy,
+} from '@mpgd/target-config';
 
 import { t } from './i18n/messages';
 import { createClientId } from './runtime/id';
@@ -25,15 +29,23 @@ async function bootstrap(): Promise<void> {
     const runtimeConfig = detectRuntime();
     const platform = await installPlatform(runtimeConfig);
     const runtime = await platform.getTargetRuntime();
+    const orientationPolicy = {
+      mode: 'prefer-landscape',
+    } as const satisfies TargetViewportOrientationPolicy;
     const viewport = resolveTargetViewportPlan({
       ...measureGameViewport(),
       runtime: runtime.config.runtime,
+      orientationPolicy,
     });
     const player =
       (await platform.identity.getPlayer()) ?? {
         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({
@@ -43,7 +55,7 @@ async function bootstrap(): Promise<void> {
     });
     const gameServices = createStarterGameServices({
       gateway: platform,
-      playerId: player.playerId,
+      playerId: identitySession.playerId ?? player.playerId,
     });
 
     await analytics.track({
@@ -61,6 +73,8 @@ async function bootstrap(): Promise<void> {
         runtime,
         viewport,
         player,
+        identitySession,
+        launchIntent,
         locale,
         gameServices,
         analytics,
@@ -73,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/src/scenes/LobbyScene.ts

@@ -21,6 +21,16 @@ export class LobbyScene extends Phaser.Scene {
       .filter((feature) => feature.enabled)
       .map((feature) => feature.feature)
       .join(', ') || t(locale, 'featuresNone');
+    const orientation = context.viewport.orientation;
+    const orientationText =
+      orientation.shouldShowRotatePrompt && orientation.preferredOrientation !== undefined
+        ? t(locale, 'orientationMismatch', {
+            mode: orientation.mode,
+            orientation: orientation.preferredOrientation,
+          })
+        : t(locale, 'orientationPolicy', {
+            mode: orientation.mode,
+          });
 
     this.add
       .text(480, 106, t(locale, 'title'), {
@@ -61,14 +71,21 @@ export class LobbyScene extends Phaser.Scene {
       )
       .setOrigin(0.5);
     this.add
-      .text(480, 300, t(locale, 'backend', { mode: context.gameServices.mode }), {
+      .text(480, 300, orientationText, {
+        color: orientation.shouldShowRotatePrompt ? '#f59e0b' : '#d6dee8',
+        fontFamily: 'Arial, sans-serif',
+        fontSize: '18px',
+      })
+      .setOrigin(0.5);
+    this.add
+      .text(480, 342, t(locale, 'backend', { mode: context.gameServices.mode }), {
         color: context.gameServices.mode === 'disabled' ? '#f59e0b' : '#2dd4bf',
         fontFamily: 'Arial, sans-serif',
         fontSize: '18px',
       })
       .setOrigin(0.5);
     this.add
-      .text(480, 342, t(locale, 'tapToStart'), {
+      .text(480, 384, t(locale, 'tapToStart'), {
         color: '#ffffff',
         fontFamily: 'Arial, sans-serif',
         fontSize: '22px',

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;
+}