@mpgd/cli 0.62.0 → 0.63.0

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

@@ -0,0 +1,23 @@
+import type { AscIapPort } from './app-store-iap-port.js';
+/**
+* The in-app purchase port on the pinned `asc` 5.5.0 CLI, with the same
+* binary pin, isolated environment and API key as the TestFlight
+* submission. Each method is one `asc ... --output json` command; the JSON
+* is App Store Connect's own resource document, which `asc` prints as it
+* received it (`internal/asc/types/resources.go` at the 5.5.0 tag).
+*/
+/** Runs one asc command with `--output json` appended and returns the parsed JSON. */
+export type AscCommandRunner = (args: readonly string[], timeoutMs: number) => Promise<unknown>;
+export interface AscCredential {
+  readonly ascBinary: string;
+  readonly apiKeyId: string;
+  readonly apiIssuerId: string;
+  readonly apiPrivateKeyBase64: string;
+}
+/** Copy and verify the pinned binary into a private directory; `close` removes it. */
+export declare function openAscIapSession(credential: AscCredential, signal?: AbortSignal): Promise<{
+  readonly port: AscIapPort;
+  close(): void;
+}>;
+/** The port over any runner; the tests drive it with recorded asc output. */
+export declare function createAscIapPort(run: AscCommandRunner, today?: () => string): AscIapPort;

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

