@mpgd/cli 0.58.0 → 0.61.0

package/dist/play-release-rollout.js

@@ -0,0 +1,237 @@
+import { existsSync, statSync } from 'node:fs';
+import { isDefinitiveHttpError, isHttpStatus } from './play-internal-submission.js';
+import { assertPlayReleaseConfirmed, assertPlayTrackName, assertPlayUserFraction, } from './play-release-options.js';
+export const playRolloutActions = Object.freeze([
+    'update',
+    'halt',
+    'resume',
+    'complete',
+]);
+export class PlayRolloutUncertainError extends Error {
+    stage;
+    editId;
+    versionCodes;
+    constructor(stage, editId, 
+    /** The release that was being changed; pass one of them as --version-code on the re-run. */
+    versionCodes = []) {
+        super(`Google Play rollout ${stage} result is uncertain for edit ${editId}. Re-run the same `
+            + `command${versionCodes[0] === undefined ? '' : ` with --version-code ${versionCodes[0]}`}: `
+            + 'it reads the live track first and reports "unchanged" if the change landed.');
+        this.stage = stage;
+        this.editId = editId;
+        this.versionCodes = versionCodes;
+        this.name = 'PlayRolloutUncertainError';
+    }
+}
+// Without --version-code, the release an action applies to (or has already
+// been applied to, so a re-run after a lost response reports "unchanged").
+const sourceStatuses = {
+    update: ['inProgress'],
+    halt: ['inProgress', 'halted'],
+    resume: ['halted', 'inProgress'],
+    complete: ['inProgress', 'halted'],
+};
+/** Change one existing release on one named track with a service account. */
+export async function changePlayRollout(input) {
+    if (!existsSync(input.serviceAccountFile) || !statSync(input.serviceAccountFile).isFile()) {
+        throw new Error('Google Play service account file is missing.');
+    }
+    assertPlayRolloutInput(input);
+    const { createServiceAccountPublisher } = await import(new URL('./play-sdk-adapter.js', import.meta.url).href);
+    return changePlayRolloutWithPublisher(input, createServiceAccountPublisher(input.serviceAccountFile));
+}
+export function assertPlayRolloutInput(input) {
+    assertPlayTrackName(input.track);
+    if (!playRolloutActions.includes(input.action)) {
+        throw new Error('--action must be update, halt, resume or complete.');
+    }
+    if (input.versionCode !== undefined
+        && (!Number.isSafeInteger(input.versionCode) || input.versionCode < 1)) {
+        throw new Error('--version-code must be a positive integer.');
+    }
+    if (input.userFraction !== undefined) {
+        if (input.action !== 'update' && input.action !== 'resume') {
+            throw new Error('--user-fraction applies only to --action update or resume.');
+        }
+        assertPlayUserFraction(input.userFraction);
+    }
+    else if (input.action === 'update') {
+        throw new Error('--action update needs --user-fraction.');
+    }
+}
+/** Credential-free injection point for the mock-transport tests. */
+export async function changePlayRolloutWithPublisher(input, publisher) {
+    assertPlayRolloutInput(input);
+    if (input.dryRun !== true && (input.action === 'update' || input.action === 'resume')) {
+        // Leaves (or keeps) a staged rollout running: confirm before any request.
+        assertPlayReleaseConfirmed({ track: input.track, status: 'inProgress' }, input.confirmProduction === true);
+    }
+    else if (input.dryRun !== true) {
+        assertPlayReleaseConfirmed({ track: input.track, status: 'completed' }, input.confirmProduction === true);
+    }
+    input.signal?.throwIfAborted();
+    const { packageName, track: trackName } = input;
+    const editId = await publisher.insertEdit(packageName, input.signal);
+    let committed = false;
+    try {
+        let current;
+        try {
+            current = await publisher.getTrack(packageName, editId, trackName, input.signal);
+        }
+        catch (error) {
+            if (isHttpStatus(error, 404)) {
+                throw new Error(`Google Play has no ${trackName} track for ${packageName}.`);
+            }
+            throw error;
+        }
+        const releases = current.releases ?? [];
+        const target = selectRelease(releases, input);
+        const before = releaseState(target);
+        const changed = applyAction(target, input);
+        const versionCodes = [...(target.versionCodes ?? [])];
+        if (changed === undefined) {
+            return {
+                status: 'unchanged',
+                packageName,
+                track: trackName,
+                action: input.action,
+                versionCodes,
+                before,
+                after: before,
+            };
+        }
+        // Only the selected release changes; every other release goes back as Play returned it.
+        const desired = {
+            track: trackName,
+            releases: releases.map((release) => release === target ? changed : release),
+        };
+        const after = releaseState(changed);
+        if (input.dryRun === true) {
+            return {
+                status: 'dry-run',
+                packageName,
+                track: trackName,
+                action: input.action,
+                versionCodes,
+                before,
+                after,
+                plannedTrack: desired,
+            };
+        }
+        try {
+            await publisher.updateTrack(packageName, editId, desired, input.signal);
+        }
+        catch (error) {
+            if (isDefinitiveHttpError(error)) {
+                throw error;
+            }
+            throw new PlayRolloutUncertainError('track-update', editId, versionCodes);
+        }
+        try {
+            await publisher.validateEdit(packageName, editId, input.signal);
+        }
+        catch (error) {
+            if (isDefinitiveHttpError(error)) {
+                throw error;
+            }
+            throw new PlayRolloutUncertainError('validate', editId, versionCodes);
+        }
+        try {
+            await publisher.commitEdit(packageName, editId, input.signal);
+        }
+        catch (error) {
+            if (isDefinitiveHttpError(error)) {
+                throw error;
+            }
+            committed = true; // Unknown: never delete an edit that may have been committed.
+            throw new PlayRolloutUncertainError('commit', editId, versionCodes);
+        }
+        committed = true;
+        return {
+            status: 'committed',
+            packageName,
+            track: trackName,
+            action: input.action,
+            versionCodes,
+            before,
+            after,
+            editId,
+        };
+    }
+    finally {
+        if (!committed) {
+            // Discard the uncommitted edit (dry run, no-op or refusal); a failure here is harmless.
+            await publisher.deleteEdit(packageName, editId, input.signal).catch(() => undefined);
+        }
+    }
+}
+function selectRelease(releases, input) {
+    const candidates = input.versionCode === undefined
+        ? releases.filter((release) => sourceStatuses[input.action].includes(String(release.status)))
+        : releases.filter((release) => release.versionCodes?.includes(String(input.versionCode)));
+    if (candidates.length !== 1 || candidates[0] === undefined) {
+        const listed = releases.map((release) => `${String(release.status)} [${(release.versionCodes ?? []).join(',')}]`).join('; ') || 'none';
+        throw new Error(input.versionCode === undefined
+            ? `Google Play ${input.track} needs exactly one ${sourceStatuses[input.action].join(' or ')} `
+                + `release for --action ${input.action}; pass --version-code. Releases: ${listed}.`
+            : `Google Play ${input.track} has no single release with version code ${input.versionCode}. `
+                + `Releases: ${listed}.`);
+    }
+    return candidates[0];
+}
+/** The changed release, or undefined when it is already in the requested state. */
+function applyAction(release, input) {
+    const status = String(release.status);
+    const fraction = typeof release.userFraction === 'number' ? release.userFraction : undefined;
+    const refuse = (detail) => {
+        throw new Error(`Google Play ${input.track} release is ${status}; ${detail}`);
+    };
+    const { userFraction: _dropped, ...withoutFraction } = release;
+    switch (input.action) {
+        case 'update':
+            if (status !== 'inProgress') {
+                return refuse('only an inProgress release has a fraction to update.');
+            }
+            return fraction === input.userFraction
+                ? undefined
+                : { ...release, userFraction: input.userFraction };
+        case 'halt':
+            if (status === 'halted') {
+                return undefined;
+            }
+            if (status !== 'inProgress' && status !== 'completed') {
+                return refuse('only an inProgress or completed release can be halted.');
+            }
+            // Halting a completed release serves the previous completed release instead.
+            return { ...release, status: 'halted' };
+        case 'resume': {
+            if (status === 'inProgress') {
+                return input.userFraction === undefined || input.userFraction === fraction
+                    ? undefined
+                    : refuse('use --action update to change its fraction.');
+            }
+            if (status !== 'halted') {
+                return refuse('only a halted release can be resumed.');
+            }
+            const resumed = input.userFraction ?? fraction;
+            if (resumed === undefined) {
+                return refuse('it has no rollout fraction; pass --user-fraction or use --action complete.');
+            }
+            return { ...release, status: 'inProgress', userFraction: resumed };
+        }
+        case 'complete':
+            if (status === 'completed') {
+                return undefined;
+            }
+            if (status !== 'inProgress' && status !== 'halted') {
+                return refuse('only an inProgress or halted release can be completed.');
+            }
+            return { ...withoutFraction, status: 'completed' };
+    }
+}
+function releaseState(release) {
+    return {
+        status: String(release.status),
+        ...(typeof release.userFraction === 'number' ? { userFraction: release.userFraction } : {}),
+    };
+}

