@mpgd/cli 0.67.0 → 0.68.0

package/dist/app-store-release-asc.d.ts

@@ -0,0 +1,39 @@
+import type { AscIapPort } from './app-store-iap-port.js';
+import type { AscStorePresencePort } from './app-store-presence-port.js';
+import type { AscReleasePort } from './app-store-release-port.js';
+import { type AscCommandRunner, type AscCredential } from './asc-session.js';
+/**
+* The release port on the pinned `asc` 5.5.0 CLI. Commands (5.5.0 source,
+* `internal/cli/...`):
+*
+* - `apps view` (`apps/apps.go`)
+* - `versions list|create|update|attach-build|release` and
+*   `versions phased-release view|create|update|delete` (`versions/`)
+* - `builds list` (`builds/builds_commands.go`)
+* - `versions view --include-build` for the attached build
+* - `review details-for-version|details-create|details-update`
+*   (`reviews/review_details.go`): the output withholds the demo password
+*   as "(redacted)"; a version without details prints `configured: false`
+* - `age-rating view --app-info-id` (`agerating/age_rating.go`)
+* - `review submissions-list|submissions-create|submissions-submit` and
+*   `review items-list|items-add` (`reviews/`): items are listed with
+*   `--include`, which is what makes App Store Connect return their
+*   version relationships (asc's own `submit` does the same)
+*
+* asc takes the demo account password only as a command-line flag, so it is
+* visible in the local process list while that one `asc` call runs; it is
+* redacted from the captured output and never written to a file.
+*/
+export interface AscReleaseSession {
+  readonly release: AscReleasePort;
+  readonly presence: AscStorePresencePort;
+  readonly iap: AscIapPort;
+  close(): void;
+}
+/** Copy and verify the pinned binary; `close` removes it. */
+export declare function openAscReleaseSession(credential: AscCredential, options?: {
+  readonly signal?: AbortSignal;
+  readonly secretValues?: readonly string[];
+}): Promise<AscReleaseSession>;
+/** The port over any runner; the tests drive it with recorded asc output. */
+export declare function createAscReleasePort(run: AscCommandRunner): AscReleasePort;

package/dist/app-store-release-asc.js