@@ -0,0 +1,326 @@
+import { chmodSync, copyFileSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { ReleaseProcessError, runReleaseProcess } from './deploy-process.js';
+import { sameDecimal } from './store-products.js';
+import { isolatedAscEnvironment, verifyPinnedAscBinary } from './testflight-submission.js';
+const lookupTimeoutMs = 60_000;
+const listTimeoutMs = 3 * 60_000;
+const uploadTimeoutMs = 10 * 60_000;
+const maxJsonBytes = 8 * 1024 * 1024;
+/** asc exit code for an App Store Connect 404 (`cmd/exit_codes.go`, 5.5.0). */
+const ascExitNotFound = 4;
+/** Copy and verify the pinned binary into a private directory; `close` removes it. */
+export async function openAscIapSession(credential, signal) {
+    if (!path.isAbsolute(credential.ascBinary)) {
+        throw new Error('asc binary must be an absolute file path.');
+    }
+    const tempRoot = mkdtempSync(path.join(tmpdir(), 'mpgd-asc-iap-'));
+    try {
+        const binary = path.join(tempRoot, 'asc');
+        copyFileSync(credential.ascBinary, binary);
+        chmodSync(binary, 0o700);
+        await verifyPinnedAscBinary(binary);
+        const environment = isolatedAscEnvironment(credential, tempRoot);
+        const run = async (args, timeoutMs) => {
+            const result = await runReleaseProcess({
+                command: binary,
+                args: [...args, '--output', 'json'],
+                cwd: tempRoot,
+                environment,
+                timeoutMs,
+                maxOutputBytes: maxJsonBytes,
+                captureMachineStdout: true,
+                secretValues: [credential.apiKeyId, credential.apiIssuerId, credential.apiPrivateKeyBase64],
+                signal,
+            });
+            if (result.truncated || result.machineStdout === undefined) {
+                throw new Error('asc JSON output was truncated or unavailable.');
+            }
+            try {
+                return JSON.parse(result.machineStdout);
+            }
+            catch {
+                throw new Error('asc returned invalid JSON.');
+            }
+        };
+        return {
+            port: createAscIapPort(run),
+            close: () => rmSync(tempRoot, { recursive: true, force: true }),
+        };
+    }
+    catch (error) {
+        rmSync(tempRoot, { recursive: true, force: true });
+        throw error;
+    }
+}
+/** The port over any runner; the tests drive it with recorded asc output. */
+export function createAscIapPort(run, today = () => new Date().toISOString().slice(0, 10)) {
+    const optional = async (args) => {
+        try {
+            return await run(args, lookupTimeoutMs);
+        }
+        catch (error) {
+            if (error instanceof ReleaseProcessError && error.exitCode === ascExitNotFound) {
+                return undefined;
+            }
+            throw error;
+        }
+    };
+    return {
+        async readAppBundleId(appId) {
+            const app = single(await run(['apps', 'view', '--id', appId], lookupTimeoutMs), 'apps view');
+            const bundleId = app.attributes.bundleId;
+            if (app.id !== appId || typeof bundleId !== 'string') {
+                throw new Error('asc apps view returned no bundle ID for the app.');
+            }
+            return bundleId;
+        },
+        async listIaps(appId) {
+            return list(await run(['iap', 'list', '--app', appId, '--paginate'], listTimeoutMs), 'iap list')
+                .map((resource) => ({
+                id: resource.id,
+                productId: requiredString(resource.attributes.productId, 'iap list productId'),
+                name: requiredString(resource.attributes.name, 'iap list name'),
+                inAppPurchaseType: requiredString(resource.attributes.inAppPurchaseType, 'iap list type'),
+                ...optionalString('state', resource.attributes.state),
+                ...optionalString('reviewNote', resource.attributes.reviewNote),
+                ...(resource.attributes.familySharable === true ? { familySharable: true } : {}),
+            }));
+        },
+        async listVersions(iapId) {
+            return list(await run(['iap', 'versions', 'list', '--iap-id', iapId, '--paginate'], listTimeoutMs), 'iap versions list').map((resource) => ({
+                id: resource.id,
+                ...(typeof resource.attributes.version === 'number' ? { version: resource.attributes.version } : {}),
+                ...optionalString('state', resource.attributes.state),
+            }));
+        },
+        async listLocalizations(versionId) {
+            return list(await run(['iap', 'versions', 'localizations', 'list', '--version-id', versionId, '--paginate'], listTimeoutMs), 'iap versions localizations list').map((resource) => ({
+                id: resource.id,
+                locale: requiredString(resource.attributes.locale, 'localization locale'),
+                name: requiredString(resource.attributes.name, 'localization name'),
+                ...optionalString('description', resource.attributes.description),
+            }));
+        },
+        async readPriceSchedule(iapId) {
+            const response = await optional(['iap', 'pricing', 'schedules', 'view', '--iap-id', iapId, '--include', 'baseTerritory']);
+            // No schedule: asc exits 4 (not found), or App Store Connect answers with no resource.
+            if (response === undefined || isEmptyResource(response)) {
+                return undefined;
+            }
+            const schedule = single(response, 'iap pricing schedules view');
+            const baseTerritory = relationshipId(schedule.relationships, 'baseTerritory');
+            const resolved = await run(['iap', 'pricing', 'schedules', 'manual-prices', '--schedule-id', schedule.id, '--resolved'], listTimeoutMs);
+            if (!isRecord(resolved) || !Array.isArray(resolved.prices)) {
+                throw new Error('asc iap pricing schedules manual-prices returned no prices.');
+            }
+            const manualPrices = resolved.prices.flatMap((row) => isRecord(row) && row.manual === true && typeof row.territory === 'string'
+                && typeof row.customerPrice === 'string'
+                ? [{ territory: row.territory, customerPrice: row.customerPrice }]
+                : []);
+            if (baseTerritory === undefined && manualPrices.length === 0) {
+                return undefined;
+            }
+            // `--resolved` lists only prices in effect; the raw list also holds future ones.
+            const all = list(await run(['iap', 'pricing', 'schedules', 'manual-prices', '--schedule-id', schedule.id, '--paginate'], listTimeoutMs), 'iap pricing schedules manual-prices');
+            const now = today();
+            // A future start or a future end (a temporary price expiring) is a
+            // transition a new open-ended schedule would remove.
+            const upcoming = (value) => typeof value === 'string' && value.slice(0, 10) > now;
+            const scheduledChanges = all.filter((price) => upcoming(price.attributes.startDate) || upcoming(price.attributes.endDate)).length;
+            return {
+                id: schedule.id,
+                ...(baseTerritory === undefined ? {} : { baseTerritory }),
+                manualPrices,
+                scheduledChanges,
+            };
+        },
+        async readAvailability(iapId) {
+            let response;
+            try {
+                response = await run(['iap', 'pricing', 'availability', 'view', '--iap-id', iapId], lookupTimeoutMs);
+            }
+            catch (error) {
+                // asc 5.5.0 reports an unset availability as an error naming it (availability.go).
+                if (error instanceof ReleaseProcessError
+                    && (error.exitCode === ascExitNotFound || error.output.includes('has no availability configured'))) {
+                    return undefined;
+                }
+                throw error;
+            }
+            if (isEmptyResource(response)) {
+                return undefined;
+            }
+            const availability = single(response, 'iap pricing availability view');
+            const territories = list(await run(['iap', 'pricing', 'availabilities', 'available-territories', '--id', availability.id, '--paginate'], listTimeoutMs), 'iap pricing availabilities available-territories').map((territory) => territory.id);
+            return {
+                id: availability.id,
+                availableInNewTerritories: availability.attributes.availableInNewTerritories === true,
+                territories,
+            };
+        },
+        async readReviewScreenshot(iapId) {
+            const response = await optional(['iap', 'review-screenshots', 'view', '--iap-id', iapId]);
+            if (!isRecord(response) || !isRecord(response.data) || typeof response.data.id !== 'string'
+                || response.data.id === '') {
+                return undefined;
+            }
+            const attributes = isRecord(response.data.attributes) ? response.data.attributes : {};
+            return {
+                id: response.data.id,
+                ...optionalString('fileName', attributes.fileName),
+                ...(typeof attributes.fileSize === 'number' ? { fileSize: attributes.fileSize } : {}),
+                ...optionalString('sourceFileChecksum', attributes.sourceFileChecksum),
+                ...optionalString('deliveryState', isRecord(attributes.assetDeliveryState) ? attributes.assetDeliveryState.state : undefined),
+            };
+        },
+        async listTerritories() {
+            const territories = list(await run(['pricing', 'territories', 'list', '--paginate'], listTimeoutMs), 'pricing territories list').map((resource) => resource.id);
+            if (territories.length === 0) {
+                throw new Error('asc pricing territories list returned no territories.');
+            }
+            return territories;
+        },
+        async createIap(input) {
+            const created = single(await run([
+                'iap', 'create',
+                '--app', input.appId,
+                '--type', input.type,
+                '--ref-name', input.referenceName,
+                '--product-id', input.productId,
+                ...(input.familySharable ? ['--family-sharable'] : []),
+            ], lookupTimeoutMs), 'iap create');
+            return created.id;
+        },
+        async updateIap(input) {
+            await run([
+                'iap', 'update',
+                '--id', input.iapId,
+                ...(input.referenceName === undefined ? [] : ['--ref-name', input.referenceName]),
+                ...(input.familySharable === true ? ['--family-sharable'] : []),
+            ], lookupTimeoutMs);
+        },
+        async createVersion(iapId) {
+            return single(await run(['iap', 'versions', 'create', '--iap-id', iapId], lookupTimeoutMs), 'iap versions create').id;
+        },
+        async createLocalization(input) {
+            await run([
+                'iap', 'versions', 'localizations', 'create',
+                '--version-id', input.versionId,
+                '--locale', input.locale,
+                '--name', input.name,
+                '--description', input.description,
+            ], lookupTimeoutMs);
+        },
+        async updateLocalization(input) {
+            await run([
+                'iap', 'versions', 'localizations', 'update',
+                '--localization-id', input.localizationId,
+                '--name', input.name,
+                '--description', input.description,
+            ], lookupTimeoutMs);
+        },
+        async findPricePoint(input) {
+            const points = list(await run([
+                'iap', 'pricing', 'price-points', 'list',
+                '--iap-id', input.iapId,
+                '--territory', input.territory,
+                '--price', input.customerPrice,
+                '--paginate',
+            ], listTimeoutMs), 'iap pricing price-points list').filter((point) => typeof point.attributes.customerPrice === 'string'
+                && sameDecimal(point.attributes.customerPrice, input.customerPrice));
+            const [point] = points;
+            if (points.length !== 1 || point === undefined) {
+                throw new Error(`App Store Connect has ${points.length} price points of ${input.customerPrice} in ${input.territory}; `
+                    + 'use a price that is an App Store price point there.');
+            }
+            return point.id;
+        },
+        async createPriceSchedule(input) {
+            await run([
+                'iap', 'pricing', 'schedules', 'create',
+                '--iap-id', input.iapId,
+                '--base-territory', input.baseTerritory,
+                '--prices', input.pricePointIds.join(','),
+            ], lookupTimeoutMs);
+        },
+        async setAvailability(input) {
+            await run([
+                'iap', 'pricing', 'availability', 'set',
+                '--iap-id', input.iapId,
+                '--territories', input.territories.join(','),
+                ...(input.availableInNewTerritories ? ['--available-in-new-territories'] : []),
+            ], lookupTimeoutMs);
+        },
+        async deleteReviewScreenshot(screenshotId) {
+            await run(['iap', 'review-screenshots', 'delete', '--screenshot-id', screenshotId, '--confirm'], lookupTimeoutMs);
+        },
+        async uploadReviewScreenshot(input) {
+            await run(['iap', 'review-screenshots', 'create', '--iap-id', input.iapId, '--file', input.file], uploadTimeoutMs);
+        },
+    };
+}
+function single(value, command) {
+    const resource = isRecord(value) ? toResource(value.data) : undefined;
+    if (resource === undefined) {
+        throw new Error(`asc ${command} returned no resource.`);
+    }
+    return resource;
+}
+function list(value, command) {
+    const resources = isRecord(value) && Array.isArray(value.data)
+        ? value.data.map(toResource)
+        : undefined;
+    if (resources === undefined || resources.some((resource) => resource === undefined)) {
+        throw new Error(`asc ${command} returned no resource list.`);
+    }
+    return resources;
+}
+function toResource(value) {
+    if (!isRecord(value) || typeof value.id !== 'string' || value.id === '') {
+        return undefined;
+    }
+    return {
+        id: value.id,
+        attributes: isRecord(value.attributes) ? value.attributes : {},
+        ...(value.relationships === undefined ? {} : { relationships: value.relationships }),
+    };
+}
+/**
+ * App Store Connect's `data: null`, or asc's rendering of it: asc 5.5.0
+ * decodes into a non-pointer resource and prints `{ "type": "", "id": "" }`.
+ */
+function isEmptyResource(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return value.data === null
+        || (isRecord(value.data) && (value.data.id === undefined || value.data.id === ''));
+}
+function relationshipId(relationships, name) {
+    if (!isRecord(relationships)) {
+        return undefined;
+    }
+    const relationship = relationships[name];
+    if (!isRecord(relationship) || !isRecord(relationship.data)) {
+        return undefined;
+    }
+    return typeof relationship.data.id === 'string' ? relationship.data.id : undefined;
+}
+function requiredString(value, label) {
+    if (typeof value !== 'string') {
+        throw new Error(`asc output has no ${label}.`);
+    }
+    return value;
+}
+function optionalString(key, value) {
+    const result = {};
+    if (typeof value === 'string' && value !== '') {
+        result[key] = value;
+    }
+    return result;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/app-store-iap-port.d.ts

@@ -0,0 +1,125 @@
+/**
+* App Store Connect in-app purchase port. The kit drives App Store Connect
+* through the pinned `asc` CLI (docs/NATIVE_DEPLOY_TOOLING_DECISION.md);
+* `app-store-iap-asc.ts` implements this port with it, and the planner and
+* tests see only these shapes.
+*
+* Resources (App Store Connect API 4.4.1):
+* - In-app purchases v2: https://developer.apple.com/documentation/appstoreconnectapi/in-app-purchases
+* - Versions and their localizations: https://developer.apple.com/documentation/appstoreconnectapi/in-app-purchase-versions
+* - Price schedules: https://developer.apple.com/documentation/appstoreconnectapi/post-v1-inapppurchasepriceschedules
+* - Availability: https://developer.apple.com/documentation/appstoreconnectapi/post-v1-inapppurchaseavailabilities
+* - Review screenshot: https://developer.apple.com/documentation/appstoreconnectapi/post-v1-inapppurchaseappstorereviewscreenshots
+*/
+export type AscIapType = 'CONSUMABLE' | 'NON_CONSUMABLE';
+export interface AscIap {
+  readonly id: string;
+  readonly productId: string;
+  /** Reference name. */
+  readonly name: string;
+  readonly inAppPurchaseType: string;
+  /** `InAppPurchaseState`, for example `MISSING_METADATA` or `APPROVED`. */
+  readonly state?: string | undefined;
+  readonly familySharable?: boolean | undefined;
+  readonly reviewNote?: string | undefined;
+}
+export interface AscIapVersion {
+  readonly id: string;
+  readonly version?: number | undefined;
+  /** `PREPARE_FOR_SUBMISSION`, `READY_FOR_REVIEW`, `WAITING_FOR_REVIEW`, `APPROVED`, ... */
+  readonly state?: string | undefined;
+}
+export interface AscIapLocalization {
+  readonly id: string;
+  readonly locale: string;
+  readonly name: string;
+  readonly description?: string | undefined;
+}
+/** The current price schedule: base territory and the manual prices in effect. */
+export interface AscIapPriceSchedule {
+  readonly id: string;
+  readonly baseTerritory?: string | undefined;
+  /** Manual (not equalized) prices in effect now, per alpha-3 territory. */
+  readonly manualPrices: readonly {
+    readonly territory: string;
+    readonly customerPrice: string;
+  }[];
+  /** Manual prices that start in the future; a new schedule would drop them. */
+  readonly scheduledChanges: number;
+}
+export interface AscIapAvailability {
+  readonly id: string;
+  readonly availableInNewTerritories: boolean;
+  /** Alpha-3 territories the in-app purchase is sold in. */
+  readonly territories: readonly string[];
+}
+export interface AscIapReviewScreenshot {
+  readonly id: string;
+  readonly fileName?: string | undefined;
+  readonly fileSize?: number | undefined;
+  /** MD5 of the uploaded file, as App Store Connect records it. */
+  readonly sourceFileChecksum?: string | undefined;
+  /** `assetDeliveryState.state`: `AWAITING_UPLOAD`, `UPLOAD_COMPLETE`, `COMPLETE` or `FAILED`. */
+  readonly deliveryState?: string | undefined;
+}
+export interface AscIapPort {
+  /** The app record's bundle ID (`apps view`). */
+  readAppBundleId(appId: string): Promise<string>;
+  listIaps(appId: string): Promise<AscIap[]>;
+  listVersions(iapId: string): Promise<AscIapVersion[]>;
+  listLocalizations(versionId: string): Promise<AscIapLocalization[]>;
+  /** `undefined` when the in-app purchase has no price schedule yet. */
+  readPriceSchedule(iapId: string): Promise<AscIapPriceSchedule | undefined>;
+  /** `undefined` when no availability was set. */
+  readAvailability(iapId: string): Promise<AscIapAvailability | undefined>;
+  /** `undefined` when no review screenshot was uploaded. */
+  readReviewScreenshot(iapId: string): Promise<AscIapReviewScreenshot | undefined>;
+  /** Every App Store territory (alpha-3). */
+  listTerritories(): Promise<string[]>;
+  createIap(input: {
+    readonly appId: string;
+    readonly type: AscIapType;
+    readonly referenceName: string;
+    readonly productId: string;
+    readonly familySharable: boolean;
+  }): Promise<string>;
+  updateIap(input: {
+    readonly iapId: string;
+    readonly referenceName?: string;
+    readonly familySharable?: true;
+  }): Promise<void>;
+  createVersion(iapId: string): Promise<string>;
+  createLocalization(input: {
+    readonly versionId: string;
+    readonly locale: string;
+    readonly name: string;
+    readonly description: string;
+  }): Promise<void>;
+  updateLocalization(input: {
+    readonly localizationId: string;
+    readonly name: string;
+    readonly description: string;
+  }): Promise<void>;
+  /** The price point of `customerPrice` in `territory`; throws unless exactly one matches. */
+  findPricePoint(input: {
+    readonly iapId: string;
+    readonly territory: string;
+    readonly customerPrice: string;
+  }): Promise<string>;
+  /** A new schedule effective now: the base territory's and the manual prices. */
+  createPriceSchedule(input: {
+    readonly iapId: string;
+    readonly baseTerritory: string;
+    readonly pricePointIds: readonly string[];
+  }): Promise<void>;
+  setAvailability(input: {
+    readonly iapId: string;
+    readonly territories: readonly string[];
+    readonly availableInNewTerritories: boolean;
+  }): Promise<void>;
+  deleteReviewScreenshot(screenshotId: string): Promise<void>;
+  uploadReviewScreenshot(input: {
+    readonly iapId: string;
+    readonly file: string;
+  }): Promise<void>;
+}

package/dist/app-store-iap-port.js

@@ -0,0 +1,14 @@
+/**
+ * App Store Connect in-app purchase port. The kit drives App Store Connect
+ * through the pinned `asc` CLI (docs/NATIVE_DEPLOY_TOOLING_DECISION.md);
+ * `app-store-iap-asc.ts` implements this port with it, and the planner and
+ * tests see only these shapes.
+ *
+ * Resources (App Store Connect API 4.4.1):
+ * - In-app purchases v2: https://developer.apple.com/documentation/appstoreconnectapi/in-app-purchases
+ * - Versions and their localizations: https://developer.apple.com/documentation/appstoreconnectapi/in-app-purchase-versions
+ * - Price schedules: https://developer.apple.com/documentation/appstoreconnectapi/post-v1-inapppurchasepriceschedules
+ * - Availability: https://developer.apple.com/documentation/appstoreconnectapi/post-v1-inapppurchaseavailabilities
+ * - Review screenshot: https://developer.apple.com/documentation/appstoreconnectapi/post-v1-inapppurchaseappstorereviewscreenshots
+ */
+export {};

package/dist/index.d.ts

@@ -9,6 +9,10 @@ export { runNativeDeployment, readStoreCredential, type RunNativeDeploymentInput
 export { planRecordedAndroidSubmission, submitRecordedNativeTarget, type NativeStoreCredential, type SubmitRecordedNativeTargetInput, } from './native-deploy-submission.js';
 export { PlaySubmissionUncertainError, planVerifiedAndroidBundleSubmission, submitVerifiedAndroidBundle, type PlayInternalSubmissionInput, type PlayInternalSubmissionResult, type PlaySubmissionPlan, } from './play-internal-submission.js';
 export { createPlayReleaseRequest, defaultPlayReleaseRequest, maximumPlayReleaseNoteCharacters, parsePlayReleaseNotes, type CreatePlayReleaseRequestInput, type PlayNewReleaseStatus, type PlayReleaseNote, type PlayReleaseRequest, type PlayReleaseStatus, } from './play-release-options.js';
+export { applyStoreProducts, planStoreProducts, saveStoreProductPlan, type StoreProductApplyOptions, type StoreProductPlanFile, type StoreProductPlanOptions, type StoreProductPorts, type StoreProductStore, } from './store-products-command.js';
+export { applyPlayProductPlan, formatPlayProductPlan, planPlayProducts, PlayProductApplyError, type PlannedPlayProduct, type PlayProductApplyResult, type PlayProductChange, type PlayProductPlan, type PlayProductPlanInput, } from './store-products-play.js';
+export { AppStoreProductApplyError, applyAppStoreProductPlan, formatAppStoreProductPlan, planAppStoreProducts, type AppStoreProductApplyResult, type AppStoreProductChange, type AppStoreProductPlan, type AppStoreProductPlanInput, type PlannedAppStoreProduct, } from './store-products-app-store.js';
+export { StoreProductPlanStaleError } from './store-products.js';
 export { PlayPromoteUncertainError, promotePlayRelease, type PlayPromoteInput, type PlayPromoteResult, } from './play-release-promote.js';
 export { PlayRolloutUncertainError, changePlayRollout, type PlayRolloutAction, type PlayRolloutInput, type PlayRolloutResult, } from './play-release-rollout.js';
 export { IosSubmissionUncertainError, submitVerifiedIosBuild, type IosTestFlightStatus, type IosTestFlightSubmissionInput, type IosTestFlightSubmissionResult, } from './testflight-submission.js';

package/dist/index.js

@@ -36,6 +36,9 @@ import { readStoreCredential, runNativeDeployment } from './native-deploy-run.js
 import { isNativeDeployApproved, planRecordedAndroidSubmission, submitRecordedNativeTarget, } from './native-deploy-submission.js';
 import { createPlayReleaseRequest, parsePlayUserFraction, readPlayReleaseNotesFile, } from './play-release-options.js';
 import { promotePlayRelease } from './play-release-promote.js';
+import { applyStoreProducts, planStoreProducts, saveStoreProductPlan, } from './store-products-command.js';
+import { formatAppStoreProductPlan } from './store-products-app-store.js';
+import { formatPlayProductPlan } from './store-products-play.js';
 import { changePlayRollout } from './play-release-rollout.js';
 import { readNativeReleaseStatus as readNativeReleaseStatusForCli } from './release-state.js';
 import { uploadRecordedCrashSymbols } from './crash-symbols-upload.js';
@@ -50,6 +53,10 @@ export { runNativeDeployment, readStoreCredential, } from './native-deploy-run.j
 export { planRecordedAndroidSubmission, submitRecordedNativeTarget, } from './native-deploy-submission.js';
 export { PlaySubmissionUncertainError, planVerifiedAndroidBundleSubmission, submitVerifiedAndroidBundle, } from './play-internal-submission.js';
 export { createPlayReleaseRequest, defaultPlayReleaseRequest, maximumPlayReleaseNoteCharacters, parsePlayReleaseNotes, } from './play-release-options.js';
+export { applyStoreProducts, planStoreProducts, saveStoreProductPlan, } from './store-products-command.js';
+export { applyPlayProductPlan, formatPlayProductPlan, planPlayProducts, PlayProductApplyError, } from './store-products-play.js';
+export { AppStoreProductApplyError, applyAppStoreProductPlan, formatAppStoreProductPlan, planAppStoreProducts, } from './store-products-app-store.js';
+export { StoreProductPlanStaleError } from './store-products.js';
 export { PlayPromoteUncertainError, promotePlayRelease, } from './play-release-promote.js';
 export { PlayRolloutUncertainError, changePlayRollout, } from './play-release-rollout.js';
 export { IosSubmissionUncertainError, submitVerifiedIosBuild, } from './testflight-submission.js';
@@ -210,6 +217,7 @@ export async function runMpgdCli(args) {
             assets: assetsCommand,
             game: gameCommand,
             deploy: deployCommand,
+            store: storeCommand,
             legal: legalCommand,
             target: targetCommand,
             kit: kitCommand,
@@ -262,7 +270,7 @@ const entryCommand = defineI18n({
         ko: 'mpgd-kit 스타터와 타깃 워크플로우를 관리합니다.',
     }),
     run: () => {
-        console.info('Use a sub-command: assets, game, deploy, legal, target, kit.');
+        console.info('Use a sub-command: assets, game, deploy, store, legal, target, kit.');
         console.info('Run "pnpm mpgd --help" for available commands.');
     },
 });
@@ -743,6 +751,92 @@ const deployCommand = defineI18n({
         }),
     },
 });
