@mpgd/cli 0.61.1 → 0.62.0

package/dist/release-state.js

@@ -6,6 +6,7 @@ import path from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { allocatePlatformVersions, assertPlatformVersionLedger, createMpgdReleaseIdentity, formatMpgdReleaseId, } from '@mpgd/target-config';
 import { runReleaseProcess } from './deploy-process.js';
+import { isDsymIdentityList } from './native-build-symbols.js';
 import { inspectAndroidBundleSigner } from './android-bundle-signer.js';
 export function isNativeSubmissionSettled(status) {
     return status === 'committed' || status === 'testflight-ready';
@@ -195,6 +196,7 @@ export async function reserveNativeRelease(input) {
             reservations: { ...(game?.reservations ?? {}), [input.releaseKey]: allocation.plan },
             builds: game?.builds ?? {},
             ...(game?.submissions === undefined ? {} : { submissions: game.submissions }),
+            ...(game?.symbolUploads === undefined ? {} : { symbolUploads: game.symbolUploads }),
         };
         const next = {
             schemaVersion: 1,
@@ -238,7 +240,26 @@ export async function recordNativeReleaseBuild(input) {
         || !statSync(input.releaseManifestFile).isFile()) {
         throw new Error('Native build record requires file artifacts.');
     }
-    const artifactSha256 = await sha256(input.artifactFile);
+    if ((input.r8Mapping !== undefined && input.target !== 'android')
+        || (input.crashlyticsSymbols !== undefined && (input.target !== 'ios'
+            || !isDsymIdentityList(input.crashlyticsSymbols.dsyms)))) {
+        throw new Error('Native build symbols do not match the build target.');
+    }
+    const r8Mapping = input.r8Mapping === undefined
+        ? undefined
+        : await recordSymbolFile(input.r8Mapping);
+    const crashlyticsSymbols = input.crashlyticsSymbols === undefined
+        ? undefined
+        : {
+            dsymArchive: await recordSymbolFile(input.crashlyticsSymbols.dsymArchive),
+            dsyms: input.crashlyticsSymbols.dsyms.map((entry) => ({
+                bundle: entry.bundle,
+                uuids: [...entry.uuids],
+            })),
+            uploadTool: await recordSymbolFile(input.crashlyticsSymbols.uploadTool),
+            googleServiceInfo: await recordSymbolFile(input.crashlyticsSymbols.googleServiceInfo),
+        };
+    const artifactSha256 = await sha256File(input.artifactFile);
     const manifestBytes = readFileSync(input.releaseManifestFile);
     const releaseManifestSha256 = createHash('sha256').update(manifestBytes).digest('hex');
     if (artifactSha256 !== input.expectedArtifactSha256
@@ -331,6 +352,8 @@ export async function recordNativeReleaseBuild(input) {
             ...(input.target === 'android'
                 ? { inspectedSignerSha256: signer }
                 : { inspectedTeamId: input.inspectedTeamId ?? '' }),
+            ...(r8Mapping === undefined ? {} : { r8Mapping }),
+            ...(crashlyticsSymbols === undefined ? {} : { crashlyticsSymbols }),
         };
         const key = `${input.releaseKey}/${input.target}`;
         const previous = ownValue(game.builds, key);
@@ -377,6 +400,8 @@ export async function readNativeReleaseStatus(input) {
                 ...(game.submissions?.[iosKey] === undefined
                     ? {} : { ios: game.submissions[iosKey] }),
             },
+            symbolUploads: game.symbolUploads?.[iosKey] === undefined
+                ? {} : { ios: game.symbolUploads[iosKey] },
             stateCommit: session.previousCommit,
         };
     });
@@ -529,6 +554,57 @@ export async function releaseNativeSubmissionLease(input) {
         return checkpoint;
     });
 }
