@mpgd/cli 0.62.0 → 0.64.0

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

@@ -0,0 +1,13 @@
+/**
+ * App Store Connect store page port: app information localizations (name,
+ * subtitle, privacy policy URL), App Store version localizations (description,
+ * keywords, promotional text, what's new, URLs) and their screenshot sets.
+ * `app-store-presence-asc.ts` implements it with the pinned `asc` CLI; the
+ * planner and tests see only these shapes.
+ *
+ * Resources (App Store Connect API):
+ * - App infos and their localizations: https://developer.apple.com/documentation/appstoreconnectapi/app-infos
+ * - App Store versions and their localizations: https://developer.apple.com/documentation/appstoreconnectapi/app-store-versions
+ * - Screenshot sets and screenshots: https://developer.apple.com/documentation/appstoreconnectapi/app-screenshot-sets
+ */
+export {};

package/dist/asc-session.d.ts

@@ -0,0 +1,43 @@
+/**
+* One session on the pinned `asc` 5.5.0 CLI, with the same binary pin,
+* isolated environment and API key as the TestFlight submission, and the
+* JSON helpers every asc-backed port reads its output with. Each command is
+* one `asc ... --output json` subprocess; the JSON is App Store Connect's
+* own resource document, as `asc` 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;
+}
+export declare const ascLookupTimeoutMs = 60000;
+export declare const ascListTimeoutMs: number;
+export declare const ascUploadTimeoutMs: number;
+/** asc exit code for an App Store Connect 404 (`cmd/exit_codes.go`, 5.5.0). */
+export declare const ascExitNotFound = 4;
+/** Copy and verify the pinned binary into a private directory; `close` removes it. */
+export declare function openAscSession(credential: AscCredential, signal?: AbortSignal): Promise<{
+  readonly run: AscCommandRunner;
+  close(): void;
+}>;
+export interface AscJsonResource {
+  readonly id: string;
+  readonly attributes: Record<string, unknown>;
+  readonly relationships?: unknown;
+}
+export declare function single(value: unknown, command: string): AscJsonResource;
+export declare function list(value: unknown, command: string): AscJsonResource[];
+export declare function toResource(value: unknown): AscJsonResource | undefined;
+/**
+* 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": "" }`.
+*/
+export declare function isEmptyResource(value: unknown): boolean;
+export declare function relationshipId(relationships: unknown, name: string): string | undefined;
+export declare function requiredString(value: unknown, label: string): string;
+export declare function optionalString<K extends string>(key: K, value: unknown): Partial<Record<K, string>>;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/asc-session.js