+const storeCommand = defineI18n({
+    name: 'store',
+    description: 'Sync store-side configuration from game files.',
+    resource: commandResource({
+        en: 'Sync store-side configuration from game files.',
+        ko: '게임 파일에서 스토어 쪽 설정을 동기화합니다.',
+    }),
+    subCommands: {
+        products: defineI18n({
+            name: 'products',
+            description: 'Plan and apply one-time products from the catalog and store listing file.',
+            resource: commandResource({
+                en: 'Plan and apply one-time products from the catalog and store listing file.',
+                ko: '카탈로그와 스토어 리스팅 파일로 일회성 상품을 계획하고 적용합니다.',
+            }),
+            subCommands: {
+                plan: defineI18n({
+                    name: 'plan',
+                    description: 'Read the store products and print the changes; never writes to the store.',
+                    resource: commandResource({
+                        en: 'Read the store products and print the changes; never writes to the store.',
+                        ko: '스토어 상품을 읽고 변경 사항을 출력합니다. 스토어에 쓰지 않습니다.',
+                    }),
+                    args: {
+                        game: { type: 'string', required: false, description: 'Game project directory.' },
+                        profile: { type: 'string', required: false, description: 'Deployment profile naming the app and credential; defaults to beta.' },
+                        store: { type: 'string', required: true, description: 'google-play or app-store.' },
+                        catalog: { type: 'string', required: false, description: 'Product catalog path, relative to the current directory; defaults to mpgd.catalog.json in the game.' },
+                        listings: { type: 'string', required: false, description: 'Store listing file path, relative to the current directory; defaults to mpgd.store-listings.json in the game.' },
+                        'catalog-target': { type: 'string', required: false, description: 'Catalog platformProductIds key of the store; defaults to android (Google Play) or ios (App Store).' },
+                        'keep-live-prices': { type: 'boolean', required: false, description: 'Leave the prices of products players can already buy unchanged.' },
+                        out: { type: 'string', required: false, description: 'New plan JSON path for apply; existing files are not overwritten.' },
+                    },
+                    run: async (ctx) => {
+                        const catalog = readOptionalString(ctx.values.catalog);
+                        const listings = readOptionalString(ctx.values.listings);
+                        const catalogTarget = readOptionalString(ctx.values['catalog-target']);
+                        const result = await planStoreProducts({
+                            game: readOptionalString(ctx.values.game) ?? '.',
+                            profile: readOptionalString(ctx.values.profile) ?? 'beta',
+                            store: readRequiredCliOption(ctx.values.store, '--store'),
+                            ...(catalog === undefined ? {} : { catalogFile: catalog }),
+                            ...(listings === undefined ? {} : { listingsFile: listings }),
+                            ...(catalogTarget === undefined ? {} : { catalogTarget }),
+                            ...(ctx.values['keep-live-prices'] === true ? { keepLivePrices: true } : {}),
+                        });
+                        console.info(result.plan.store === 'google-play'
+                            ? formatPlayProductPlan(result.plan)
+                            : formatAppStoreProductPlan(result.plan));
+                        const out = readOptionalString(ctx.values.out);
+                        if (out !== undefined) {
+                            console.info(`Wrote store product plan: ${saveStoreProductPlan(out, result)}`);
+                        }
+                    },
+                }),
+                apply: defineI18n({
+                    name: 'apply',
+                    description: 'Write the reviewed plan; refuses when the store or the files changed since.',
+                    resource: commandResource({
+                        en: 'Write the reviewed plan; refuses when the store or the files changed since.',
+                        ko: '검토한 계획을 적용합니다. 이후 스토어나 파일이 바뀌었으면 거부합니다.',
+                    }),
+                    args: {
+                        plan: { type: 'string', required: true, description: 'Plan JSON written by "store products plan --out".' },
+                        game: { type: 'string', required: false, description: 'Current game directory if the game moved.' },
+                        approve: { type: 'boolean', required: false, description: 'Approve the store writes.' },
+                        'confirm-price-change': { type: 'boolean', required: false, description: 'Confirm price changes on products players can already buy.' },
+                    },
+                    run: async (ctx) => {
+                        const game = readOptionalString(ctx.values.game);
+                        const result = await applyStoreProducts({
+                            planFile: readRequiredCliOption(ctx.values.plan, '--plan'),
+                            ...(game === undefined ? {} : { game }),
+                            approved: ctx.values.approve === true,
+                            ...(ctx.values['confirm-price-change'] === true ? { confirmPriceChange: true } : {}),
+                        });
+                        console.info(JSON.stringify(result, null, 2));
+                    },
+                }),
+            },
+        }),
+    },
+    run: () => {
+        console.info('Use "mpgd store products plan" or "mpgd store products apply".');
+    },
+});
 const gameCommand = defineI18n({
     name: 'game',
     description: 'Create standalone Phaser game starters.',

package/dist/native-build-info.json

@@ -1,5 +1,5 @@
 {
-  "kitGitSha": "ea82dfadb6cdcd6b842b753f4ce10b52ad1a1fb4",
+  "kitGitSha": "9492eb3679a942e0556e821ce45245db82974640",
   "kitDirty": false,
-  "packageVersion": "0.62.0"
+  "packageVersion": "0.63.0"
 }