@mpgd/cli 0.6.0 → 0.8.0

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

@@ -1,3 +1,5 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+
 import { createServer, context, getServerPort, reddit, redis } from '@devvit/web/server';
 import type { UiResponse } from '@devvit/web/shared';
 import {
@@ -7,17 +9,16 @@ import {
   type BridgeResponse,
 } from '@mpgd/bridge';
 import {
-  createBridgeRpcFetchHandler,
   createBridgeRpcRouter,
   defaultBridgeRpcEndpoint,
 } from '@mpgd/bridge/orpc';
-import express, { type Request as ExpressRequest, type Response as ExpressResponse } from 'express';
-import helmet from 'helmet';
+import { createBridgeRpcNodeHandler } from '@mpgd/bridge/orpc/node';
 
-const app = express();
 const redisKeyComponentPattern = /^[A-Za-z0-9:_-]{1,128}$/;
 const maxStorageKeyLength = 128;
 const maxEncodedStorageKeyLength = 384;
+const maxRequestBodySize = 1_000_000;
+const legacyBridgeEndpoint = '/api/mpgd/bridge';
 const leaderboardUpdateMaxAttempts = 3;
 const leaderboardBackoffBaseMs = 25;
 const leaderboardLockTtlMs = 2_000;
@@ -25,51 +26,125 @@ const leaderboardLockTtlSeconds = Math.ceil(leaderboardLockTtlMs / 1_000);
 const leaderboardLockRetryBudgetMs = leaderboardLockTtlSeconds * 1_000;
 const gameName = '__GAME_NAME__';
 const gameTitle = __GAME_TITLE_TS_LITERAL__;
-const expressManagedResponseHeaders = new Set([
-  'connection',
-  'content-encoding',
-  'content-length',
-  'transfer-encoding',
-]);
-
-app.disable('x-powered-by');
-app.use(helmet());
-
-const bridgeRpcFetchHandler = createBridgeRpcFetchHandler(
+const bridgeRpcHandler = createBridgeRpcNodeHandler(
   createBridgeRpcRouter(handleBridgeRequest),
+  {
+    maxBodySize: maxRequestBodySize,
+    prefix: defaultBridgeRpcEndpoint,
+  },
 );
 
-app.use(defaultBridgeRpcEndpoint, express.raw({ type: '*/*', limit: '1mb' }), async (
-  request: ExpressRequest,
-  response: ExpressResponse,
-): Promise<void> => {
+async function handleHttpRequest(
+  request: IncomingMessage,
+  response: ServerResponse,
+): Promise<void> {
+  setResponseSecurityHeaders(response);
+
+  if (request.method === 'POST' && requestPathname(request) === '/internal/menu/create-post') {
+    try {
+      await drainRequestBody(request, maxRequestBodySize);
+    } catch (error) {
+      if (!(error instanceof RequestBodyTooLargeError)) {
+        throw error;
+      }
+
+      discardOversizedRequestBody(request, response);
+      sendJson(response, 413, {
+        error: 'REQUEST_BODY_TOO_LARGE',
+      });
+      return;
+    }
+
+    await handleCreatePostMenu(response);
+    return;
+  }
+
+  if (request.method === 'POST' && requestPathname(request) === legacyBridgeEndpoint) {
+    await handleLegacyBridgeRequest(request, response);
+    return;
+  }
+
+  if (await bridgeRpcHandler(request, response)) {
+    return;
+  }
+
+  sendJson(response, 404, {
+    error: 'NOT_FOUND',
+  });
+}
+
+async function handleLegacyBridgeRequest(
+  request: IncomingMessage,
+  response: ServerResponse,
+): Promise<void> {
+  let body: unknown;
+
+  try {
+    body = await readJsonRequestBody(request, maxRequestBodySize);
+  } catch (error) {
+    const responseError = describeLegacyBridgeBodyError(error);
+
+    if (error instanceof RequestBodyTooLargeError) {
+      discardOversizedRequestBody(request, response);
+    }
+
+    if (responseError.retryable) {
+      console.error(`devvit legacy bridge body read failed: ${errorMessage(error)}`, error);
+    }
+
+    sendJson(
+      response,
+      responseError.status,
+      createBridgeError(
+        'unknown',
+        responseError.code,
+        responseError.message,
+        responseError.retryable,
+      ),
+    );
+    return;
+  }
+
+  let bridgeRequest: BridgeRequest;
+
+  try {
+    bridgeRequest = assertBridgeRequest(body);
+  } catch (error) {
+    console.warn(`devvit legacy bridge validation failed: ${errorMessage(error)}`);
+    sendJson(
+      response,
+      400,
+      createBridgeError(
+        requestIdFromBody(body),
+        'INVALID_BRIDGE_REQUEST',
+        'Invalid bridge request.',
+      ),
+    );
+    return;
+  }
+
   try {
-    const fetchResponse = await bridgeRpcFetchHandler(expressRequestToFetchRequest(request));
-    await sendFetchResponse(response, fetchResponse);
+    sendJson(response, 200, await handleBridgeRequest(bridgeRequest));
   } catch (error) {
-    const message = error instanceof Error ? error.message : 'Devvit oRPC request failed.';
-    console.error(`devvit oRPC internal error: ${message}`, error);
-    response.status(500).json(
+    console.error(`devvit legacy bridge request failed: ${errorMessage(error)}`, error);
+    sendJson(
+      response,
+      500,
       createBridgeError(
-        requestIdFromBody(request.body),
+        bridgeRequest.id,
         'DEVVIT_BRIDGE_INTERNAL_ERROR',
         'Devvit bridge request failed.',
         true,
       ),
     );
   }
-});
-
-app.use(express.json({ limit: '1mb' }));
+}
 
-app.post('/internal/menu/create-post', async (
-  _request: ExpressRequest,
-  response: ExpressResponse,
-): Promise<void> => {
+async function handleCreatePostMenu(response: ServerResponse): Promise<void> {
   const subredditName = currentSubredditName();
 
   if (subredditName === undefined) {
-    response.status(200).json({
+    sendJson(response, 200, {
       showToast: {
         text: 'Could not resolve the target subreddit for this menu action.',
         appearance: 'neutral',
@@ -92,7 +167,7 @@ app.post('/internal/menu/create-post', async (
       },
     });
 
-    response.status(200).json({
+    sendJson(response, 200, {
       showToast: {
         text: `Created ${gameTitle} post ${post.id}.`,
         appearance: 'success',
@@ -100,53 +175,30 @@ app.post('/internal/menu/create-post', async (
     } satisfies UiResponse);
   } catch (error) {
     console.error(`devvit custom post creation failed: ${errorMessage(error)}`, error);
-    response.status(200).json({
+    sendJson(response, 200, {
       showToast: {
         text: `Could not create the ${gameTitle} post.`,
         appearance: 'neutral',
       },
     } satisfies UiResponse);
   }
-});
-
-app.post('/api/mpgd/bridge', async (
-  request: ExpressRequest,
-  response: ExpressResponse,
-): Promise<void> => {
-  let bridgeRequest: BridgeRequest;
+}
 
-  try {
-    bridgeRequest = assertBridgeRequest(request.body);
-  } catch (error) {
-    response.status(400).json(
-      createBridgeError(
-        requestIdFromBody(request.body),
-        'INVALID_BRIDGE_REQUEST',
-        error instanceof Error ? error.message : 'Invalid bridge request.',
-      ),
-    );
-    return;
-  }
+const server = createServer((request, response) => {
+  void handleHttpRequest(request, response).catch((error: unknown) => {
+    console.error(`devvit server request failed: ${errorMessage(error)}`, error);
 
-  try {
-    const bridgeResponse = await handleBridgeRequest(bridgeRequest);
-    response.status(200).json(bridgeResponse);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Devvit bridge request failed.';
-    console.error(`devvit bridge internal error: ${message}`, error);
+    if (response.headersSent) {
+      response.end();
+      return;
+    }
 
-    response.status(500).json(
-      createBridgeError(
-        bridgeRequest.id,
-        'DEVVIT_BRIDGE_INTERNAL_ERROR',
-        'Devvit bridge request failed.',
-        true,
-      ),
-    );
-  }
+    sendJson(response, 500, {
+      error: 'DEVVIT_SERVER_INTERNAL_ERROR',
+    });
+  });
 });
 
-const server = createServer(app);
 const port = getServerPort();
 
 server.on('error', (error) => {
@@ -387,15 +439,6 @@ async function saveStorage(input: BridgeRequest): Promise<BridgeResponse> {
   });
 }
 
-function requestIdFromBody(input: unknown): string {
-  if (typeof input !== 'object' || input === null) {
-    return 'unknown';
-  }
-
-  const candidate = input as { readonly id?: unknown };
-  return typeof candidate.id === 'string' ? candidate.id : 'unknown';
-}
-
 function ok(input: BridgeRequest, data: unknown): BridgeResponse {
   return {
     id: input.id,
@@ -641,61 +684,130 @@ function optionalObjectPayload(payload: unknown): Record<string, unknown> {
   return payload as Record<string, unknown>;
 }
 
-function expressRequestToFetchRequest(request: ExpressRequest): Request {
-  const headers = new Headers();
+function requestPathname(request: IncomingMessage): string {
+  return new URL(request.url ?? '/', 'http://localhost').pathname;
+}
 
-  for (const [key, value] of Object.entries(request.headers)) {
-    if (typeof value === 'string') {
-      headers.set(key, value);
-    } else if (Array.isArray(value)) {
-      headers.set(key, value.join(', '));
-    }
+class RequestBodyTooLargeError extends Error {}
+
+function describeLegacyBridgeBodyError(error: unknown): {
+  readonly status: number;
+  readonly code: string;
+  readonly message: string;
+  readonly retryable: boolean;
+} {
+  if (error instanceof RequestBodyTooLargeError) {
+    return {
+      status: 413,
+      code: 'BRIDGE_REQUEST_TOO_LARGE',
+      message: 'Bridge request body is too large.',
+      retryable: false,
+    };
+  }
+
+  if (error instanceof SyntaxError) {
+    return {
+      status: 400,
+      code: 'INVALID_BRIDGE_REQUEST',
+      message: 'Bridge request body is not valid JSON.',
+      retryable: false,
+    };
   }
 
-  const init: RequestInit = {
-    method: request.method,
-    headers,
+  return {
+    status: 500,
+    code: 'DEVVIT_BRIDGE_INTERNAL_ERROR',
+    message: 'Bridge request body could not be read.',
+    retryable: true,
   };
+}
+
+async function* readRequestBodyChunks(
+  request: IncomingMessage,
+  maxBodySize: number,
+): AsyncGenerator<Buffer, void, undefined> {
+  assertContentLengthWithinLimit(request, maxBodySize);
+
+  let bodySize = 0;
 
-  if (request.method !== 'GET' && request.method !== 'HEAD') {
-    init.body = requestBodyToBodyInit(request.body);
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bodySize += buffer.byteLength;
 
-    if (!headers.has('content-type') && !(request.body instanceof Uint8Array)) {
-      headers.set('content-type', 'application/json');
+    if (bodySize > maxBodySize) {
+      throw new RequestBodyTooLargeError();
     }
+
+    yield buffer;
+  }
+}
+
+async function drainRequestBody(
+  request: IncomingMessage,
+  maxBodySize: number,
+): Promise<void> {
+  for await (const _chunk of readRequestBodyChunks(request, maxBodySize)) {
+    // Drain the bounded request stream without retaining its contents.
   }
+}
+
+async function readJsonRequestBody(
+  request: IncomingMessage,
+  maxBodySize: number,
+): Promise<unknown> {
+  const chunks: Buffer[] = [];
 
-  return new Request(expressRequestUrl(request), init);
+  for await (const chunk of readRequestBodyChunks(request, maxBodySize)) {
+    chunks.push(chunk);
+  }
+
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'));
 }
 
-function requestBodyToBodyInit(input: unknown): BodyInit {
-  if (input instanceof Uint8Array) {
-    const body = new Uint8Array(input.byteLength);
-    body.set(input);
+function assertContentLengthWithinLimit(
+  request: IncomingMessage,
+  maxBodySize: number,
+): void {
+  const contentLength = request.headers['content-length'];
 
-    return body.buffer as ArrayBuffer;
+  if (
+    contentLength !== undefined
+    && Number.isFinite(Number(contentLength))
+    && Number(contentLength) > maxBodySize
+  ) {
+    throw new RequestBodyTooLargeError();
   }
+}
 
-  return JSON.stringify(input ?? null);
+function discardOversizedRequestBody(
+  request: IncomingMessage,
+  response: ServerResponse,
+): void {
+  response.setHeader('connection', 'close');
+  request.resume();
 }
 
-function expressRequestUrl(request: ExpressRequest): string {
-  const host = request.get('host') ?? 'localhost';
-  const protocol = request.protocol || 'https';
+function requestIdFromBody(input: unknown): string {
+  if (typeof input !== 'object' || input === null || !('id' in input)) {
+    return 'unknown';
+  }
 
-  return `${protocol}://${host}${request.originalUrl}`;
+  const id = (input as { readonly id?: unknown }).id;
+  return typeof id === 'string' && id.length > 0 ? id : 'unknown';
 }
 
-async function sendFetchResponse(
-  response: ExpressResponse,
-  fetchResponse: Response,
-): Promise<void> {
-  fetchResponse.headers.forEach((value: string, key: string) => {
-    if (!expressManagedResponseHeaders.has(key.toLowerCase())) {
-      response.setHeader(key, value);
-    }
-  });
+function setResponseSecurityHeaders(response: ServerResponse): void {
+  response.setHeader('cache-control', 'no-store');
+  response.setHeader('content-security-policy', "default-src 'none'; frame-ancestors 'none'");
+  response.setHeader('referrer-policy', 'no-referrer');
+  response.setHeader('x-content-type-options', 'nosniff');
+  response.setHeader('x-frame-options', 'DENY');
+}
 
-  response.status(fetchResponse.status);
-  response.send(await fetchResponse.text());
+function sendJson(response: ServerResponse, status: number, body: unknown): void {
+  const payload = JSON.stringify(body);
+  response.statusCode = status;
+  response.setHeader('content-length', Buffer.byteLength(payload));
+  response.setHeader('content-type', 'application/json; charset=utf-8');
+  response.end(payload);
 }

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

@@ -0,0 +1,9 @@
+import { redis } from '@devvit/web/server';
+import {
+  createDevvitRedisPostOperationStore,
+  type DevvitDurableOperationStore,
+} from '@mpgd/adapter-devvit/server';
+
+export function createPostOperationStore(): DevvitDurableOperationStore {
+  return createDevvitRedisPostOperationStore(redis);
+}

package/templates/phaser-game/apps/target-devvit/tsconfig.json

@@ -2,8 +2,13 @@
   "extends": "../../tsconfig.json",
   "compilerOptions": {
     "allowSyntheticDefaultImports": true,
-    "types": ["node"],
+    "types": ["node", "vite/client"],
     "noEmit": true
   },
-  "include": ["src/**/*.ts", "vite.server.config.ts"]
+  "include": [
+    "src/**/*.ts",
+    "vite.config.ts",
+    "../../src/**/*.ts",
+    "../../vite.shared.ts"
+  ]
 }

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

@@ -0,0 +1,41 @@
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { devvit } from '@devvit/start/vite';
+import { defineConfig } from 'vite';
+
+import { createGameViteSharedConfig } from '../../vite.shared';
+
+const wrapperRoot = fileURLToPath(new URL('.', import.meta.url));
+const gameRoot = resolve(wrapperRoot, '../..');
+
+export default defineConfig(({ mode }) => {
+  const shared = createGameViteSharedConfig({
+    appTarget: 'reddit',
+    configTarget: 'reddit',
+    gameRoot,
+    mode,
+    platformTargetsFile: resolve(gameRoot, 'mpgd.targets.json'),
+    project: resolve(wrapperRoot, 'tsconfig.json'),
+  });
+
+  return {
+    ...shared,
+    publicDir: resolve(gameRoot, 'public'),
+    plugins: [
+      ...(shared.plugins ?? []),
+      devvit({
+        client: {
+          build: {
+            sourcemap: mode !== 'production',
+          },
+        },
+        server: {
+          build: {
+            sourcemap: mode !== 'production',
+          },
+        },
+      }),
+    ],
+  };
+});

package/templates/phaser-game/game.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="theme-color" content="#0f172a" />
+    <title>__GAME_TITLE__</title>
+  </head>
+  <body>
+    <div id="game"></div>
+    <script type="module" src="/src/gameEntry.ts"></script>
+  </body>
+</html>

package/templates/phaser-game/gitignore

@@ -1,9 +1,11 @@
 node_modules/
 dist/
 apps/*/dist/
+apps/target-devvit/generated/
 artifacts/
 release-output/
 .mpgd.targets.generated.json
+.mpgd/
 .env
 .env.*
 apps/*/.env

package/templates/phaser-game/index.html

@@ -4,11 +4,11 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="theme-color" content="#0f172a" />
-    <link rel="manifest" href="/manifest.webmanifest" />
+    <link rel="manifest" href="./manifest.webmanifest" />
     <title>__GAME_TITLE__</title>
   </head>
   <body>
     <div id="game"></div>
-    <script type="module" src="/src/main.ts"></script>
+    <script type="module" src="/src/entry.ts"></script>
   </body>
 </html>

package/templates/phaser-game/mpgd.game.json

@@ -0,0 +1,8 @@
+{
+  "brand": {
+    "appIcon": {
+      "source": "public/icon.svg",
+      "backgroundColor": "#0f172a"
+    }
+  }
+}

package/templates/phaser-game/mpgd.targets.json

@@ -4,12 +4,14 @@
       "kind": "web",
       "gameApp": ".",
       "adapter": "browser",
+      "icon": { "profile": "web-preview" },
       "output": "artifacts/web-preview"
     },
     "microsoft-store": {
       "kind": "web",
       "gameApp": ".",
       "adapter": "browser",
+      "icon": { "profile": "microsoft-pwa" },
       "output": "artifacts/microsoft-store"
     },
     "android": {
@@ -17,6 +19,7 @@
       "gameApp": ".",
       "shellApp": "${MPGD_KIT_PATH}/apps/mobile-capacitor",
       "adapter": "capacitor",
+      "icon": { "profile": "android" },
       "webDir": "${MPGD_KIT_PATH}/apps/mobile-capacitor/www",
       "artifact": "aab"
     },
@@ -25,6 +28,7 @@
       "gameApp": ".",
       "shellApp": "${MPGD_KIT_PATH}/apps/mobile-capacitor",
       "adapter": "capacitor",
+      "icon": { "profile": "ios" },
       "webDir": "${MPGD_KIT_PATH}/apps/mobile-capacitor/www",
       "artifact": "ipa"
     },
@@ -33,14 +37,17 @@
       "gameApp": ".",
       "wrapperApp": "${MPGD_KIT_PATH}/apps/target-ait",
       "adapter": "ait",
+      "icon": { "profile": "ait" },
       "webDir": "${MPGD_KIT_PATH}/apps/target-ait/public/game",
       "artifact": ".ait"
     },
     "reddit": {
       "kind": "devvit-web",
+      "buildStrategy": "devvit-vite",
       "gameApp": ".",
       "wrapperApp": "apps/target-devvit",
       "adapter": "devvit",
+      "icon": { "profile": "devvit" },
       "webDir": "apps/target-devvit/dist/client",
       "artifact": "devvit"
     }

package/templates/phaser-game/package.json

@@ -8,7 +8,13 @@
     "dev": "__WORKSPACE_I18N_BUILD_PREFIX__vite --host 0.0.0.0",
     "dev:ait": "APP_TARGET=ait APP_VERSION=0.0.0-dev BUILD_ID=ait-sandbox sh -c '__WORKSPACE_I18N_BUILD_PREFIX__vite --host 0.0.0.0'",
     "build": "__WORKSPACE_I18N_BUILD_PREFIX__vite build",
-    "build:ait": "pnpm exec mpgd target build ait production --variant wrapper --targets-file ./mpgd.targets.json --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
+    "accept": "node ./tools/run-game-acceptance.mjs",
+    "icons:generate": "pnpm exec mpgd game icons generate . --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
+    "icons:generate:devvit": "pnpm exec mpgd game icons generate . --targets reddit --profile development --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
+    "icons:generate:devvit:production": "pnpm exec mpgd game icons generate . --targets reddit --profile production --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
+    "icons:verify": "pnpm exec mpgd game icons verify . --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
+    "icons:inspect": "pnpm exec mpgd game icons inspect . --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
+    "build:ait": "pnpm exec mpgd target build ait staging --variant wrapper --targets-file ./mpgd.targets.json --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
     "build:ait:package": "pnpm exec mpgd target build ait production --targets-file ./mpgd.targets.json --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
     "smoke:ait": "pnpm exec mpgd target smoke ait --targets-file ./mpgd.targets.json --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
     "ait:wrapper:dev": "pnpm --dir ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}/apps/target-ait run dev",
@@ -67,10 +73,10 @@
     "@ait-co/console-cli": "^0.1.45",
     "@cloudflare/workers-types": "^5.20260707.1",
     "@mpgd/cli": "__MPGD_DEPENDENCY_VERSION_CLI__",
-    "@ttsc/unplugin": "0.16.9",
+    "@ttsc/unplugin": "0.18.4",
     "@types/node": "^24.0.0",
-    "ttsc": "0.16.9",
-    "typescript": "7.0.1-rc",
+    "ttsc": "0.18.4",
+    "typescript": "7.0.2",
     "vite": "^8.1.3",
     "wrangler": "^4.107.0"
   }

package/templates/phaser-game/public/manifest.webmanifest

@@ -3,6 +3,7 @@
   "name": "__GAME_TITLE__",
   "short_name": "__GAME_NAME__",
   "description": "__GAME_TITLE__ built with mpgd-kit.",
+  "id": "./__GAME_NAME__",
   "start_url": "./",
   "scope": "./",
   "display": "standalone",

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

@@ -0,0 +1,7 @@
+if (__APP_TARGET__ === 'reddit') {
+  await import('./platform/devvitEntrypoint');
+} else {
+  await import('./main');
+}
+
+export {};

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

@@ -2,6 +2,9 @@
 
 declare const __APP_TARGET__: string;
 declare const __MPGD_CONFIG_TARGET__: string;
+declare const __MPGD_PLATFORM_TARGET__:
+  | import('@mpgd/target-config').EffectivePlatformTargetMetadata
+  | undefined;
 declare const __APP_VERSION__: string;
 declare const __BUILD_ID__: string;
 declare const __SOURCE_GIT_SHA__: string;

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

@@ -0,0 +1,3 @@
+await import('./main');
+
+export {};