@mpgd/cli 0.47.0 → 0.48.0

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

@@ -1,7 +1,10 @@
 import {
+  bridgeEventProtocol,
   bridgeStorageLoadProtocol,
   createBridgeError,
   createCommerceV2UnavailableBridgeError,
+  createNotificationsV2UnavailableBridgeError,
+  isBridgeNotificationsV2Method,
   type BridgeRequest,
   type BridgeResponse,
   type BridgeStorageLoadData,
@@ -90,10 +93,15 @@ export function createDevvitBridgeHandler(
   }
 
   return async function handleBridgeRequest(input: BridgeRequest): Promise<BridgeResponse> {
+    // Notifications v2 arrives with the Devvit provider (P3), which serves the
+    // game-rendered opt-in from this bridge; until then every v2 method
+    // answers the dedicated code, and the v1 `notifications.*` answers stay.
+    if (isBridgeNotificationsV2Method(input.method)) {
+      return createNotificationsV2UnavailableBridgeError(input, 'Devvit server bridge');
+    }
     switch (input.method) {
       case 'runtime.getCapabilities':
         return ok(input, {
-          nativeIap: false,
           nativeAds: false,
           rewardedAds: false,
           interstitialAds: false,
@@ -104,6 +112,7 @@ export function createDevvitBridgeHandler(
           socialShare: false,
           haptics: false,
           localizedContent: true,
+          commerce: await readCommerceCapabilities(input, dependencies.commerce),
         });
 
       case 'identity.getPlayer': {
@@ -164,21 +173,6 @@ export function createDevvitBridgeHandler(
       case 'notifications.requestSubscription':
         return ok(input, 'unavailable');
 
-      case 'commerce.getProducts':
-      case 'commerce.getEntitlements':
-        return ok(input, []);
-
-      case 'commerce.purchase':
-        return ok(input, {
-          status: 'cancelled',
-          entitlementIds: [],
-        });
-
-      case 'commerce.restore':
-        return ok(input, {
-          restoredEntitlements: [],
-        });
-
       case 'ads.preload':
         return ok(input, {});
 
@@ -211,8 +205,9 @@ export function createDevvitBridgeHandler(
       case 'storage.save':
         return saveStorage(input, dependencies, storageKeyNamespace, warn);
 
-      // Commerce v2 (B6): served by the configured handler over the payments
-      // plugin; the checkout itself opens in the webview.
+      // Commerce v2: served by the configured handler over the payments
+      // plugin; the checkout itself opens in the webview. The removed v1
+      // `commerce.*` methods fall to UNSUPPORTED_METHOD below.
       case 'commerce.v2.getCapabilities':
       case 'commerce.v2.fetchProducts':
       case 'commerce.v2.requestPurchase':
@@ -233,6 +228,130 @@ export function createDevvitBridgeHandler(
   };
 }
 
+/**
+ * The all-false commerce capability block of a server that sells nothing
+ * (`createUnsupportedCommerceCapabilities()` of `@mpgd/platform`, kept equal by
+ * the bridge test). A fresh object on every read.
+ */
+function createUnsupportedCommerceBlock() {
+  return {
+    purchase: { consumable: false, durable: false, subscription: false, quantity: false },
+    catalog: { products: false, offers: false, localizedPrice: false },
+    lifecycle: {
+      availablePurchases: false,
+      pending: false,
+      restore: false,
+      events: false,
+      finish: 'none',
+    },
+    authority: { evidence: 'client-token', accountBinding: 'optional' },
+    availability: 'unsupported',
+  };
+}
+
+const commerceBlockShape = {
+  purchase: {
+    consumable: 'boolean',
+    durable: 'boolean',
+    subscription: 'boolean',
+    quantity: 'boolean',
+  },
+  catalog: { products: 'boolean', offers: 'boolean', localizedPrice: 'boolean' },
+  lifecycle: {
+    availablePurchases: 'boolean',
+    pending: 'boolean',
+    restore: 'boolean',
+    events: 'boolean',
+    finish: ['client', 'server', 'host', 'none'],
+  },
+  authority: {
+    evidence: ['client-token', 'host-callback', 'adapter-settled', 'server-push'],
+    accountBinding: ['required', 'optional', 'host'],
+  },
+} as const;
+const commerceAvailabilities: readonly unknown[] = [
+  'available',
+  'unsupported',
+  'configuration-required',
+  'action-required',
+  'temporarily-unavailable',
+];
+
+function isPlainRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function hasExactKeys(value: Readonly<Record<string, unknown>>, keys: readonly string[]): boolean {
+  const own = Object.keys(value);
+  return own.length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+
+/**
+ * A fresh copy of a well-formed commerce capability block (the exact keys and
+ * values `PlatformCapabilities.commerce` allows), or undefined for anything
+ * else, so a malformed handler answer never reaches the snapshot.
+ */
+function copyCommerceBlock(value: unknown): Record<string, unknown> | undefined {
+  if (!isPlainRecord(value)
+    || !hasExactKeys(value, [...Object.keys(commerceBlockShape), 'availability'])
+    || !commerceAvailabilities.includes(value.availability)) {
+    return undefined;
+  }
+  const copy: Record<string, unknown> = { availability: value.availability };
+  for (const [section, fields] of Object.entries(commerceBlockShape)) {
+    const source = value[section];
+    if (!isPlainRecord(source) || !hasExactKeys(source, Object.keys(fields))) {
+      return undefined;
+    }
+    const sectionCopy: Record<string, unknown> = {};
+    for (const [field, rule] of Object.entries(fields)) {
+      const fieldValue = source[field];
+      const valid = rule === 'boolean'
+        ? typeof fieldValue === 'boolean'
+        : (rule as readonly unknown[]).includes(fieldValue);
+      if (!valid) {
+        return undefined;
+      }
+      sectionCopy[field] = fieldValue;
+    }
+    copy[section] = sectionCopy;
+  }
+  return copy;
+}
+
+/**
+ * The `commerce` block of the server snapshot: what the configured commerce
+ * handler reports for this server, otherwise the unsupported block. It fails
+ * closed: a missing handler, a handler that throws or answers an error, or an
+ * answer without a well-formed capability block sells nothing. The webview
+ * gateway owns the block it finally reports (its provider's, or the
+ * unsupported one).
+ */
+async function readCommerceCapabilities(
+  input: BridgeRequest,
+  handler: DevvitBridgeCommerceHandler | undefined,
+): Promise<unknown> {
+  if (handler === undefined) {
+    return createUnsupportedCommerceBlock();
+  }
+
+  try {
+    const response = await handler.request({
+      ...input,
+      method: 'commerce.v2.getCapabilities',
+      payload: { protocol: bridgeEventProtocol },
+    });
+    const data: unknown = response.ok ? response.data : undefined;
+    const capabilities = typeof data === 'object' && data !== null
+      ? (data as { readonly capabilities?: unknown }).capabilities
+      : undefined;
+
+    return copyCommerceBlock(capabilities) ?? createUnsupportedCommerceBlock();
+  } catch {
+    return createUnsupportedCommerceBlock();
+  }
+}
+
 async function loadStorage(
   input: BridgeRequest,
   dependencies: DevvitBridgeHandlerDependencies,

package/templates/phaser-game/package.json

@@ -56,7 +56,7 @@
   },
   "dependencies": {
     "@ait-co/polyfill": "^0.1.19",
-    "@apps-in-toss/web-framework": "3.5.0",
+    "@apps-in-toss/web-framework": "3.6.0",
     "@capacitor/app": "8.1.1",
     "@capacitor/core": "8.5.2",
     "@mpgd/adapter-ait": "__MPGD_DEPENDENCY_VERSION_ADAPTER_AIT__",

package/templates/phaser-game/pnpm-workspace.yaml

@@ -1,3 +1,5 @@
+# Run the generated POSIX target scripts consistently on Windows and Unix.
+shellEmulator: true
 packages:
   - '.'
   - 'apps/*'

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

@@ -2,6 +2,8 @@
 
 declare const __APP_TARGET__: string;
 declare const __MPGD_CONFIG_TARGET__: string;
+/** The Apps in Toss app name `intoss://` share links carry; see `vite.shared.ts`. */
+declare const __MPGD_AIT_APP_NAME__: string;
 declare const __MPGD_PLATFORM_TARGET__:
   | import('@mpgd/target-config').EffectivePlatformTargetMetadata
   | undefined;

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

@@ -8,7 +8,7 @@ import type { RuntimeConfig } from '../runtimeDetector';
  * host side: the wrapper (`apps/target-ait`) installs the IAP products from
  * the catalog's `platformProductIds.ait` entries and serves the six
  * `commerce.v2.*` methods plus the `commerceV2` event channel, so the gateway
- * exposes `commerceV2` whenever the installed bridge has that channel. The
+ * exposes `commerce` whenever the installed bridge has that channel. The
  * host's grant callback only confirms through the game backend; nothing is
  * granted from this side.
  */

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

@@ -5,15 +5,20 @@ import type { RuntimeConfig } from '../runtimeDetector';
 
 /**
  * Local Apps in Toss playtest. The sandbox bridge keeps its build-id gate: only
- * the `ait-sandbox` build (`pnpm dev:ait`) gets the `commerceV2` channel and
+ * the `ait-sandbox` build (`pnpm dev:ait`) gets the commerce event channel and
  * the evidence-only v2 stub; any other build id gets no channel, so the
- * gateway offers no `commerceV2` and the v2 methods answer
- * `COMMERCE_V2_UNAVAILABLE`.
+ * gateway offers no `commerce` provider and the v2 methods answer
+ * `COMMERCE_V2_UNAVAILABLE`. Every build answers the `notifications.v2.*`
+ * methods with `NOTIFICATIONS_V2_UNAVAILABLE` until the Apps in Toss
+ * notifications provider lands.
  */
 export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {
   return createAitPlatformGateway({
     appVersion: runtime.appVersion,
     buildId: runtime.buildId,
-    fallbackBridge: createAitSandboxBridge({ buildId: runtime.buildId }),
+    fallbackBridge: createAitSandboxBridge({
+      appName: __MPGD_AIT_APP_NAME__,
+      buildId: runtime.buildId,
+    }),
   });
 }

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

@@ -41,8 +41,8 @@ function resolveMicrosoftStoreProducts(target: string): readonly MicrosoftStoreC
 }
 
 /**
- * Commerce v2 over the Digital Goods path (`createMicrosoftStoreCommerceProvider`)
- * installed as `commerceV2` with the v1 wrapper. The purchase authority stays
+ * Commerce over the Digital Goods path (`createMicrosoftStoreCommerceProvider`)
+ * installed as `gateway.commerce` with its capability block. The purchase authority stays
  * `configuration-required` until the game points it at its backend: the
  * authority's ledger entry is the only settlement, and the reconciler still
  * verifies it through game-services before anything is granted.
@@ -64,9 +64,6 @@ export async function createBuildGateway(runtime: RuntimeConfig): Promise<Platfo
       async verifyAndGrant() {
         return { status: 'failed' };
       },
-      async getEntitlements() {
-        return [];
-      },
     },
   });
   return withMicrosoftStoreCommerceProvider(base, commerce);

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

@@ -20,7 +20,7 @@ const productCatalog = productCatalogJson as ProductCatalog;
  * which serves it only after the Devvit server opted in
  * (`permissions.payments` plus the same catalog SKUs), and the grant comes
  * from the fulfillment handler's ledger entry. Without SKUs the gateway
- * offers no `commerceV2` at all.
+ * offers no `commerce` provider at all.
  */
 export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {
   const commerce = createCommerceOptions();

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

@@ -18,7 +18,7 @@ import { resolveStarterVerse8Agent8Client } from '../verse8Agent8Client';
 const productCatalog = productCatalogJson as ProductCatalog;
 
 /**
- * Verse8 gateway. VXShop and the commerce v2 provider are installed only when
+ * Verse8 gateway. VXShop and the commerce provider are installed only when
  * the game provides its authenticated Agent8 client (`verse8Agent8Client.ts`)
  * and the catalog names VXShop product ids (`platformProductIds.verse8`):
  * `vxShop.purchases` reads the purchases the Agent8 server recorded, which is
@@ -58,7 +58,6 @@ function createVxShopOptions(runtime: RuntimeConfig): Verse8CommerceOptions | un
   return {
     purchaseEventAuthority: 'agent8-server',
     products,
-    loadEntitlements: async () => (await agent8.getCommerceSnapshot()).entitlements,
     purchases: {
       listPurchases: () => agent8.listPurchases(),
     },

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

@@ -1,23 +1,22 @@
 import type { Verse8RecordedPurchase } from '@mpgd/adapter-verse8';
-import type { Entitlement } from '@mpgd/platform';
 
 /**
  * The game-owned Agent8 remote client the Verse8 gateway reads commerce state
- * through: two authenticated server methods exposed for the sender's own
+ * through: one authenticated server method exposed for the sender's own
  * account (see docs/VERSE8_COMMERCE.md, "Iframe client boundary"). The
  * starter installs no Agent8 browser SDK, so `resolveStarterVerse8Agent8Client`
  * answers `undefined` until the game provides one; VXShop then stays off and
- * the gateway offers no `commerceV2`, exactly as before. The client only
+ * the gateway offers no `commerce` provider and sells nothing. The client only
  * reads: `$onItemPurchased` on the Agent8 server is the sole grant path.
+ * Entitlements are not read from the client: they come from the backend
+ * ledger through game-services.
  */
 export interface StarterVerse8Agent8Client {
-  /** Server-owned balances and entitlements (`getSnapshot` of the Agent8 commerce service). */
-  getCommerceSnapshot(): Promise<{ readonly entitlements: readonly Entitlement[] }>;
   /** The purchases `$onItemPurchased` recorded (`listPurchases` of the Agent8 commerce service). */
   listPurchases(): Promise<readonly Verse8RecordedPurchase[]>;
 }
 
-/** Return the game's authenticated Agent8 client here to enable VXShop and commerce v2 on Verse8. */
+/** Return the game's authenticated Agent8 client here to enable VXShop and commerce on Verse8. */
 export function resolveStarterVerse8Agent8Client(): StarterVerse8Agent8Client | undefined {
   return undefined;
 }

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

@@ -17,6 +17,8 @@ interface RuntimePlatformTargetMetadata {
   readonly crazyGamesLaunch?: 'basic' | 'full';
   readonly authoritativeGameServices?: boolean;
   readonly integrations?: Record<string, unknown>;
+  /** An Apps in Toss target's `metadata.appName`, for the sandbox bridge only. */
+  readonly aitAppName?: string;
 }
 
 // Sandbox gateways self-complete purchases and rewards without any backend
@@ -100,7 +102,10 @@ export function createGameViteSharedConfig<SharedPluginOption = PluginOption>(
       __APP_TARGET__: JSON.stringify(appTarget),
       __MPGD_CONFIG_TARGET__: JSON.stringify(configTarget),
       __MPGD_PLATFORM_TARGET__:
-        platformTarget === undefined ? 'undefined' : JSON.stringify(platformTarget),
+        platformTarget === undefined
+          ? 'undefined'
+          : JSON.stringify(toEffectivePlatformTargetMetadata(platformTarget)),
+      __MPGD_AIT_APP_NAME__: JSON.stringify(resolveAitAppName(platformTarget)),
       __MPGD_TARGET_CONFIG_MATRIX__:
         runtimeTargetConfigMatrix === undefined
           ? 'undefined'
@@ -264,6 +269,8 @@ function readRuntimePlatformTarget(
     throw new Error(`Platform target ${configTarget} authoritativeGameServices must be a boolean.`);
   }
 
+  const aitAppName = readAitAppName(target);
+
   return {
     kind: target.kind,
     adapter: target.adapter,
@@ -272,9 +279,41 @@ function readRuntimePlatformTarget(
       : { authoritativeGameServices: target.authoritativeGameServices }),
     ...(target.crazyGamesLaunch === undefined ? {} : { crazyGamesLaunch: target.crazyGamesLaunch as 'basic' | 'full' }),
     ...(target.integrations === undefined ? {} : { integrations: target.integrations }),
+    ...(aitAppName === undefined ? {} : { aitAppName }),
+  };
+}
+
+function toEffectivePlatformTargetMetadata(
+  input: RuntimePlatformTargetMetadata,
+): Omit<RuntimePlatformTargetMetadata, 'aitAppName'> {
+  return {
+    kind: input.kind,
+    adapter: input.adapter,
+    ...(input.authoritativeGameServices === undefined
+      ? {}
+      : { authoritativeGameServices: input.authoritativeGameServices }),
+    ...(input.crazyGamesLaunch === undefined ? {} : { crazyGamesLaunch: input.crazyGamesLaunch }),
+    ...(input.integrations === undefined ? {} : { integrations: input.integrations }),
   };
 }
 
+/**
+ * The app name `intoss://` share links must carry in the Apps in Toss sandbox
+ * bridge, the one the wrapper's host bridge uses: `MPGD_AIT_APP_NAME`, else
+ * the target's `metadata.appName`, else the game name.
+ */
+function resolveAitAppName(platformTarget: RuntimePlatformTargetMetadata | undefined): string {
+  return process.env.MPGD_AIT_APP_NAME?.trim() || platformTarget?.aitAppName || '__GAME_NAME__';
+}
+
+function readAitAppName(target: Record<string, unknown>): string | undefined {
+  const appName = target.kind === 'apps-in-toss' && isRecord(target.metadata)
+    ? target.metadata.appName
+    : undefined;
+
+  return typeof appName === 'string' && appName.trim().length > 0 ? appName.trim() : undefined;
+}
+
 function isRecord(input: unknown): input is Record<string, unknown> {
   return typeof input === 'object' && input !== null && !Array.isArray(input);
 }