@mpgd/cli 0.62.0 → 0.64.0

package/dist/store-presence-command.js

@@ -0,0 +1,145 @@
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { openAscStorePresenceSession } from './app-store-presence-asc.js';
+import { readStorePresenceSource, storePresencePlanCommand, } from './store-presence.js';
+import { applyAppStorePresence, planAppStorePresence, } from './store-presence-app-store.js';
+import { applyPlayPresence, planPlayPresence, } from './store-presence-play.js';
+import { assertStoreSyncStore, readStorePlanFile, relocateStoreSyncFile, resolveStoreSyncApp, StorePlanStaleError, writeStorePlanFile, } from './store-sync.js';
+const defaultPorts = {
+    googlePlay: loadPlayStoreListing,
+    appStore: openAscStorePresenceSession,
+};
+export async function planStorePresence(options, environment = process.env, ports = {}) {
+    const { app, source } = resolveInputs(options, environment);
+    const plan = await withSession(app, ports, options.signal, (session) => {
+        if (session.store === 'google-play') {
+            return planPlayPresence({
+                packageName: session.packageName,
+                presence: source.presence,
+                directory: source.directory,
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
+            }, session.port);
+        }
+        return planAppStorePresence({
+            appId: session.appId,
+            bundleId: session.bundleId,
+            presence: source.presence,
+            directory: source.directory,
+        }, session.port);
+    });
+    return {
+        schemaVersion: 1,
+        kind: 'mpgd-store-presence-plan',
+        gameRoot: path.resolve(options.game),
+        profile: options.profile,
+        presenceFile: source.file,
+        plan,
+    };
+}
+export function saveStorePresencePlan(file, plan) {
+    return writeStorePlanFile(file, plan);
+}
+export async function applyStorePresence(options, environment = process.env, ports = {}) {
+    if (!options.approved) {
+        throw new Error('Writing the store listing requires --approve.');
+    }
+    const saved = readSavedPlan(options.planFile);
+    const gameRoot = options.game === undefined ? saved.gameRoot : path.resolve(options.game);
+    const planOptions = {
+        game: gameRoot,
+        profile: saved.profile,
+        store: saved.plan.store,
+        presenceFile: relocateStoreSyncFile(saved.gameRoot, options.game === undefined ? undefined : gameRoot, saved.presenceFile),
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+    };
+    const { app, source } = resolveInputs(planOptions, environment);
+    const removal = options.confirmImageRemoval === true ? { confirmImageRemoval: true } : {};
+    return withSession(app, ports, options.signal, (session) => {
+        if (session.store === 'google-play' && saved.plan.store === 'google-play') {
+            return applyPlayPresence({
+                saved: saved.plan,
+                plan: {
+                    packageName: session.packageName,
+                    presence: source.presence,
+                    directory: source.directory,
+                    ...(options.signal === undefined ? {} : { signal: options.signal }),
+                },
+                port: session.port,
+                approved: true,
+                ...removal,
+                ...(options.changesNotSentForReview === true ? { changesNotSentForReview: true } : {}),
+            });
+        }
+        if (session.store === 'app-store' && saved.plan.store === 'app-store') {
+            if (options.changesNotSentForReview === true) {
+                throw new Error('--changes-not-sent-for-review applies to Google Play only.');
+            }
+            return applyAppStorePresence({
+                saved: saved.plan,
+                plan: {
+                    appId: session.appId,
+                    bundleId: session.bundleId,
+                    presence: source.presence,
+                    directory: source.directory,
+                },
+                port: session.port,
+                approved: true,
+                ...removal,
+            });
+        }
+        throw new StorePlanStaleError('The saved plan is for another store.', storePresencePlanCommand);
+    });
+}
+function resolveInputs(options, environment) {
+    assertStoreSyncStore(options.store);
+    // The game file first: a malformed file reports its own error without a credential.
+    const source = readStorePresenceSource({
+        gameRoot: options.game,
+        ...(options.presenceFile === undefined ? {} : { presenceFile: options.presenceFile }),
+    });
+    const app = resolveStoreSyncApp(options, environment);
+    return { app, source };
+}
+/** One store session per command. */
+async function withSession(app, overrides, signal, action) {
+    const ports = { ...defaultPorts, ...overrides };
+    if (app.store === 'google-play') {
+        const port = await ports.googlePlay(app.serviceAccountFile);
+        return action({ store: 'google-play', packageName: app.packageName, port });
+    }
+    const session = await ports.appStore(app.credential, signal);
+    try {
+        return await action({
+            store: 'app-store',
+            appId: app.appId,
+            bundleId: app.bundleId,
+            port: session.port,
+        });
+    }
+    finally {
+        session.close();
+    }
+}
+function readSavedPlan(file) {
+    const raw = readStorePlanFile(file, 'store presence plan');
+    const plan = raw.plan;
+    const storeFields = typeof plan === 'object' && plan !== null && ((plan.store === 'google-play' && typeof plan.packageName === 'string' && Array.isArray(plan.languages))
+        || (plan.store === 'app-store' && typeof plan.appId === 'string' && typeof plan.bundleId === 'string'
+            && Array.isArray(plan.locales)));
+    if (raw.schemaVersion !== 1 || raw.kind !== 'mpgd-store-presence-plan'
+        || typeof raw.gameRoot !== 'string' || !path.isAbsolute(raw.gameRoot)
+        || typeof raw.profile !== 'string' || typeof raw.presenceFile !== 'string'
+        || typeof plan !== 'object' || plan === null || plan.schemaVersion !== 1 || !storeFields
+        || typeof plan.remoteSha256 !== 'string' || typeof plan.desiredSha256 !== 'string'
+        || typeof plan.changed !== 'boolean' || typeof plan.imageRemovals !== 'number') {
+        throw new Error('Saved store presence plan is malformed.');
+    }
+    return raw;
+}
+async function loadPlayStoreListing(serviceAccountFile) {
+    if (!existsSync(serviceAccountFile) || !statSync(serviceAccountFile).isFile()) {
+        throw new Error('Google Play service account file is missing.');
+    }
+    const { createServiceAccountStoreListing } = await import(new URL('./play-sdk-adapter.js', import.meta.url).href);
+    return createServiceAccountStoreListing(serviceAccountFile);
+}