@@ -0,0 +1,118 @@
+import { chmodSync, copyFileSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { runReleaseProcess } from './deploy-process.js';
+import { isolatedAscEnvironment, verifyPinnedAscBinary } from './testflight-submission.js';
+export const ascLookupTimeoutMs = 60_000;
+export const ascListTimeoutMs = 3 * 60_000;
+export const ascUploadTimeoutMs = 10 * 60_000;
+const maxJsonBytes = 8 * 1024 * 1024;
+/** asc exit code for an App Store Connect 404 (`cmd/exit_codes.go`, 5.5.0). */
+export const ascExitNotFound = 4;
+/** Copy and verify the pinned binary into a private directory; `close` removes it. */
+export async function openAscSession(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 {
+            run,
+            close: () => rmSync(tempRoot, { recursive: true, force: true }),
+        };
+    }
+    catch (error) {
+        rmSync(tempRoot, { recursive: true, force: true });
+        throw error;
+    }
+}
+export 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;
+}
+export 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;
+}
+export 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": "" }`.
+ */
+export function isEmptyResource(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return value.data === null
+        || (isRecord(value.data) && (value.data.id === undefined || value.data.id === ''));
+}
+export 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;
+}
+export function requiredString(value, label) {
+    if (typeof value !== 'string') {
+        throw new Error(`asc output has no ${label}.`);
+    }
+    return value;
+}
+export function optionalString(key, value) {
+    const result = {};
+    if (typeof value === 'string' && value !== '') {
+        result[key] = value;
+    }
+    return result;
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/index.d.ts

@@ -9,6 +9,16 @@ 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 { StorePlanStaleError } from './store-sync.js';
+export { applyStorePresence, planStorePresence, saveStorePresencePlan, type StorePresenceApplyOptions, type StorePresencePlanFile, type StorePresencePlanOptions, type StorePresencePorts, type StorePresenceStore, } from './store-presence-command.js';
+export { applyPlayPresence, formatPlayPresencePlan, planPlayPresence, PlayPresenceApplyError, type PlannedPlayImageSlot, type PlannedPlayLanguage, type PlayPresenceApplyResult, type PlayPresencePlan, type PlayPresencePlanInput, } from './store-presence-play.js';
+export { applyAppStorePresence, AppStorePresenceApplyError, formatAppStorePresencePlan, planAppStorePresence, type AppStorePresenceApplyResult, type AppStorePresencePlan, type AppStorePresencePlanInput, type PlannedAppStoreLocale, type PlannedAscScreenshotSet, } from './store-presence-app-store.js';
+export type { AscAppInfo, AscAppInfoLocalization, AscAppStoreVersion, AscScreenshot, AscScreenshotSet, AscStorePresencePort, AscVersionLocalization, AscVersionLocalizationFields, } from './app-store-presence-port.js';
+export type { PlayAppDetails, PlayImage, PlayImageType, PlayListing, PlayStoreListingPort, } from './play-listing-port.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,12 @@ 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 { applyStorePresence, planStorePresence, saveStorePresencePlan, } from './store-presence-command.js';
+import { formatPlayPresencePlan } from './store-presence-play.js';
+import { formatAppStorePresencePlan } from './store-presence-app-store.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 +56,14 @@ 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 { StorePlanStaleError } from './store-sync.js';
+export { applyStorePresence, planStorePresence, saveStorePresencePlan, } from './store-presence-command.js';
+export { applyPlayPresence, formatPlayPresencePlan, planPlayPresence, PlayPresenceApplyError, } from './store-presence-play.js';
+export { applyAppStorePresence, AppStorePresenceApplyError, formatAppStorePresencePlan, planAppStorePresence, } from './store-presence-app-store.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 +224,7 @@ export async function runMpgdCli(args) {
             assets: assetsCommand,
             game: gameCommand,
             deploy: deployCommand,
+            store: storeCommand,
             legal: legalCommand,
             target: targetCommand,
             kit: kitCommand,
@@ -262,7 +277,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 +758,159 @@ 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));
+                    },
+                }),
+            },
+        }),
+        presence: defineI18n({
+            name: 'presence',
+            description: 'Plan and apply the store page text and graphics from mpgd.store-presence.json.',
+            resource: commandResource({
+                en: 'Plan and apply the store page text and graphics from mpgd.store-presence.json.',
+                ko: 'mpgd.store-presence.json으로 스토어 페이지 문구와 그래픽을 계획하고 적용합니다.',
+            }),
+            subCommands: {
+                plan: defineI18n({
+                    name: 'plan',
+                    description: 'Read the store listing and print the changes; never writes to the store.',
+                    resource: commandResource({
+                        en: 'Read the store listing 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.' },
+                        presence: { type: 'string', required: false, description: 'Store presence file path, relative to the current directory; defaults to mpgd.store-presence.json in the game.' },
+                        out: { type: 'string', required: false, description: 'New plan JSON path for apply; existing files are not overwritten.' },
+                    },
+                    run: async (ctx) => {
+                        const presence = readOptionalString(ctx.values.presence);
+                        const result = await planStorePresence({
+                            game: readOptionalString(ctx.values.game) ?? '.',
+                            profile: readOptionalString(ctx.values.profile) ?? 'beta',
+                            store: readRequiredCliOption(ctx.values.store, '--store'),
+                            ...(presence === undefined ? {} : { presenceFile: presence }),
+                        });
+                        console.info(result.plan.store === 'google-play'
+                            ? formatPlayPresencePlan(result.plan)
+                            : formatAppStorePresencePlan(result.plan));
+                        const out = readOptionalString(ctx.values.out);
+                        if (out !== undefined) {
+                            console.info(`Wrote store presence plan: ${saveStorePresencePlan(out, result)}`);
+                        }
+                    },
+                }),
+                apply: defineI18n({
+                    name: 'apply',
+                    description: 'Write the reviewed plan (one Play edit); refuses when the store or the files changed since.',
+                    resource: commandResource({
+                        en: 'Write the reviewed plan (one Play edit); refuses when the store or the files changed since.',
+                        ko: '검토한 계획을 적용합니다(Play는 한 번의 편집). 이후 스토어나 파일이 바뀌었으면 거부합니다.',
+                    }),
+                    args: {
+                        plan: { type: 'string', required: true, description: 'Plan JSON written by "store presence 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-image-removal': { type: 'boolean', required: false, description: 'Confirm removing store images a complete set no longer lists.' },
+                        'changes-not-sent-for-review': { type: 'boolean', required: false, description: 'Google Play: commit without sending for review; send it from Play Console.' },
+                    },
+                    run: async (ctx) => {
+                        const game = readOptionalString(ctx.values.game);
+                        const result = await applyStorePresence({
+                            planFile: readRequiredCliOption(ctx.values.plan, '--plan'),
+                            ...(game === undefined ? {} : { game }),
+                            approved: ctx.values.approve === true,
+                            ...(ctx.values['confirm-image-removal'] === true ? { confirmImageRemoval: true } : {}),
+                            ...(ctx.values['changes-not-sent-for-review'] === true ? { changesNotSentForReview: true } : {}),
+                        });
+                        console.info(JSON.stringify(result, null, 2));
+                    },
+                }),
+            },
+        }),
+    },
+    run: () => {
+        console.info('Use "mpgd store products plan|apply" or "mpgd store presence plan|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": "ab7954c63c4b6648148b4af4f34058d2f3ca7631",
   "kitDirty": false,
-  "packageVersion": "0.62.0"
+  "packageVersion": "0.64.0"
 }