@mpgd/cli 0.33.2 → 0.35.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { renderGameAcceptanceMarkdown, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, defaultGameAcceptanceCommandTimeoutMs, maximumGameplayE2EReportBytes, type GameAcceptanceCommandResult, type GameAcceptanceCommandRunner, type GameAcceptanceReport, type GameAcceptanceStatus, type GameAcceptanceStep, type GameAcceptanceStepResult, type GameAcceptanceStepStatus, type RunGameAcceptanceInput, type RunGameAcceptanceResult, } from './game-acceptance.js';
+export { applyCapacitorShellStarter, materializeCapacitorShellStarter, planCapacitorShellStarter, type CapacitorShellCommandRunner, type CapacitorShellStarterInput, type CapacitorShellStarterPlan, } from './capacitor-shell-starter.js';
 export { createBrowserGameplayE2EDriver, type BrowserGameplayE2EInspectInput, type BrowserGameplayE2EPage, type BrowserGameplayE2EScreenshotOptions, type BrowserGameplayE2EViewport, type CreateBrowserGameplayE2EDriverInput, } from './browser-gameplay-e2e.js';
 export { collectGameplayE2EPathEvidence, defaultGameplayE2EReportFile, maximumGameplayE2EStates, parseGameplayE2EPlan, readGameplayE2EPlan, renderGameplayE2EMarkdown, resolveGameplayE2EReportFile, runGameplayE2E, type GameplayE2EAction, type GameplayE2EActionResult, type GameplayE2EDriver, type GameplayE2EHashLimits, type GameplayE2EInputAction, type GameplayE2EObservation, type GameplayE2EPauseResumeAction, type GameplayE2EPathEvidence, type GameplayE2EPlan, type GameplayE2EReport, type GameplayE2EResultStatus, type GameplayE2EState, type GameplayE2EStateResult, type GameplayE2EStatus, type RunGameplayE2EInput, type RunGameplayE2EResult, } from './gameplay-e2e.js';
 export { cloudflarePagesDeploymentProfiles, hostedPwaDeploymentHosts, isSupportedHostedPwaProfile, verifyHostedPwaDeployment, type CloudflarePagesDeploymentProfile, type HostedPwaDeploymentHost, type HostedPwaDeploymentVerification, type VerifyHostedPwaDeploymentInput, } from './hosted-pwa-deployment.js';

package/dist/index.js

@@ -8,6 +8,7 @@ import resources from '@gunshi/resources';
 import { cli } from 'gunshi';
 import { buildAssetPacks } from './asset-pack-build.js';
 import { verifyAssetPackDelivery } from './asset-pack-verify.js';
+import { materializeCapacitorShellStarter, planCapacitorShellStarter, } from './capacitor-shell-starter.js';
 import { normalizeConfiguredBuildTargets, normalizeBuildTarget as normalizeConfiguredTargetName, supportedBuildTargets, } from './build-targets.js';
 import { escapeMarkdownInline as escapeEvidenceMarkdownInline, writeEvidenceReportFiles, } from './evidence-io.js';
 import { defaultGameAcceptanceCommandTimeoutMs, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, } from './game-acceptance.js';