@@ -0,0 +1,274 @@
+import { createAscIapPort } from './app-store-iap-asc.js';
+import { createAscStorePresencePort } from './app-store-presence-asc.js';
+import { ascExitNotFound, ascListTimeoutMs, ascLookupTimeoutMs, isEmptyResource, isRecord, list, openAscSession, optionalString, relationshipId, requiredString, single, } from './asc-session.js';
+import { ReleaseProcessError } from './deploy-process.js';
+/** Copy and verify the pinned binary; `close` removes it. */
+export async function openAscReleaseSession(credential, options = {}) {
+    const session = await openAscSession(credential, options.signal, options.secretValues);
+    return {
+        release: createAscReleasePort(session.run),
+        presence: createAscStorePresencePort(session.run),
+        iap: createAscIapPort(session.run),
+        close: () => session.close(),
+    };
+}
+// AgeRatingDeclaration content descriptors (App Store Connect API
+// `AgeRatingDeclaration.Attributes`); a questionnaire never answered has none.
+const ageRatingDescriptors = [
+    'advertising',
+    'alcoholTobaccoOrDrugUseOrReferences',
+    'ageAssurance',
+    'contests',
+    'gambling',
+    'gamblingSimulated',
+    'gunsOrOtherWeapons',
+    'healthOrWellnessTopics',
+    'horrorOrFearThemes',
+    'lootBox',
+    'matureOrSuggestiveThemes',
+    'medicalOrTreatmentInformation',
+    'messagingAndChat',
+    'parentalControls',
+    'profanityOrCrudeHumor',
+    'sexualContentGraphicAndNudity',
+    'sexualContentOrNudity',
+    'unrestrictedWebAccess',
+    'userGeneratedContent',
+    'violenceCartoonOrFantasy',
+    'violenceRealistic',
+    'violenceRealisticProlongedGraphicOrSadistic',
+];
+/** The port over any runner; the tests drive it with recorded asc output. */
+export function createAscReleasePort(run) {
+    const optional = async (args) => {
+        try {
+            return await run(args, ascLookupTimeoutMs);
+        }
+        catch (error) {
+            if (error instanceof ReleaseProcessError && error.exitCode === ascExitNotFound) {
+                return undefined;
+            }
+            throw error;
+        }
+    };
+    return {
+        async readApp(appId) {
+            const app = single(await run(['apps', 'view', '--id', appId], ascLookupTimeoutMs), 'apps view');
+            if (app.id !== appId) {
+                throw new Error('asc apps view returned another app.');
+            }
+            return {
+                bundleId: requiredString(app.attributes.bundleId, 'app bundle ID'),
+                ...optionalString('primaryLocale', app.attributes.primaryLocale),
+            };
+        },
+        async listVersions(appId) {
+            return list(await run(['versions', 'list', '--app', appId, '--platform', 'IOS', '--paginate'], ascListTimeoutMs), 'versions list').map((resource) => ({
+                id: resource.id,
+                versionString: requiredString(resource.attributes.versionString, 'version string'),
+                ...optionalString('state', resource.attributes.appVersionState ?? resource.attributes.appStoreState),
+                ...optionalString('appStoreState', resource.attributes.appStoreState),
+                ...optionalString('releaseType', resource.attributes.releaseType),
+                ...optionalString('earliestReleaseDate', resource.attributes.earliestReleaseDate),
+                ...optionalString('copyright', resource.attributes.copyright),
+                ...optionalString('createdDate', resource.attributes.createdDate),
+            }));
+        },
+        async listBuilds(input) {
+            return list(await run([
+                'builds', 'list',
+                '--app', input.appId,
+                '--version', input.marketingVersion,
+                ...(input.buildNumber === undefined ? [] : ['--build-number', input.buildNumber]),
+                '--platform', 'IOS',
+                '--paginate',
+            ], ascListTimeoutMs), 'builds list').map((resource) => ({
+                id: resource.id,
+                buildNumber: requiredString(resource.attributes.version, 'build number'),
+                ...optionalString('processingState', resource.attributes.processingState),
+                ...(typeof resource.attributes.expired === 'boolean' ? { expired: resource.attributes.expired } : {}),
+                ...(typeof resource.attributes.usesNonExemptEncryption === 'boolean'
+                    ? { usesNonExemptEncryption: resource.attributes.usesNonExemptEncryption }
+                    : {}),
+                ...optionalString('uploadedDate', resource.attributes.uploadedDate),
+            }));
+        },
+        async readAttachedBuild(versionId) {
+            const result = await run(['versions', 'view', '--version-id', versionId, '--include-build'], ascLookupTimeoutMs);
+            if (!isRecord(result) || result.id !== versionId) {
+                throw new Error('asc versions view returned another version.');
+            }
+            return typeof result.buildId === 'string' && result.buildId !== ''
+                ? { id: result.buildId, ...optionalString('buildNumber', result.buildVersion) }
+                : undefined;
+        },
+        async readReviewDetail(versionId) {
+            const response = await optional(['review', 'details-for-version', '--version-id', versionId]);
+            if (response === undefined || isEmptyResource(response)
+                || (isRecord(response) && response.configured === false)) {
+                return undefined;
+            }
+            const detail = single(response, 'review details-for-version');
+            const text = (key) => optionalString(key, detail.attributes[key]);
+            return {
+                id: detail.id,
+                ...text('contactFirstName'),
+                ...text('contactLastName'),
+                ...text('contactEmail'),
+                ...text('contactPhone'),
+                ...text('demoAccountName'),
+                ...text('notes'),
+                demoAccountPasswordSet: typeof detail.attributes.demoAccountPassword === 'string'
+                    && detail.attributes.demoAccountPassword !== '',
+                demoAccountRequired: detail.attributes.demoAccountRequired === true,
+            };
+        },
+        async readPhasedRelease(versionId) {
+            const response = await optional(['versions', 'phased-release', 'view', '--version-id', versionId]);
+            if (response === undefined || isEmptyResource(response)) {
+                return undefined;
+            }
+            const phased = single(response, 'versions phased-release view');
+            return {
+                id: phased.id,
+                state: requiredString(phased.attributes.phasedReleaseState, 'phased release state'),
+                ...(typeof phased.attributes.currentDayNumber === 'number'
+                    ? { currentDayNumber: phased.attributes.currentDayNumber }
+                    : {}),
+                ...optionalString('startDate', phased.attributes.startDate),
+            };
+        },
+        async readAgeRating(appInfoId) {
+            const response = await optional(['age-rating', 'view', '--app-info-id', appInfoId]);
+            if (response === undefined || isEmptyResource(response)) {
+                return undefined;
+            }
+            const declaration = single(response, 'age-rating view');
+            return {
+                id: declaration.id,
+                answered: ageRatingDescriptors.filter((key) => {
+                    const value = declaration.attributes[key];
+                    return typeof value === 'boolean' || (typeof value === 'string' && value !== '');
+                }),
+            };
+        },
+        async listReviewSubmissions(appId) {
+            return list(await run(['review', 'submissions-list', '--app', appId, '--platform', 'IOS', '--paginate'], ascListTimeoutMs), 'review submissions-list').map((resource) => ({
+                id: resource.id,
+                state: requiredString(resource.attributes.state, 'review submission state'),
+                ...optionalString('submittedDate', resource.attributes.submittedDate),
+            }));
+        },
+        async listReviewSubmissionItems(submissionId) {
+            return list(await run([
+                'review', 'items-list',
+                '--submission', submissionId,
+                '--include', 'appStoreVersion,inAppPurchaseVersion',
+                '--paginate',
+            ], ascListTimeoutMs), 'review items-list').map((resource) => ({
+                id: resource.id,
+                ...optionalString('state', resource.attributes.state),
+                ...optionalString('appStoreVersionId', relationshipId(resource.relationships, 'appStoreVersion')),
+                ...optionalString('inAppPurchaseVersionId', relationshipId(resource.relationships, 'inAppPurchaseVersion')),
+            }));
+        },
+        async createVersion(input) {
+            const result = await run([
+                'versions', 'create',
+                '--app', input.appId,
+                '--version', input.versionString,
+                '--platform', 'IOS',
+                '--release-type', input.releaseType,
+                ...(input.copyright === undefined ? [] : ['--copyright', input.copyright]),
+            ], ascLookupTimeoutMs);
+            if (!isRecord(result) || typeof result.id !== 'string' || result.id === ''
+                || result.versionString !== input.versionString) {
+                throw new Error('asc versions create returned no version.');
+            }
+            return result.id;
+        },
+        async updateVersion(input) {
+            const flags = [
+                ...(input.versionString === undefined ? [] : ['--version', input.versionString]),
+                ...(input.copyright === undefined ? [] : ['--copyright', input.copyright]),
+                ...(input.releaseType === undefined ? [] : ['--release-type', input.releaseType]),
+                ...(input.earliestReleaseDate === undefined ? [] : ['--earliest-release-date', input.earliestReleaseDate]),
+            ];
+            if (flags.length === 0) {
+                return;
+            }
+            await run(['versions', 'update', '--version-id', input.versionId, ...flags], ascLookupTimeoutMs);
+        },
+        async attachBuild(input) {
+            const result = await run(['versions', 'attach-build', '--version-id', input.versionId, '--build-id', input.buildId], ascLookupTimeoutMs);
+            if (!isRecord(result) || result.attached !== true || result.buildId !== input.buildId) {
+                throw new Error('asc versions attach-build did not confirm the build.');
+            }
+        },
+        async createReviewDetail(input) {
+            await run(['review', 'details-create', '--version-id', input.versionId, ...reviewDetailFlags(input.fields)], ascLookupTimeoutMs);
+        },
+        async updateReviewDetail(input) {
+            const flags = reviewDetailFlags(input.fields);
+            if (flags.length === 0) {
+                return;
+            }
+            await run(['review', 'details-update', '--id', input.detailId, ...flags], ascLookupTimeoutMs);
+        },
+        async createPhasedRelease(versionId) {
+            await run(['versions', 'phased-release', 'create', '--version-id', versionId, '--state', 'INACTIVE'], ascLookupTimeoutMs);
+        },
+        async deletePhasedRelease(phasedReleaseId) {
+            await run(['versions', 'phased-release', 'delete', '--id', phasedReleaseId, '--confirm'], ascLookupTimeoutMs);
+        },
+        async updatePhasedRelease(input) {
+            await run([
+                'versions', 'phased-release', 'update',
+                '--id', input.phasedReleaseId,
+                '--state', input.state,
+                ...(input.state === 'COMPLETE' ? ['--confirm'] : []),
+            ], ascLookupTimeoutMs);
+        },
+        async createReviewSubmission(appId) {
+            return single(await run(['review', 'submissions-create', '--app', appId, '--platform', 'IOS'], ascLookupTimeoutMs), 'review submissions-create').id;
+        },
+        async addReviewSubmissionItem(input) {
+            await run([
+                'review', 'items-add',
+                '--submission', input.submissionId,
+                '--item-type', input.type,
+                '--item-id', input.id,
+            ], ascLookupTimeoutMs);
+        },
+        async submitReviewSubmission(submissionId) {
+            await run(['review', 'submissions-submit', '--id', submissionId, '--confirm'], ascLookupTimeoutMs);
+        },
+        async releaseVersion(versionId) {
+            const result = await run(['versions', 'release', '--version-id', versionId, '--confirm'], ascLookupTimeoutMs);
+            if (!isRecord(result) || result.versionId !== versionId || typeof result.releaseRequestId !== 'string') {
+                throw new Error('asc versions release returned no release request.');
+            }
+        },
+    };
+}
+const reviewDetailFlagNames = [
+    ['contactFirstName', '--contact-first-name'],
+    ['contactLastName', '--contact-last-name'],
+    ['contactEmail', '--contact-email'],
+    ['contactPhone', '--contact-phone'],
+    ['notes', '--notes'],
+    ['demoAccountName', '--demo-account-name'],
+    ['demoAccountPassword', '--demo-account-password'],
+];
+function reviewDetailFlags(fields) {
+    return [
+        ...reviewDetailFlagNames.flatMap(([field, flag]) => {
+            const value = fields[field];
+            return value === undefined ? [] : [flag, value];
+        }),
+        // A Go boolean flag takes its value only in the `--flag=value` form.
+        ...(fields.demoAccountRequired === undefined
+            ? []
+            : [`--demo-account-required=${String(fields.demoAccountRequired)}`]),
+    ];
+}