package/dist/play-sdk-adapter.js

@@ -43,17 +43,34 @@ function wrapPublisher(publisher) {
       });
       return response.data;
     },
-    async getTrack(packageName, editId, signal) {
+    async uploadDeobfuscationFile(input) {
+      await publisher.edits.deobfuscationfiles.upload({
+        packageName: input.packageName,
+        editId: input.editId,
+        apkVersionCode: input.versionCode,
+        deobfuscationFileType: "proguard",
+        media: { mimeType: "application/octet-stream", body: createReadStream(input.mappingFile) }
+      }, {
+        timeout: input.timeoutMs,
+        retry: false,
+        signal: input.signal,
+        ...input.requestRootUrl === void 0 ? {} : { rootUrl: input.requestRootUrl }
+      });
+    },
+    async getTrack(packageName, editId, track, signal) {
       return (await publisher.edits.tracks.get(
-        { packageName, editId, track: "internal" },
+        { packageName, editId, track },
         { signal }
       )).data;
     },
     async updateTrack(packageName, editId, track, signal) {
+      if (typeof track.track !== "string" || track.track === "") {
+        throw new Error("Google Play track update needs a track name.");
+      }
       await publisher.edits.tracks.update({
         packageName,
         editId,
-        track: "internal",
+        track: track.track,
         requestBody: track
       }, { retry: false, signal });
     },
@@ -69,6 +86,12 @@ function wrapPublisher(publisher) {
         editId,
         changesInReviewBehavior: "ERROR_IF_IN_REVIEW"
       }, { retry: false, signal });