package/dist/store-presence-play.d.ts

@@ -0,0 +1,116 @@
+import { type StorePresence } from '@mpgd/catalog';
+import type { PlayAppDetails, PlayImageType, PlayListing, PlayStoreListingPort } from './play-listing-port.js';
+import { type StorePresenceTextChange } from './store-presence.js';
+/**
+* Google Play store presence sync: compare the store presence file with the
+* main store listing (`edits.details`, `edits.listings`, `edits.images`)
+* and plan the writes. Everything goes through one edit: plan opens one to
+* read and discards it; apply opens one, re-plans inside it, writes, and
+* commits once at the end, or discards the edit when anything fails, so
+* Play never holds half an apply.
+*
+* Languages Play lists that the file does not name are kept. Images Play
+* holds that the file does not name are kept unless the file marks the set
+* `complete`; removing one then needs `--confirm-image-removal`.
+*/
+export type PlayPresenceAction = 'create' | 'update' | 'unchanged';
+export interface PlannedPlayImage {
+  /** Path relative to the store presence file. */
+  readonly path: string;
+  readonly sha256: string;
+}
+export interface PlannedPlayImageSlot {
+  readonly imageType: PlayImageType;
+  /** `add` uploads after Play's images; `replace` deletes the slot first. */
+  readonly action: 'unchanged' | 'add' | 'replace';
+  readonly complete: boolean;
+  /** Uploads, in order. */
+  readonly upload: readonly PlannedPlayImage[];
+  /** SHA-256 of Play's images that stay as they are. */
+  readonly keep: readonly string[];
+  /** Play's images the write removes and does not upload again. */
+  readonly remove: readonly {
+    readonly id: string;
+    readonly sha256: string;
+  }[];
+  readonly notes: readonly string[];
+}
+export interface PlannedPlayLanguage {
+  /** The language as Play spells it (BCP-47 casing for a new one). */
+  readonly language: string;
+  readonly action: PlayPresenceAction;
+  readonly text: readonly StorePresenceTextChange[];
+  /** `edits.listings.update` body when the text changes. */
+  readonly listing?: PlayListing & {
+    readonly language: string;
+  };
+  readonly images: readonly PlannedPlayImageSlot[];
+}
+export interface PlayPresencePlan {
+  readonly schemaVersion: 1;
+  readonly store: 'google-play';
+  readonly packageName: string;
+  readonly details?: {
+    readonly changes: readonly {
+      readonly field: string;
+      readonly from?: string;
+      readonly to: string;
+    }[];
+    /** `edits.details.update` body: Play's details with the file's contact fields. */
+    readonly write: PlayAppDetails;
+  };
+  readonly languages: readonly PlannedPlayLanguage[];
+  /** Languages on Play that the file does not name. Never deleted. */
+  readonly remoteOnlyLanguages: readonly string[];
+  /** Play images a complete set removes; apply needs --confirm-image-removal. */
+  readonly imageRemovals: number;
+  readonly changed: boolean;
+  readonly notes: readonly string[];
+  /** What the sync cannot do; the reviewer does it in Play Console. */
+  readonly manual: readonly string[];
+  /** Digest of everything read from Play. */
+  readonly remoteSha256: string;
+  /** Digest of the planned writes. */
+  readonly desiredSha256: string;
+}
+export interface PlayPresencePlanInput {
+  readonly packageName: string;
+  readonly presence: StorePresence;
+  /** Directory of the store presence file; graphics resolve against it. */
+  readonly directory: string;
+  readonly signal?: AbortSignal;
+}
+/** Read Play through a throwaway edit and plan; never writes. */
+export declare function planPlayPresence(input: PlayPresencePlanInput, port: PlayStoreListingPort): Promise<PlayPresencePlan>;
+export interface PlayPresenceApplyResult {
+  readonly packageName: string;
+  readonly status: 'committed' | 'unchanged';
+  readonly languages: readonly {
+    readonly language: string;
+    readonly listing: PlayPresenceAction;
+    readonly images: number;
+  }[];
+}
+export declare class PlayPresenceApplyError extends Error {
+  readonly stage: string;
+  /** `discarded`: Play discarded the edit; `unknown`: the commit may or may not have landed. */
+  readonly outcome: 'discarded' | 'unknown';
+  constructor(stage: string, 
+  /** `discarded`: Play discarded the edit; `unknown`: the commit may or may not have landed. */
+  outcome: 'discarded' | 'unknown', cause: unknown);
+}
+/**
+* Apply a reviewed plan in one edit: re-plan inside the edit, refuse when
+* Play or the files moved past the reviewed plan, write, then commit once.
+* A plan whose changes already landed is a no-op, so a re-run is safe.
+*/
+export declare function applyPlayPresence(input: {
+  readonly saved: PlayPresencePlan;
+  readonly plan: PlayPresencePlanInput;
+  readonly port: PlayStoreListingPort;
+  readonly approved: boolean;
+  readonly confirmImageRemoval?: boolean;
+  readonly changesNotSentForReview?: boolean;
+}): Promise<PlayPresenceApplyResult>;
+/** The plan for the terminal: per language, the text and image changes. */
+export declare function formatPlayPresencePlan(plan: PlayPresencePlan): string;