package/dist/app-store-release-command.d.ts

@@ -0,0 +1,73 @@
+import { type AscReleaseSession } from './app-store-release-asc.js';
+import { changeAppStorePhasedRelease, publishAppStoreVersion, type AppStoreReleaseApplyResult, type AppStoreReleasePlan, type AppStoreReleaseRequest, type AppStoreReleaseStatus } from './app-store-release.js';
+import type { AscCredential } from './asc-session.js';
+import { readNativeReleaseStatus } from './release-state.js';
+/**
+* `mpgd store release plan|apply|status|publish|phased`: the deployment
+* profile names the App Store Connect app and the asc credential (the same
+* ones `deploy submit` uses); `mpgd.store-presence.json` names What's New,
+* the copyright line and App Review information; `mpgd.targets.json` says
+* whether the app runs on iPad; the release ledger names the build
+* `deploy run` recorded.
+*/
+export interface AppStoreReleaseCommandPorts {
+  readonly appStore: (credential: AscCredential, options: {
+    readonly signal?: AbortSignal;
+    readonly secretValues?: readonly string[];
+  }) => Promise<AscReleaseSession>;
+  readonly readReleaseStatus: typeof readNativeReleaseStatus;
+  readonly now: () => Date;
+}
+export type ReleaseTypeOption = 'manual' | 'after-approval' | 'scheduled';
+export interface AppStoreReleasePlanOptions {
+  readonly game: string;
+  readonly profile: string;
+  readonly presenceFile?: string;
+  /** The marketing version; optional with `release`, whose recorded build names it. */
+  readonly version?: string;
+  readonly buildNumber?: string;
+  /** Release ledger game ID and release ID of the build `deploy run` recorded. */
+  readonly gameId?: string;
+  readonly release?: string;
+  readonly releaseType?: ReleaseTypeOption;
+  readonly releaseDate?: string;
+  readonly phasedRelease?: boolean;
+  readonly skipIaps?: readonly string[];
+  readonly rotateDemoPassword?: boolean;
+  readonly signal?: AbortSignal;
+}
+/** The saved plan: the inputs apply re-reads, and the reviewed plan. No secret is saved. */
+export interface AppStoreReleasePlanFile {
+  readonly schemaVersion: 1;
+  readonly kind: 'mpgd-store-release-plan';
+  readonly gameRoot: string;
+  readonly profile: string;
+  readonly presenceFile: string;
+  readonly request: AppStoreReleaseRequest;
+  readonly plan: AppStoreReleasePlan;
+}
+export declare function planAppStoreReleaseCommand(options: AppStoreReleasePlanOptions, environment?: NodeJS.ProcessEnv, overrides?: Partial<AppStoreReleaseCommandPorts>): Promise<AppStoreReleasePlanFile>;
+export declare function saveAppStoreReleasePlan(file: string, plan: AppStoreReleasePlanFile): string;
+export interface AppStoreReleaseApplyOptions {
+  readonly planFile: string;
+  /** Current game directory, when the game moved since the plan. */
+  readonly game?: string;
+  readonly approved: boolean;
+  readonly dryRun?: boolean;
+  readonly signal?: AbortSignal;
+}
+export declare function applyAppStoreReleaseCommand(options: AppStoreReleaseApplyOptions, environment?: NodeJS.ProcessEnv, overrides?: Partial<AppStoreReleaseCommandPorts>): Promise<AppStoreReleaseApplyResult>;
+export interface AppStoreReleaseVersionOptions {
+  readonly game: string;
+  readonly profile: string;
+  readonly version?: string;
+  readonly signal?: AbortSignal;
+}
+export declare function readAppStoreReleaseStatusCommand(options: AppStoreReleaseVersionOptions, environment?: NodeJS.ProcessEnv, overrides?: Partial<AppStoreReleaseCommandPorts>): Promise<AppStoreReleaseStatus>;
+export declare function publishAppStoreVersionCommand(options: AppStoreReleaseVersionOptions & {
+  readonly approved: boolean;
+}, environment?: NodeJS.ProcessEnv, overrides?: Partial<AppStoreReleaseCommandPorts>): Promise<Awaited<ReturnType<typeof publishAppStoreVersion>>>;
+export declare function changeAppStorePhasedReleaseCommand(options: AppStoreReleaseVersionOptions & {
+  readonly action: string;
+  readonly approved: boolean;
+}, environment?: NodeJS.ProcessEnv, overrides?: Partial<AppStoreReleaseCommandPorts>): Promise<Awaited<ReturnType<typeof changeAppStorePhasedRelease>>>;