+    },
+    async deleteEdit(packageName, editId, signal) {
+      await publisher.edits.delete(
+        { packageName, editId },
+        { retry: false, signal }
+      );
     }
   };
 }

package/dist/release-state.d.ts

@@ -54,6 +54,12 @@ export interface NativeSubmissionCheckpoint {
   readonly remoteEditId?: string;
   readonly remoteUploadId?: string;
   readonly remoteBuildId?: string;
+  /**
+  * Android only: digest of the Google Play release options (track, status,
+  * fraction, notes, mapping) the attempt started with. Absent for the original
+  * internal/completed submission. It never changes once written.
+  */
+  readonly playReleaseSha256?: string;
 }
 export interface NativeReleaseStatus {
   readonly plan: PlatformVersionReleasePlan;

package/dist/release-state.js

@@ -410,6 +410,11 @@ export async function checkpointNativeSubmission(input) {
             }
             if (isNativeSubmissionSettled(previous.status)
                 || previous.status === 'failed'
+                || (previous.playReleaseSha256 !== input.checkpoint.playReleaseSha256
+                    // Options may be corrected only before any remote edit exists.
+                    && !(previous.status === 'started' && input.checkpoint.status === 'started'
+                        && previous.remoteEditId === undefined
+                        && input.checkpoint.remoteEditId === undefined))
                 || previous.remoteEditId !== undefined
                     && previous.remoteEditId !== input.checkpoint.remoteEditId
                     && !(previous.target === 'android'
@@ -872,6 +877,7 @@ const checkpointFields = [
     'remoteEditId',
     'remoteUploadId',
     'remoteBuildId',
+    'playReleaseSha256',
 ];
 /** Validate persisted checkpoint shape before any remote mutation or recovery. */
 export function assertNativeSubmissionCheckpoint(value) {
@@ -907,6 +913,8 @@ export function assertNativeSubmissionCheckpoint(value) {
         || !Number.isFinite(Date.parse(value.leaseExpiresAt))
         || Object.keys(value).some((key) => !checkpointFields.includes(key))
         || !id('remoteEditId') || !id('remoteUploadId') || !id('remoteBuildId')
+        || (value.playReleaseSha256 !== undefined
+            && (value.target !== 'android' || !sha256Pattern.test(String(value.playReleaseSha256))))
         || (value.target === 'android' && (!androidStatuses.includes(value.status)
             || value.remoteUploadId !== undefined || value.remoteBuildId !== undefined
             || (['edit-open', 'committed'].includes(String(value.status))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/cli",
-  "version": "0.58.0",
+  "version": "0.61.0",
   "description": "Gunshi CLI for mpgd-kit starter generation and target workflow orchestration.",
   "license": "MIT",
   "repository": {
@@ -70,10 +70,10 @@
     "parse5": "7.3.0",
     "postcss": "8.5.28",
     "postcss-value-parser": "4.2.0",
-    "@mpgd/phaser-assets": "0.9.1",
-    "@mpgd/catalog": "0.11.0",
-    "@mpgd/platform": "0.29.0",
-    "@mpgd/target-config": "0.23.9"
+    "@mpgd/catalog": "0.11.3",
+    "@mpgd/platform": "0.32.0",
+    "@mpgd/target-config": "0.24.1",
+    "@mpgd/phaser-assets": "0.9.1"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",
@@ -81,18 +81,18 @@
     "@types/yauzl": "3.4.0",
     "ttsc": "0.32.1",
     "typescript": "7.0.2",
-    "@mpgd/adapter-ait": "0.20.6",
-    "@mpgd/adapter-devvit": "0.14.1",
-    "@mpgd/adapter-browser": "0.11.9",
-    "@mpgd/adapter-verse8": "0.7.10",
-    "@mpgd/adapter-capacitor": "0.13.0",
-    "@mpgd/analytics": "0.5.2",
-    "@mpgd/bridge": "0.16.1",
-    "@mpgd/capacitor-play-billing": "0.3.10",
-    "@mpgd/capacitor-storekit": "0.3.10",
-    "@mpgd/game-runtime": "0.8.3",
-    "@mpgd/game-services": "0.29.0",
-    "@mpgd/i18n": "0.6.23",
+    "@mpgd/adapter-ait": "0.21.1",
+    "@mpgd/adapter-browser": "0.12.1",
+    "@mpgd/adapter-capacitor": "0.16.0",
+    "@mpgd/adapter-verse8": "0.7.13",
+    "@mpgd/adapter-devvit": "0.14.4",
+    "@mpgd/bridge": "0.16.4",
+    "@mpgd/analytics": "0.5.5",
+    "@mpgd/capacitor-play-billing": "0.4.2",
+    "@mpgd/capacitor-storekit": "0.4.2",
+    "@mpgd/game-runtime": "0.8.6",
+    "@mpgd/game-services": "0.30.2",
+    "@mpgd/i18n": "0.6.26",
     "@mpgd/lite-shell": "0.1.0"
   },
   "main": "./dist/index.js",

package/templates/phaser-game/vite.runtime-target-config.ts

@@ -68,6 +68,7 @@ const targetIntegrations = Object.keys({
   sharing: true,
   inboundShare: true,
   notifications: true,
+  reviews: true,
 } satisfies Record<TargetIntegration, true>);
 
 export function assertRuntimeTargetConfigMatrix(input: unknown): TargetConfigMatrix {
@@ -142,6 +143,9 @@ function assertTargetConfig(input: unknown, label: string): asserts input is Tar
   if (input.integrations !== undefined) {
     assertRecord(input.integrations, `${label}.integrations`);
     for (const key of targetIntegrations) {
+      if (key === 'reviews' && input.integrations[key] === undefined) {
+        continue;
+      }
       assertOneOf(
         input.integrations[key],
         integrationAvailabilityValues,