@@ -16,10 +17,12 @@ import { cloudflarePagesDeploymentProfiles, hostedPwaDeploymentHosts, verifyHost
 import { createMicrosoftStorePackageAcceptanceRuntime, runMicrosoftStorePackageAcceptance, } from './microsoft-store-package-acceptance.js';
 import { runMicrosoftStorePackageGeneration } from './microsoft-store-package-generation.js';
 import { defaultMpgdKitPath, initializeMicrosoftStoreStarter, listMicrosoftStoreInitializerTemplateFiles, prepareBaseGameTemplateFile, resolveMicrosoftStoreAdapterDependencyVersion, } from './microsoft-store-starter.js';
+import { applyKitUpgrade, planKitUpgrade } from './kit-upgrade.js';
 import { runMicrosoftStoreSubmissionPreflight } from './microsoft-store-submission.js';
 import { defaultOfflinePlaytestArtifactDir, defaultOfflinePlaytestMaximumBytes, defaultOfflinePlaytestOutputDir, runOfflinePlaytestPackaging, } from './offline-playtest.js';
 import { targetConfigExtensionsFileEnv } from './target-config-env.js';
 export { renderGameAcceptanceMarkdown, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, defaultGameAcceptanceCommandTimeoutMs, maximumGameplayE2EReportBytes, } from './game-acceptance.js';
+export { applyCapacitorShellStarter, materializeCapacitorShellStarter, planCapacitorShellStarter, } from './capacitor-shell-starter.js';
 export { createBrowserGameplayE2EDriver, } from './browser-gameplay-e2e.js';
 export { collectGameplayE2EPathEvidence, defaultGameplayE2EReportFile, maximumGameplayE2EStates, parseGameplayE2EPlan, readGameplayE2EPlan, renderGameplayE2EMarkdown, resolveGameplayE2EReportFile, runGameplayE2E, } from './gameplay-e2e.js';
 export { cloudflarePagesDeploymentProfiles, hostedPwaDeploymentHosts, isSupportedHostedPwaProfile, verifyHostedPwaDeployment, } from './hosted-pwa-deployment.js';
@@ -133,7 +136,7 @@ export async function runMpgdCli(args) {
         // partial document. Every other command keeps the default rendering.
         renderHeader: async (ctx) => {
             const values = ctx.values;
-            if (ctx.name === 'verify-delivery' && values.json === true) {
+            if ((ctx.name === 'verify-delivery' || ctx.name === 'upgrade') && values.json === true) {
                 return '';
             }
             const title = ctx.env.description || ctx.env.name || '';
@@ -144,7 +147,7 @@ export async function runMpgdCli(args) {
         renderValidationErrors: async (ctx, error) => {
             const messages = error.errors.map((entry) => String(entry.message)).join('\n');
             const values = ctx.values;
-            if (ctx.name === 'verify-delivery' && values.json === true) {
+            if ((ctx.name === 'verify-delivery' || ctx.name === 'upgrade') && values.json === true) {
                 process.stderr.write(`${messages}\n`);
                 return '';
             }
@@ -1117,8 +1120,8 @@ const targetCommand = defineI18n({
                 ko: '충돌 파일을 덮어쓰지 않고 기존 게임에 선택적 타깃 워크플로를 초기화합니다.',
             }, {
                 target: {
-                    en: 'Target to initialize. Currently supports microsoft-store.',
-                    ko: '초기화할 타깃. 현재 microsoft-store를 지원합니다.',
+                    en: 'Target to initialize: microsoft-store or capacitor.',
+                    ko: '초기화할 타깃: microsoft-store 또는 capacitor.',
                 },
                 game: {
                     en: 'Existing game root. Defaults to the current directory.',
@@ -1132,12 +1135,32 @@ const targetCommand = defineI18n({
                     en: 'Validate and print planned file changes without writing them.',
                     ko: '파일을 쓰지 않고 예정 변경을 검증하고 출력합니다.',
                 },
+                'app-id': {
+                    en: 'Game-owned Android package ID and iOS bundle ID.',
+                    ko: '게임 소유 Android 패키지 ID 및 iOS 번들 ID.',
+                },
+                'display-name': {
+                    en: 'Native application display name.',
+                    ko: '네이티브 앱 표시 이름.',
+                },
+                'icon-source': {
+                    en: 'Game-owned native icon source file.',
+                    ko: '게임 소유 네이티브 아이콘 원본 파일.',
+                },
+                'backend-url': {
+                    en: 'Production HTTPS Game Services base URL.',
+                    ko: '프로덕션 HTTPS Game Services 기본 URL.',
+                },
+                providers: {
+                    en: 'Comma-separated requested provider IDs; this does not install SDKs.',
+                    ko: '쉼표로 구분한 요청 provider ID. SDK를 설치하지는 않습니다.',
+                },
             }),
             args: {
                 target: {
                     type: 'positional',
                     required: true,
-                    description: 'Target to initialize. Currently supports microsoft-store.',
+                    description: 'Target to initialize: microsoft-store or capacitor.',
                 },
                 game: {
                     type: 'string',
@@ -1155,15 +1178,86 @@ const targetCommand = defineI18n({
                     required: false,
                     description: 'Validate and print planned file changes without writing them.',
                 },
+                'app-id': {
+                    type: 'string',
+                    required: false,
+                    description: 'Game-owned Android package ID and iOS bundle ID.',
+                },
+                'display-name': {
+                    type: 'string',
+                    required: false,
+                    description: 'Native application display name.',
+                },
+                'icon-source': {
+                    type: 'string',
+                    required: false,
+                    description: 'Game-owned native icon source file.',
+                },
+                'backend-url': {
+                    type: 'string',
+                    required: false,
+                    description: 'Production HTTPS Game Services base URL.',
+                },
+                providers: {
+                    type: 'string',
+                    required: false,
+                    description: 'Comma-separated requested provider IDs; this does not install SDKs.',
+                },
             },
             run: (ctx) => {
                 const positionals = readLocalPositionals(ctx.positionals, ['target', 'init']);
                 const requestedTarget = readRequiredPositional(positionals, 0, 'target');
+                const gameRoot = path.resolve(readOptionalString(ctx.values.game) ?? '.');
+                const dryRun = ctx.values['dry-run'] === true;
+                if (requestedTarget === 'capacitor') {
+                    if (ctx.values['kit-path'] !== undefined) {
+                        throw new Error('--kit-path is not used by the game-owned Capacitor initializer.');
+                    }
+                    const appId = readOptionalString(ctx.values['app-id']);
+                    const displayName = readOptionalString(ctx.values['display-name']);
+                    if (appId === undefined || displayName === undefined) {
+                        throw new Error('Capacitor initialization requires --app-id and --display-name.');
+                    }
+                    const iconSource = readOptionalString(ctx.values['icon-source']);
+                    const backendUrl = readOptionalString(ctx.values['backend-url']);
+                    const selectedProviders = readOptionalString(ctx.values.providers);
+                    const plan = planCapacitorShellStarter({
+                        gameRoot,
+                        appId,
+                        displayName,
+                        ...(iconSource === undefined ? {} : { iconSource }),
+                        ...(backendUrl === undefined ? {} : { backendUrl }),
+                        ...(selectedProviders === undefined ? {} : {
+                            providerIds: selectedProviders.split(',').map((id) => id.trim()),
+                        }),
+                    });
+                    if (!dryRun) {
+                        materializeCapacitorShellStarter(plan);
+                    }
+                    console.info(`${dryRun ? 'Would update' : 'Updated'} game-owned Capacitor shell: ${plan.changedFiles.length} file(s).`);
+                    for (const file of plan.changedFiles) {
+                        console.info(`- ${file}`);
+                    }
+                    for (const platform of plan.nativePlatformsToAdd) {
+                        console.info(`${dryRun ? 'Would add' : 'Added'} native platform: ${platform}`);
+                    }
+                    console.info('File count covers managed shell files only; pnpm may also update root or shell lockfiles.');
+                    if (!dryRun) {
+                        console.info('Production native builds still require release identity and signing checks.');
+                    }
+                    return;
+                }
                 const target = normalizeConfiguredBuildTarget(requestedTarget);
                 if (target !== 'microsoft-store') {
                     throw new Error(`Target initialization is only available for microsoft-store; received: ${requestedTarget}`);
                 }
-                const gameRoot = path.resolve(readOptionalString(ctx.values.game) ?? '.');
+                for (const option of [
+                    'app-id', 'display-name', 'icon-source', 'backend-url', 'providers',
+                ]) {
+                    if (ctx.values[option] !== undefined) {
+                        throw new Error(`--${option} is only available for capacitor initialization.`);
+                    }
+                }
                 const configuredKitPath = readOptionalString(ctx.values['kit-path']);
                 const resolvedKitPath = configuredKitPath === undefined
                     ? detectedKitRoot
@@ -1172,7 +1266,6 @@ const targetCommand = defineI18n({
                 const defaultKitPath = resolvedKitPath === undefined
                     ? defaultMpgdKitPath
                     : toTemplatePath(path.relative(canonicalGameRoot, resolvedKitPath) || '.');
-                const dryRun = ctx.values['dry-run'] === true;
                 const adapterDependencyVersion = resolveMicrosoftStoreAdapterDependencyVersion(requireMpgdDependencyVersion(resolveMpgdDependencyVersionReplacements({
                     workspace: false,
                     ...(resolvedKitPath === undefined ? {} : { kitPath: resolvedKitPath }),
@@ -1950,6 +2043,76 @@ const kitCommand = defineI18n({
         ko: '현재 mpgd-kit 체크아웃을 점검합니다.',
     }),
     subCommands: {
+        upgrade: defineI18n({
+            name: 'upgrade',
+            description: 'Plan or apply the latest published Kit package versions for a game.',
+            resource: commandResource({
+                base: {
+                    en: 'Plan or apply the latest published Kit package versions for a game.',
+                    ko: '게임에 배포된 최신 Kit 패키지 버전 적용을 계획하거나 실행합니다.',
+                },
+                args: {
+                    game: {
+                        en: 'Game directory containing package.json and optional mpgd.targets.json.',
+                        ko: 'package.json과 선택적 mpgd.targets.json이 있는 게임 디렉터리.',
+                    },
+                    'targets-file': {
+                        en: 'Optional game-owned target configuration file.',
+                        ko: '선택적 게임 소유 타깃 구성 파일.',
+                    },
+                    apply: {
+                        en: 'Write the planned manifests and pnpm lockfiles.',
+                        ko: '계획된 의존성 선언과 pnpm 락파일을 갱신합니다.',
+                    },
+                    json: {
+                        en: 'Write one machine-readable JSON document to stdout.',
+                        ko: '표준 출력에 기계 판독용 JSON 문서 하나를 출력합니다.',
+                    },
+                },
+            }),
+            args: {
+                game: { type: 'string', required: false, default: '.', description: 'Game directory.' },
+                'targets-file': { type: 'string', required: false, description: 'Target config file.' },
+                apply: { type: 'boolean', required: false, description: 'Apply the upgrade plan.' },
+                json: { type: 'boolean', required: false, description: 'Print JSON.' },
+            },
+            run: async (ctx) => {
+                const game = readOptionalString(ctx.values.game) ?? '.';
+                const plan = await planKitUpgrade(game, undefined, readOptionalString(ctx.values['targets-file']));
+                const result = ctx.values.apply === true && plan.blockers.length === 0
+                    ? applyKitUpgrade(plan)
+                    : undefined;
+                if (ctx.values.json === true) {
+                    process.stdout.write(JSON.stringify({ plan, result: result ?? null }, null, 2) + '\n');
+                }
+                else {
+                    console.info('Kit upgrade plan for ' + plan.gameRoot);
+                    for (const update of plan.updates) {
+                        console.info('  ' + path.relative(plan.gameRoot, update.manifest)
+                            + ': ' + update.packageName + ' ' + update.current + ' -> ' + update.next);
+                    }
+                    if (plan.updates.length === 0) {
+                        console.info('  Already current for published npm latest tags.');
+                    }
+                    for (const note of plan.notes) {
+                        console.info('Note: ' + note);
+                    }
+                    for (const blocker of plan.blockers) {
+                        console.error('Blocked: ' + blocker);
+                    }
+                    if (result !== undefined) {
+                        console.info('Updated ' + result.manifests.length + ' manifest(s) and '
+                            + result.lockfiles.length + ' lockfile(s). Run target checks before release.');
+                    }
+                    else if (plan.updates.length > 0 && plan.blockers.length === 0) {
+                        console.info('Run again with --apply to update manifests and pnpm lockfiles.');
+                    }
+                }
+                if (plan.blockers.length > 0) {
+                    process.exitCode = 1;
+                }
+            },
+        }),
         doctor: defineI18n({
             name: 'doctor',
             description: 'Print CLI, kit, template, and target-wrapper status.',
@@ -1968,7 +2131,7 @@ const kitCommand = defineI18n({
         }),
     },
     run: () => {
-        console.info('Use "mpgd kit doctor".');
+        console.info('Use "mpgd kit doctor" or "mpgd kit upgrade --game <directory> [--apply]".');
     },
 });
 function commandResource(description, args = {}) {

package/dist/kit-upgrade.d.ts

@@ -0,0 +1,39 @@
+declare const dependencySections: readonly ['dependencies', 'devDependencies', 'optionalDependencies'];
+type DependencySection = (typeof dependencySections)[number];
+export interface PublishedKitPackage {
+  readonly version: string;
+  readonly peerDependencies?: Readonly<Record<string, string>>;
+  readonly optionalPeerDependencies?: readonly string[];
+}
+export type LatestKitPackageLookup = (name: string, gameRoot: string) => Promise<PublishedKitPackage>;
+export interface KitUpgradeUpdate {
+  readonly manifest: string;
+  readonly section: DependencySection;
+  readonly packageName: string;
+  readonly current: string;
+  readonly next: string;
+  readonly latestVersion: string;
+}
+export interface KitUpgradePlan {
+  readonly gameRoot: string;
+  readonly updates: readonly KitUpgradeUpdate[];
+  readonly blockers: readonly string[];
+  readonly notes: readonly string[];
+  readonly manifestDigests: Readonly<Record<string, string>>;
+  readonly targetConfigDigest: {
+    readonly file: string;
+    readonly sha256: string | null;
+  };
+  readonly lockfileDigests: Readonly<Record<string, string>>;
+  readonly workspaceRoots: readonly string[];
+}
+export interface KitUpgradeApplyResult {
+  readonly manifests: readonly string[];
+  readonly lockfiles: readonly string[];
+}
+export type KitUpgradeLockfileRunner = (workspaceRoot: string) => void;
+export declare function planKitUpgrade(gameDirectory: string, lookup?: LatestKitPackageLookup, targetsFileName?: string): Promise<KitUpgradePlan>;
+export declare function applyKitUpgrade(plan: KitUpgradePlan, runLockfileUpdate?: KitUpgradeLockfileRunner): KitUpgradeApplyResult;
+export declare function lookupPublishedKitPackage(packageName: string, gameRoot: string): Promise<PublishedKitPackage>;
+export declare function parsePublishedKitPackageResponse(source: string, packageName: string): PublishedKitPackage;
+export {};