+/**
+ * Record the outcome of a Crashlytics dSYM upload for one recorded iOS build.
+ * A failure can be recorded again and retried; once `uploaded`, it stays so.
+ */
+export async function recordCrashSymbolUpload(input) {
+    assertReleaseKey(input.releaseKey);
+    const upload = {
+        releaseKey: input.releaseKey,
+        target: 'ios',
+        buildRunId: input.buildRunId,
+        dsymArchiveSha256: input.dsymArchiveSha256,
+        status: input.status,
+        updatedAt: new Date().toISOString(),
+        ...(input.status === 'failed' && input.failure !== undefined
+            ? { failure: boundedFailure(input.failure) } : {}),
+    };
+    assertCrashSymbolUploadRecord(upload);
+    return withStateSession(input, async (session) => {
+        const game = ownValue(session.state.games, input.gameId);
+        const key = `${input.releaseKey}/ios`;
+        const build = game === undefined ? undefined : ownValue(game.builds, key);
+        if (game === undefined || build === undefined
+            || build.buildRunId !== input.buildRunId
+            || build.crashlyticsSymbols?.dsymArchive.sha256 !== input.dsymArchiveSha256) {
+            throw new Error('A dSYM upload must reference the immutable iOS build record.');
+        }
+        const previous = ownValue(game.symbolUploads ?? {}, key);
+        if (previous?.status === 'uploaded') {
+            if (input.status === 'uploaded') {
+                return previous;
+            }
+            throw new Error('The dSYMs of this build were already uploaded.');
+        }
+        const next = {
+            schemaVersion: 1,
+            games: {
+                ...session.state.games,
+                [input.gameId]: {
+                    ...game,
+                    symbolUploads: { ...(game.symbolUploads ?? {}), [key]: upload },
+                },
+            },
+        };
+        await commitState(session, next, `Symbols ${input.gameId}/${key} ${input.status}`);
+        return upload;
+    });
+}
+function boundedFailure(text) {
+    const line = text.replace(/[\u0000-\u001f\u007f]+/gu, ' ').trim();
+    return line.length > 300 ? `${line.slice(0, 297)}...` : (line === '' ? 'failed' : line);
+}
 /** Exported for tests: the checkpoint status moves a store submission may make. */
 export function allowedSubmissionTransition(from, to) {
     if (from === to) {
@@ -719,13 +795,14 @@ function parseReleaseState(json) {
         }
         const game = rawGame;
         if (Object.keys(game).some((key) => ![
-            'initialLedger', 'ledger', 'reservations', 'builds', 'submissions',
+            'initialLedger', 'ledger', 'reservations', 'builds', 'submissions', 'symbolUploads',
         ].includes(key))
             || typeof game.reservations !== 'object' || game.reservations === null
             || Array.isArray(game.reservations)
             || typeof game.builds !== 'object' || game.builds === null
             || Array.isArray(game.builds)
-            || (game.submissions !== undefined && !isRecord(game.submissions))) {
+            || (game.submissions !== undefined && !isRecord(game.submissions))
+            || (game.symbolUploads !== undefined && !isRecord(game.symbolUploads))) {
             throw new Error(`Release state game ${gameId} has invalid entries.`);
         }
         const initialLedger = assertPlatformVersionLedger(game.initialLedger);
@@ -789,6 +866,20 @@ function parseReleaseState(json) {
                 throw new Error(`Release state game ${gameId} has an invalid submission ${key}.`);
             }
         }
+        for (const [key, rawUpload] of Object.entries(game.symbolUploads ?? {})) {
+            const build = game.builds[key];
+            try {
+                assertCrashSymbolUploadRecord(rawUpload);
+            }
+            catch {
+                throw new Error(`Release state game ${gameId} has an invalid dSYM upload ${key}.`);
+            }
+            if (key !== `${rawUpload.releaseKey}/ios` || build === undefined
+                || rawUpload.buildRunId !== build.buildRunId
+                || rawUpload.dsymArchiveSha256 !== build.crashlyticsSymbols?.dsymArchive.sha256) {
+                throw new Error(`Release state game ${gameId} has an invalid dSYM upload ${key}.`);
+            }
+        }
     }
     return value;
 }
@@ -813,6 +904,8 @@ const buildRecordFields = [
     'inspectedAppId',
     'inspectedSignerSha256',
     'inspectedTeamId',
+    'r8Mapping',
+    'crashlyticsSymbols',
 ];
 function assertStoredBuildRecord(gameId, buildKey, value, reservations) {
     const malformed = () => {
@@ -853,7 +946,11 @@ function assertStoredBuildRecord(gameId, buildKey, value, reservations) {
             || !sha256Pattern.test(String(record.inspectedSignerSha256))))
         || (record.target === 'ios' && (record.inspectedSignerSha256 !== undefined
             || !teamIdPattern.test(String(record.inspectedTeamId))))
-        || !isRecord(record.platformVersion)) {
+        || !isRecord(record.platformVersion)
+        || (record.r8Mapping !== undefined
+            && (record.target !== 'android' || !isRecordedSymbolFile(record.r8Mapping)))
+        || (record.crashlyticsSymbols !== undefined
+            && (record.target !== 'ios' || !isRecordedCrashlyticsSymbols(record.crashlyticsSymbols)))) {
         malformed();
     }
     const plan = ownValue(reservations, record.releaseKey);
@@ -930,6 +1027,53 @@ export function assertNativeSubmissionCheckpoint(value) {
         throw new Error('Native submission checkpoint is malformed.');
     }
 }
