@mpgd/cli 0.36.0 → 0.36.1

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

@@ -2,22 +2,20 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 
 import { context, createServer, getServerPort, reddit, redis } from '@devvit/web/server';
 import type { UiResponse } from '@devvit/web/shared';
-import {
-  bridgeStorageLoadProtocol,
-  createBridgeError,
-  type BridgeRequest,
-  type BridgeResponse,
-  type BridgeStorageLoadData,
-} from '@mpgd/bridge';
 import { createBridgeRpcRouter, defaultBridgeRpcEndpoint } from '@mpgd/bridge/orpc';
 import { createBridgeRpcNodeHandler } from '@mpgd/bridge/orpc/node';
 
-const maxStorageKeyLength = 128;
-const maxEncodedStorageKeyLength = 384;
-const maxStorageValueBytes = 262_144;
+import { createDevvitBridgeHandler } from './bridge.js';
+
 const maxRequestBodySize = 1_048_576;
 const gameName = '__GAME_NAME__';
 const gameTitle = __GAME_TITLE_TS_LITERAL__;
+const handleBridgeRequest = createDevvitBridgeHandler({
+  redis,
+  currentPlayerId,
+  currentDisplayName,
+  storageKeyNamespace: gameName,
+});
 const bridgeRpcHandler = createBridgeRpcNodeHandler(createBridgeRpcRouter(handleBridgeRequest), {
   maxBodySize: maxRequestBodySize,
   prefix: defaultBridgeRpcEndpoint,
@@ -126,279 +124,6 @@ server.listen(port, () => {
   console.log(`devvit server listening on ${port}`);
 });
 
-async function handleBridgeRequest(input: BridgeRequest): Promise<BridgeResponse> {
-  switch (input.method) {
-    case 'runtime.getCapabilities':
-      return ok(input, {
-        nativeIap: false,
-        nativeAds: false,
-        rewardedAds: false,
-        interstitialAds: false,
-        nativeLeaderboard: false,
-        remoteLeaderboard: false,
-        achievements: false,
-        cloudSave: true,
-        socialShare: false,
-        haptics: false,
-        localizedContent: true,
-      });
-
-    case 'identity.getPlayer': {
-      const playerId = currentPlayerId();
-
-      if (playerId === undefined) {
-        return ok(input, null);
-      }
-
-      return ok(input, {
-        playerId,
-        displayName: await currentDisplayName(playerId),
-      });
-    }
-
-    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, []);
-
-    case 'commerce.purchase':
-      return ok(input, {
-        status: 'cancelled',
-        entitlementIds: [],
-      });
-
-    case 'commerce.restore':
-      return ok(input, {
-        restoredEntitlements: [],
-      });
-
-    case 'ads.preload':
-      return ok(input, {});
-
-    case 'leaderboard.open':
-      return createBridgeError(
-        input.id,
-        'DEVVIT_LEADERBOARD_OPEN_UNAVAILABLE',
-        'Devvit leaderboard display is not implemented yet.',
-      );
-
-    case 'ads.showRewarded':
-      return ok(input, {
-        status: 'unavailable',
-        rewardGranted: false,
-      });
-
-    case 'ads.showInterstitial':
-      return ok(input, {
-        status: 'unavailable',
-      });
-
-    case 'leaderboard.submitScore':
-      return ok(input, {
-        submitted: false,
-      });
-
-    case 'storage.load':
-      return loadStorage(input);
-
-    case 'storage.save':
-      return saveStorage(input);
-
-    default:
-      return createBridgeError(
-        input.id,
-        'UNSUPPORTED_METHOD',
-        `Unsupported Devvit bridge method: ${input.method}`,
-      );
-  }
-}
-
-async function loadStorage(input: BridgeRequest): Promise<BridgeResponse> {
-  const playerId = currentPlayerId();
-
-  if (playerId === undefined) {
-    return createBridgeError(
-      input.id,
-      'DEVVIT_STORAGE_IDENTITY_REQUIRED',
-      'A current Reddit player is required to load storage.',
-    );
-  }
-
-  const key = storageKey(input, playerId);
-
-  if (typeof key !== 'string') {
-    return key;
-  }
-
-  let stored: string | null | undefined;
-
-  try {
-    stored = await redis.get(key);
-  } catch (error) {
-    console.warn(`devvit storage load failed: ${errorMessage(error)}`);
-    return createBridgeError(
-      input.id,
-      'DEVVIT_STORAGE_LOAD_FAILED',
-      'Devvit storage could not be loaded.',
-      true,
-    );
-  }
-
-  if (stored === undefined || stored === null) {
-    return ok(input, {
-      __mpgdBridgeProtocol: bridgeStorageLoadProtocol,
-      found: false,
-    } satisfies BridgeStorageLoadData);
-  }
-
-  try {
-    return ok(
-      input,
-      {
-        __mpgdBridgeProtocol: bridgeStorageLoadProtocol,
-        found: true,
-        value: JSON.parse(stored),
-      } satisfies BridgeStorageLoadData,
-    );
-  } catch {
-    return createBridgeError(input.id, 'CORRUPTED_STORAGE_VALUE', 'Stored data is not valid JSON.');
-  }
-}
-
-async function saveStorage(input: BridgeRequest): Promise<BridgeResponse> {
-  const playerId = currentPlayerId();
-
-  if (playerId === undefined) {
-    return createBridgeError(
-      input.id,
-      'DEVVIT_STORAGE_IDENTITY_REQUIRED',
-      'A current Reddit player is required to save storage.',
-    );
-  }
-
-  const key = storageKey(input, playerId);
-
-  if (typeof key !== 'string') {
-    return key;
-  }
-
-  const payload = optionalObjectPayload(input.payload) as { readonly value?: unknown };
-  let serialized: string;
-
-  try {
-    const candidate = JSON.stringify(payload.value);
-
-    if (typeof candidate !== 'string') {
-      throw new Error('JSON serialization did not produce a string.');
-    }
-
-    serialized = candidate;
-  } catch {
-    return createBridgeError(
-      input.id,
-      'INVALID_STORAGE_VALUE',
-      'Storage values must be JSON serializable.',
-    );
-  }
-
-  if (new TextEncoder().encode(serialized).length > maxStorageValueBytes) {
-    return createBridgeError(
-      input.id,
-      'DEVVIT_STORAGE_QUOTA_EXCEEDED',
-      `Storage values must not exceed ${String(maxStorageValueBytes)} UTF-8 bytes.`,
-    );
-  }
-
-  try {
-    await redis.set(key, serialized);
-  } catch (error) {
-    console.warn(`devvit storage save was not persisted: ${errorMessage(error)}`);
-    return createBridgeError(
-      input.id,
-      'DEVVIT_STORAGE_SAVE_FAILED',
-      'Devvit storage could not be saved.',
-      true,
-    );
-  }
-
-  return ok(input, {
-    saved: true,
-    playerId,
-  });
-}
-
-function ok(input: BridgeRequest, data: unknown): BridgeResponse {
-  return {
-    id: input.id,
-    ok: true,
-    data,
-  };
-}
-
-function storageKey(input: BridgeRequest, playerId: string): string | BridgeResponse {
-  const payload = optionalObjectPayload(input.payload);
-
-  if (typeof payload.key !== 'string' || payload.key.length === 0) {
-    return createBridgeError(input.id, 'INVALID_STORAGE_KEY', 'Storage key is required.');
-  }
-
-  if (payload.key.length > maxStorageKeyLength) {
-    return createBridgeError(input.id, 'INVALID_STORAGE_KEY', 'Storage key is too long.');
-  }
-
-  const encodedKey = encodeURIComponent(payload.key);
-
-  if (encodedKey.length > maxEncodedStorageKeyLength) {
-    return createBridgeError(input.id, 'INVALID_STORAGE_KEY', 'Encoded storage key is too long.');
-  }
-
-  return `${gameName}:save:${encodeURIComponent(playerId)}:${encodedKey}`;
-}
-
 function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
@@ -435,14 +160,6 @@ function currentSubredditName(): string | undefined {
     : undefined;
 }
 
-function optionalObjectPayload(payload: unknown): Record<string, unknown> {
-  if (typeof payload !== 'object' || payload === null) {
-    return {};
-  }
-
-  return payload as Record<string, unknown>;
-}
-
 function requestPathname(request: IncomingMessage): string {
   return new URL(request.url ?? '/', 'http://localhost').pathname;
 }

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

@@ -18,6 +18,10 @@ interface RuntimePlatformTargetMetadata {
   readonly integrations?: Record<string, unknown>;
 }
 
+// Sandbox gateways self-complete purchases and rewards without any backend
+// verification, so a non-production build alone must never select them. Each
+// one additionally requires the explicit BUILD_ID its dev script sets.
+const aitSandboxBuildId = 'ait-sandbox';
 const devvitSandboxBuildId = 'devvit-sandbox';
 
 export interface CreateGameViteSharedConfigInput {
@@ -140,7 +144,7 @@ export function resolveBuildGatewayModule(input: {
     case 'ios':
       return 'src/platform/buildGateways/capacitorIos.ts';
     case 'ait':
-      return input.debug
+      return input.debug && input.buildId === aitSandboxBuildId
         ? 'src/platform/buildGateways/aitSandbox.ts'
         : 'src/platform/buildGateways/ait.ts';
     case 'reddit':