package/dist/app-store-release-command.js

@@ -0,0 +1,280 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { openAscReleaseSession } from './app-store-release-asc.js';
+import { applyAppStoreRelease, appStoreReleasePlanCommand, changeAppStorePhasedRelease, planAppStoreRelease, publishAppStoreVersion, readAppStoreReleaseStatus, } from './app-store-release.js';
+import { readIosDeviceFamily } from './native-shell-store-policy.js';
+import { readNativeReleaseStatus } from './release-state.js';
+import { readStorePresenceSource } from './store-presence.js';
+import { readJsonFile, readStorePlanFile, relocateStoreSyncFile, resolveStoreSyncApp, StorePlanStaleError, writeStorePlanFile, } from './store-sync.js';
+const defaultPorts = {
+    appStore: openAscReleaseSession,
+    readReleaseStatus: readNativeReleaseStatus,
+    now: () => new Date(),
+};
+const releaseTypes = {
+    manual: 'MANUAL',
+    'after-approval': 'AFTER_APPROVAL',
+    scheduled: 'SCHEDULED',
+};
+export async function planAppStoreReleaseCommand(options, environment = process.env, overrides = {}) {
+    const ports = { ...defaultPorts, ...overrides };
+    const gameRoot = path.resolve(options.game);
+    const source = readPresence(gameRoot, options.presenceFile);
+    const request = await resolveRequest(options, gameRoot, environment, ports);
+    const plan = await withSession({ game: gameRoot, profile: options.profile }, source.presence, environment, ports, options.signal, (session, app, demo) => planAppStoreRelease({
+        appId: app.appId,
+        bundleId: app.bundleId,
+        presence: source.presence,
+        request,
+        ...(demo.account === undefined ? {} : { demoAccount: demo.account }),
+        demoAccountProblems: demo.problems,
+        now: ports.now,
+    }, session));
+    return {
+        schemaVersion: 1,
+        kind: 'mpgd-store-release-plan',
+        gameRoot,
+        profile: options.profile,
+        presenceFile: source.file,
+        request,
+        plan,
+    };
+}
+export function saveAppStoreReleasePlan(file, plan) {
+    return writeStorePlanFile(file, plan);
+}
+export async function applyAppStoreReleaseCommand(options, environment = process.env, overrides = {}) {
+    if (!options.approved && options.dryRun !== true) {
+        throw new Error('Submitting the App Store release requires --approve (or --dry-run to print it).');
+    }
+    const ports = { ...defaultPorts, ...overrides };
+    const saved = readSavedPlan(options.planFile);
+    const gameRoot = options.game === undefined ? saved.gameRoot : path.resolve(options.game);
+    const presenceFile = relocateStoreSyncFile(saved.gameRoot, options.game === undefined ? undefined : gameRoot, saved.presenceFile);
+    const source = readPresence(gameRoot, presenceFile);
+    // The universal flag comes from the game again: a changed target is a new plan.
+    const request = { ...saved.request, universal: readUniversal(gameRoot) };
+    return withSession({ game: gameRoot, profile: saved.profile }, source.presence, environment, ports, options.signal, (session, app, demo) => applyAppStoreRelease({
+        saved: saved.plan,
+        plan: {
+            appId: app.appId,
+            bundleId: app.bundleId,
+            presence: source.presence,
+            request,
+            ...(demo.account === undefined ? {} : { demoAccount: demo.account }),
+            demoAccountProblems: demo.problems,
+            now: ports.now,
+        },
+        ports: session,
+        approved: options.approved,
+        ...(options.dryRun === true ? { dryRun: true } : {}),
+    }));
+}
+export async function readAppStoreReleaseStatusCommand(options, environment = process.env, overrides = {}) {
+    const ports = { ...defaultPorts, ...overrides };
+    return withSession({ game: path.resolve(options.game), profile: options.profile }, undefined, environment, ports, options.signal, (session, app) => readAppStoreReleaseStatus({
+        appId: app.appId,
+        bundleId: app.bundleId,
+        ...(options.version === undefined ? {} : { marketingVersion: options.version }),
+    }, session.release));
+}
+export async function publishAppStoreVersionCommand(options, environment = process.env, overrides = {}) {
+    const marketingVersion = requireVersion(options.version);
+    if (!options.approved) {
+        throw new Error('Releasing the App Store version requires --approve.');
+    }
+    const ports = { ...defaultPorts, ...overrides };
+    return withSession({ game: path.resolve(options.game), profile: options.profile }, undefined, environment, ports, options.signal, (session, app) => publishAppStoreVersion({
+        appId: app.appId,
+        bundleId: app.bundleId,
+        marketingVersion,
+        approved: true,
+    }, session.release));
+}
+export async function changeAppStorePhasedReleaseCommand(options, environment = process.env, overrides = {}) {
+    const marketingVersion = requireVersion(options.version);
+    if (!['pause', 'resume', 'complete'].includes(options.action)) {
+        throw new Error('--action must be pause, resume or complete.');
+    }
+    if (!options.approved) {
+        throw new Error('Changing the phased release requires --approve.');
+    }
+    const ports = { ...defaultPorts, ...overrides };
+    return withSession({ game: path.resolve(options.game), profile: options.profile }, undefined, environment, ports, options.signal, (session, app) => changeAppStorePhasedRelease({
+        appId: app.appId,
+        bundleId: app.bundleId,
+        marketingVersion,
+        action: options.action,
+        approved: true,
+    }, session.release));
+}
+function requireVersion(version) {
+    if (version === undefined || version === '') {
+        throw new Error('--marketing-version is required.');
+    }
+    return version;
+}
+function readPresence(gameRoot, presenceFile) {
+    const source = readStorePresenceSource({
+        gameRoot,
+        ...(presenceFile === undefined ? {} : { presenceFile }),
+    });
+    if (source.presence.appStore === undefined) {
+        throw new Error(`${source.file} has no appStore section.`);
+    }
+    return source;
+}
+/**
+ * Whether the app runs on iPad: `mpgd.targets.json` ios `metadata.iosDeviceFamily`.
+ * Unset counts as universal, the device family of the Capacitor iOS template.
+ */
+function readUniversal(gameRoot) {
+    const file = path.join(gameRoot, 'mpgd.targets.json');
+    if (!existsSync(file)) {
+        return true;
+    }
+    const targets = readJsonFile(file);
+    const ios = isRecord(targets) && isRecord(targets.targets) ? targets.targets.ios : undefined;
+    return readIosDeviceFamily(isRecord(ios) ? ios.metadata : undefined) !== 'iphone';
+}
+async function resolveRequest(options, gameRoot, environment, ports) {
+    let marketingVersion = options.version;
+    let buildNumber = options.buildNumber;
+    let recordedBuildId;
+    if ((options.gameId === undefined) !== (options.release === undefined)) {
+        throw new Error('--game-id and --release go together.');
+    }
+    if (options.gameId !== undefined && options.release !== undefined) {
+        const status = await ports.readReleaseStatus({
+            gameRoot,
+            gameId: options.gameId,
+            releaseKey: options.release,
+            environment,
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+        });
+        const record = status.builds.ios;
+        if (record === undefined) {
+            throw new Error(`Release ${options.release} has no recorded iOS build.`);
+        }
+        const recordedVersion = record.platformVersion.marketingVersion;
+        const recordedBuild = record.platformVersion.buildNumber;
+        if (typeof recordedVersion !== 'string' || (typeof recordedBuild !== 'string' && typeof recordedBuild !== 'number')) {
+            throw new Error(`Release ${options.release} recorded no iOS marketing version and build number.`);
+        }
+        if (marketingVersion !== undefined && marketingVersion !== recordedVersion) {
+            throw new Error(`--marketing-version ${marketingVersion} differs from ${recordedVersion} that release ${options.release} built.`);
+        }
+        if (buildNumber !== undefined && buildNumber !== String(recordedBuild)) {
+            throw new Error(`--build-number ${buildNumber} differs from ${String(recordedBuild)} that release ${options.release} built.`);
+        }
+        marketingVersion = recordedVersion;
+        buildNumber = String(recordedBuild);
+        recordedBuildId = status.submissions.ios?.remoteBuildId;
+        if (recordedBuildId === undefined) {
+            throw new Error(`Release ${options.release} recorded no App Store Connect build ID for its iOS build (the TestFlight `
+                + `submission is ${status.submissions.ios?.status ?? 'missing'}): finish it with "mpgd deploy submit", or `
+                + 'name the build with --marketing-version and --build-number.');
+        }
+    }
+    if (marketingVersion === undefined) {
+        throw new Error('Name the version with --marketing-version, or the recorded build with --game-id and --release.');
+    }
+    const releaseType = options.releaseType ?? 'manual';
+    if (!(releaseType in releaseTypes)) {
+        throw new Error('--release-type must be manual, after-approval or scheduled.');
+    }
+    return {
+        marketingVersion,
+        ...(buildNumber === undefined ? {} : { buildNumber }),
+        ...(recordedBuildId === undefined ? {} : { recordedBuildId }),
+        universal: readUniversal(gameRoot),
+        releaseType: releaseTypes[releaseType],
+        ...(options.releaseDate === undefined ? {} : { earliestReleaseDate: options.releaseDate }),
+        phasedRelease: options.phasedRelease === true,
+        skipIaps: [...new Set(options.skipIaps ?? [])].sort(),
+        rotateDemoPassword: options.rotateDemoPassword === true,
+    };
+}
+/**
+ * The demo account values from the variables the presence file names. A
+ * variable that is unset or unusable is a problem the plan reports as a
+ * blocker, so a plan can be reviewed without the secrets.
+ */
+function readDemoAccount(presence, environment) {
+    const names = presence?.appStore?.review?.demoAccount;
+    if (names === undefined) {
+        return { problems: [] };
+    }
+    const problems = [];
+    const read = (name) => {
+        const value = environment[name];
+        if (value === undefined || value.trim() === '') {
+            problems.push(`appStore.review.demoAccount names ${name}, which is not set: export the demo account there, then plan again.`);
+            return undefined;
+        }
+        // asc trims the flag values it sends, so a value with surrounding spaces would
+        // reach App Review as another password: refuse it instead of changing it.
+        if (value.trim() !== value) {
+            problems.push(`${name} starts or ends with whitespace, which asc would strip before sending it to App Store Connect.`);
+            return undefined;
+        }
+        return value;
+    };
+    const name = read(names.nameEnv);
+    const password = read(names.passwordEnv);
+    if (password !== undefined && [...password].length > 100) {
+        problems.push(`${names.passwordEnv} is longer than the 100 characters App Store Connect takes.`);
+    }
+    return name === undefined || password === undefined || problems.length > 0
+        ? { problems }
+        : { account: { name, password }, problems };
+}
+/** One asc session per command, with the demo account redacted from its output. */
+async function withSession(options, presence, environment, ports, signal, action) {
+    const demo = readDemoAccount(presence, environment);
+    const demoAccount = demo.account;
+    const app = resolveStoreSyncApp({ ...options, store: 'app-store' }, environment);
+    if (app.store !== 'app-store') {
+        throw new Error('The deployment profile has no App Store app.');
+    }
+    const session = await ports.appStore(app.credential, {
+        ...(signal === undefined ? {} : { signal }),
+        secretValues: demoAccount === undefined
+            ? []
+            // The password always; the user name only when long enough not to mangle unrelated text.
+            : [...secretForms(demoAccount.password), ...(demoAccount.name.length >= 4 ? secretForms(demoAccount.name) : [])],
+    });
+    try {
+        return await action(session, { appId: app.appId, bundleId: app.bundleId }, demo);
+    }
+    finally {
+        session.close();
+    }
+}
+/** A secret as given and as JSON escapes it, so asc's JSON error output is redacted too. */
+function secretForms(value) {
+    return [...new Set([value, JSON.stringify(value).slice(1, -1)])];
+}
+function readSavedPlan(file) {
+    const raw = readStorePlanFile(file, 'store release plan');
+    const plan = raw.plan;
+    const request = raw.request;
+    if (raw.schemaVersion !== 1 || raw.kind !== 'mpgd-store-release-plan'
+        || typeof raw.gameRoot !== 'string' || !path.isAbsolute(raw.gameRoot)
+        || typeof raw.profile !== 'string' || typeof raw.presenceFile !== 'string'
+        || typeof request !== 'object' || request === null || typeof request.marketingVersion !== 'string'
+        || typeof request.releaseType !== 'string' || !Array.isArray(request.skipIaps)
+        || typeof plan !== 'object' || plan === null || plan.schemaVersion !== 1 || plan.store !== 'app-store'
+        || typeof plan.appId !== 'string' || typeof plan.bundleId !== 'string'
+        || typeof plan.remoteSha256 !== 'string' || typeof plan.desiredSha256 !== 'string'
+        || !Array.isArray(plan.operations) || !Array.isArray(plan.blockers)) {
+        throw new Error('Saved store release plan is malformed.');
+    }
+    if (plan.marketingVersion !== request.marketingVersion) {
+        throw new StorePlanStaleError('The saved plan does not match its request.', appStoreReleasePlanCommand);
+    }
+    return raw;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}