+const recordedLocationPattern = /^[A-Za-z0-9._-][A-Za-z0-9._ +-]*(?:\/[A-Za-z0-9._-][A-Za-z0-9._ +-]*)*$/u;
+/** A game-relative location without `..` segments. */
+export function isRecordedLocation(location) {
+    return typeof location === 'string' && location.length <= 512
+        && recordedLocationPattern.test(location)
+        && !location.split('/').some((segment) => segment === '.' || segment === '..');
+}
+function isRecordedSymbolFile(value) {
+    return isRecord(value) && Object.keys(value).every((key) => key === 'location' || key === 'sha256')
+        && isRecordedLocation(value.location) && sha256Pattern.test(String(value.sha256));
+}
+function isRecordedCrashlyticsSymbols(value) {
+    return isRecord(value)
+        && Object.keys(value).every((key) => ['dsymArchive', 'dsyms', 'uploadTool', 'googleServiceInfo'].includes(key))
+        && isRecordedSymbolFile(value.dsymArchive) && isRecordedSymbolFile(value.uploadTool)
+        && isRecordedSymbolFile(value.googleServiceInfo) && isDsymIdentityList(value.dsyms);
+}
+const symbolUploadFields = [
+    'releaseKey',
+    'target',
+    'buildRunId',
+    'dsymArchiveSha256',
+    'status',
+    'updatedAt',
+    'failure',
+];
+function assertCrashSymbolUploadRecord(value) {
+    if (!isRecord(value)
+        || Object.keys(value).some((key) => !symbolUploadFields.includes(key))
+        || typeof value.releaseKey !== 'string' || !releaseKeyPattern.test(value.releaseKey)
+        || value.target !== 'ios'
+        || typeof value.buildRunId !== 'string' || value.buildRunId.trim() === ''
+        || !sha256Pattern.test(String(value.dsymArchiveSha256))
+        || (value.status !== 'uploaded' && value.status !== 'failed')
+        || typeof value.updatedAt !== 'string' || !Number.isFinite(Date.parse(value.updatedAt))
+        || (value.failure !== undefined && (value.status !== 'failed'
+            || typeof value.failure !== 'string' || value.failure.length > 300))) {
+        throw new Error('Crashlytics dSYM upload record is malformed.');
+    }
+}
+async function recordSymbolFile(input) {
+    if (!isRecordedLocation(input.location) || !existsSync(input.file)
+        || !statSync(input.file).isFile() || statSync(input.file).size === 0) {
+        throw new Error('Native build symbol file is missing or has an invalid location.');
+    }
+    return { location: input.location, sha256: await sha256File(input.file) };
+}
 function assertReservationHistory(gameId, initialLedger, ledger, plans) {
     if (plans.length === 0) {
         throw new Error(`Release state game ${gameId} has no reservation history.`);
@@ -993,7 +1137,8 @@ function assertReleaseKey(key) {
         throw new Error('Release key must be a lowercase, path-safe identifier.');
     }
 }
-async function sha256(file) {
+/** Streamed SHA-256 of a file, hex. */
+export async function sha256File(file) {
     const hash = createHash('sha256');
     for await (const chunk of createReadStream(file)) {
         hash.update(chunk);

package/dist/release-workspace.d.ts

@@ -1,4 +1,5 @@
 import { type NativeDeploymentPlan } from './deploy-planning.js';
+import { type NativeBuildSymbols } from './native-build-symbols.js';
 export interface PinnedReleaseInput {
   readonly gameRoot: string;
   readonly deploymentProfile: string;
@@ -21,6 +22,8 @@ export interface PinnedNativeBuildResult {
   readonly artifact: string;
   readonly releaseManifest: string;
   readonly runId: string;
+  /** Crash symbols of this build, as absolute paths inside the pinned game. */
+  readonly symbols?: NativeBuildSymbols;
 }
 /** Freeze a read-only deployment plan into the exact inputs used by a release run. */
 export declare function pinNativeDeploymentPlan(plan: NativeDeploymentPlan, kit: {

package/dist/release-workspace.js

@@ -4,6 +4,7 @@ import { tmpdir } from 'node:os';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import { planNativeDeployment } from './deploy-planning.js';
+import { assertNativeBuildSymbols, isNativeOutputPath, } from './native-build-symbols.js';
 import { runReleaseProcess, } from './deploy-process.js';
 const gitShaPattern = /^[0-9a-f]{40}$/u;
 const sha256Pattern = /^[0-9a-f]{64}$/u;
@@ -287,7 +288,49 @@ export async function runPinnedNativeBuild(workspace, input) {
         || manifest.kitGitSha !== workspace.input.kitGitSha) {
         throw new Error('Pinned native build manifest provenance does not match its inputs.');
     }
-    return { artifact, releaseManifest, runId: status.runId };
+    const symbols = status.symbols === undefined
+        ? undefined
+        : resolvePinnedBuildSymbols(workspace.gameRoot, input.target, status.symbols);
+    return {
+        artifact,
+        releaseManifest,
+        runId: status.runId,
+        ...(symbols === undefined ? {} : { symbols }),
+    };
+}
+/** Resolve the status file's symbol paths to regular files inside the pinned game. */
+function resolvePinnedBuildSymbols(gameRoot, target, value) {
+    assertNativeBuildSymbols(value, (file) => isNativeOutputPath(file, target));
+    const canonicalGameRoot = realpathSync(gameRoot);
+    const resolve = (file) => {
+        const absolute = assertInsideWorkspace(gameRoot, file);
+        if (!existsSync(absolute) || !lstatSync(absolute).isFile()) {
+            throw new Error(`Pinned native build symbol file is missing: ${file}`);
+        }
+        const relative = path.relative(canonicalGameRoot, realpathSync(absolute));
+        if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+            throw new Error('Pinned native build symbol file resolves outside its workspace.');
+        }
+        return absolute;
+    };
+    if (value.r8Mapping !== undefined) {
+        if (target !== 'android') {
+            throw new Error('Only an Android build records an R8 mapping file.');
+        }
+        return { r8Mapping: resolve(value.r8Mapping) };
+    }
+    const crashlytics = value.crashlytics;
+    if (crashlytics === undefined || target !== 'ios') {
+        throw new Error('Only an iOS build records Crashlytics dSYMs.');
+    }
+    return {
+        crashlytics: {
+            dsymArchive: resolve(crashlytics.dsymArchive),
+            dsyms: crashlytics.dsyms,
+            uploadTool: resolve(crashlytics.uploadTool),
+            googleServiceInfo: resolve(crashlytics.googleServiceInfo),
+        },
+    };
 }
 function assertPinnedInput(input) {
     if (!gitShaPattern.test(input.gameGitSha) || !gitShaPattern.test(input.kitGitSha)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/cli",
-  "version": "0.61.1",
+  "version": "0.62.0",
   "description": "Gunshi CLI for mpgd-kit starter generation and target workflow orchestration.",
   "license": "MIT",
   "repository": {
@@ -71,9 +71,9 @@
     "postcss": "8.5.28",
     "postcss-value-parser": "4.2.0",
     "@mpgd/catalog": "0.11.3",
-    "@mpgd/platform": "0.32.0",
+    "@mpgd/phaser-assets": "0.9.1",
     "@mpgd/target-config": "0.24.1",
-    "@mpgd/phaser-assets": "0.9.1"
+    "@mpgd/platform": "0.32.0"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",
@@ -81,17 +81,17 @@
     "@types/yauzl": "3.4.0",
     "ttsc": "0.32.1",
     "typescript": "7.0.2",
-    "@mpgd/adapter-ait": "0.21.2",
+    "@mpgd/adapter-ait": "0.21.3",
     "@mpgd/adapter-browser": "0.12.1",
-    "@mpgd/adapter-devvit": "0.14.4",
-    "@mpgd/adapter-verse8": "0.7.13",
-    "@mpgd/analytics": "0.5.5",
-    "@mpgd/adapter-capacitor": "0.16.0",
+    "@mpgd/adapter-capacitor": "0.16.1",
+    "@mpgd/adapter-verse8": "0.7.14",
     "@mpgd/bridge": "0.16.4",
-    "@mpgd/capacitor-storekit": "0.4.2",
-    "@mpgd/game-runtime": "0.8.6",
-    "@mpgd/capacitor-play-billing": "0.4.2",
-    "@mpgd/game-services": "0.30.2",
+    "@mpgd/capacitor-play-billing": "0.4.3",
+    "@mpgd/adapter-devvit": "0.14.5",
+    "@mpgd/capacitor-storekit": "0.4.3",
+    "@mpgd/analytics": "0.5.5",
+    "@mpgd/game-runtime": "0.8.7",
+    "@mpgd/game-services": "0.30.3",
     "@mpgd/i18n": "0.6.26",
     "@mpgd/lite-shell": "0.1.0"
   },

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

@@ -5,6 +5,8 @@ packages:
   - 'apps/*'
 __PNPM_WORKSPACE_KIT_PACKAGES__
 allowBuilds:
+  # Its postinstall only bakes in Firebase App Hosting config (FIREBASE_WEBAPP_CONFIG).
+  '@firebase/util': false
   '@sentry/cli': true
   '@swc/core': true
   esbuild: true