@mpgd/cli 0.5.0 → 0.7.0

package/dist/index.js

@@ -6,6 +6,9 @@ import completion from '@gunshi/plugin-completion';
 import i18n, { defineI18n } from '@gunshi/plugin-i18n';
 import resources from '@gunshi/resources';
 import { cli } from 'gunshi';
+import { defaultGameAcceptanceCommandTimeoutMs, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, } from './game-acceptance.js';
+export { renderGameAcceptanceMarkdown, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, defaultGameAcceptanceCommandTimeoutMs, } from './game-acceptance.js';
+export { assertProductionTargetReadiness, } from './production-target-readiness.js';
 const sourceDir = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolvePackageRoot(sourceDir);
 const detectedKitRoot = resolveDefaultKitRoot();
@@ -50,6 +53,15 @@ const supportedBuildTargets = [
     'reddit',
 ];
 const supportedVariants = ['wrapper', 'sync', 'simulator', 'archive'];
+const acceptanceStepIds = {
+    check: 'check',
+    test: 'test',
+    build: 'build',
+    graph: 'graph-preflight',
+    playtest: 'playtest',
+    targetBuild: 'target-build',
+    targetSmoke: 'target-smoke',
+};
 export async function runMpgdCli(args) {
     await cli([...args], entryCommand, {
         name: 'mpgd',
@@ -213,15 +225,402 @@ const gameCommand = defineI18n({
                 });
             },
         }),
+        accept: defineI18n({
+            name: 'accept',
+            description: 'Run the reusable game handoff acceptance workflow.',
+            resource: commandResource({
+                en: 'Run check, test, build, graph, playtest, and target acceptance with handoff reports.',
+                ko: 'check, test, build, graph, playtest, 타깃 인수 검증과 인계 리포트를 실행합니다.',
+            }, {
+                game: {
+                    en: 'Game root containing package.json and mpgd.targets.json.',
+                    ko: 'package.json과 mpgd.targets.json이 있는 게임 루트.',
+                },
+                targets: {
+                    en: 'Comma-separated target list, default, or all.',
+                    ko: '쉼표로 구분한 타깃 목록, default 또는 all.',
+                },
+                profile: {
+                    en: 'Target build profile. Defaults to staging.',
+                    ko: '타깃 빌드 프로필. 기본값은 staging.',
+                },
+                'playtest-script': {
+                    en: 'Optional game-owned package script used for automated playtesting.',
+                    ko: '자동 플레이테스트에 사용할 선택적 게임 소유 패키지 스크립트.',
+                },
+                'report-dir': {
+                    en: 'JSON and Markdown handoff report directory.',
+                    ko: 'JSON 및 Markdown 인계 리포트 디렉터리.',
+                },
+                'timeout-ms': {
+                    en: 'Maximum duration for each acceptance command.',
+                    ko: '각 인수 검증 명령의 최대 실행 시간.',
+                },
+                'kit-path': {
+                    en: 'Path to the mpgd-kit checkout.',
+                    ko: 'mpgd-kit 체크아웃 경로.',
+                },
+            }),
+            args: {
+                game: {
+                    type: 'positional',
+                    required: true,
+                    description: 'Game root containing package.json and mpgd.targets.json.',
+                },
+                targets: {
+                    type: 'string',
+                    required: false,
+                    default: 'default',
+                    description: 'Comma-separated target list, default, or all.',
+                },
+                profile: {
+                    type: 'string',
+                    required: false,
+                    default: 'staging',
+                    description: 'Target build profile.',
+                },
+                'ait-variant': {
+                    type: 'enum',
+                    choices: supportedVariants,
+                    required: false,
+                    default: 'wrapper',
+                    description: 'Variant for the ait target.',
+                },
+                'ios-variant': {
+                    type: 'enum',
+                    choices: supportedVariants,
+                    required: false,
+                    description: 'Variant for the ios target.',
+                },
+                'playtest-script': {
+                    type: 'string',
+                    required: false,
+                    default: 'playtest',
+                    description: 'Game-owned package script used for automated playtesting.',
+                },
+                'report-dir': {
+                    type: 'string',
+                    required: false,
+                    description: 'JSON and Markdown handoff report directory.',
+                },
+                'timeout-ms': {
+                    type: 'string',
+                    required: false,
+                    default: String(defaultGameAcceptanceCommandTimeoutMs),
+                    description: 'Maximum duration for each acceptance command in milliseconds.',
+                },
+                'kit-path': {
+                    type: 'string',
+                    required: false,
+                    description: 'Path to the mpgd-kit checkout.',
+                },
+                'skip-test': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Skip the game-owned test package script.',
+                },
+                'skip-graph': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Skip the kit graph preflight.',
+                },
+                'skip-playtest': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Skip the game-owned playtest package script.',
+                },
+                'skip-target-build': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Skip the target build matrix.',
+                },
+                'skip-target-smoke': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Skip the target smoke matrix.',
+                },
+            },
+            run: (ctx) => {
+                const positionals = readLocalPositionals(ctx.positionals, ['game', 'accept']);
+                const gameRoot = path.resolve(readRequiredPositional(positionals, 0, 'game'));
+                const iosVariant = readOptionalString(ctx.values['ios-variant']);
+                const reportDir = readOptionalString(ctx.values['report-dir']);
+                const kitPath = readOptionalString(ctx.values['kit-path']);
+                const timeoutMs = readPositiveInteger(readOptionalString(ctx.values['timeout-ms'])
+                    ?? String(defaultGameAcceptanceCommandTimeoutMs), '--timeout-ms');
+                acceptGame({
+                    gameRoot,
+                    targets: readOptionalString(ctx.values.targets) ?? 'default',
+                    profile: readOptionalString(ctx.values.profile) ?? 'staging',
+                    aitVariant: readOptionalString(ctx.values['ait-variant']) ?? 'wrapper',
+                    ...(iosVariant === undefined ? {} : { iosVariant }),
+                    playtestScript: readOptionalString(ctx.values['playtest-script']) ?? 'playtest',
+                    ...(reportDir === undefined ? {} : { reportDir }),
+                    ...(kitPath === undefined ? {} : { kitPath }),
+                    timeoutMs,
+                    skipTest: ctx.values['skip-test'] === true,
+                    skipGraph: ctx.values['skip-graph'] === true,
+                    skipPlaytest: ctx.values['skip-playtest'] === true,
+                    skipTargetBuild: ctx.values['skip-target-build'] === true,
+                    skipTargetSmoke: ctx.values['skip-target-smoke'] === true,
+                });
+            },
+        }),
+        icons: defineI18n({
+            name: 'icons',
+            description: 'Generate and verify target app icons from the game brand source.',
+            resource: commandResource({
+                en: 'Generate and verify target app icons from the game brand source.',
+                ko: '게임 브랜드 원본에서 타깃별 앱 아이콘을 생성하고 검증합니다.',
+            }),
+            subCommands: Object.fromEntries(['generate', 'verify', 'inspect'].map((action) => [
+                action,
+                defineI18n({
+                    name: action,
+                    description: `${action} target app icon assets.`,
+                    resource: commandResource({
+                        en: `${action} target app icon assets.`,
+                        ko: `타깃 앱 아이콘 자산을 ${action}합니다.`,
+                    }),
+                    args: {
+                        game: {
+                            type: 'positional',
+                            required: true,
+                            description: 'Game root containing mpgd.game.json and mpgd.targets.json.',
+                        },
+                        targets: {
+                            type: 'string',
+                            required: false,
+                            description: 'Comma-separated target names. Defaults to every configured target.',
+                        },
+                        profile: {
+                            type: 'string',
+                            required: false,
+                            default: action === 'verify' ? 'production' : 'development',
+                            description: 'Validation profile (development or production).',
+                        },
+                        'kit-path': {
+                            type: 'string',
+                            required: false,
+                            description: 'Path to the mpgd-kit checkout.',
+                        },
+                    },
+                    run: (ctx) => {
+                        const positionals = readLocalPositionals(ctx.positionals, ['game', 'icons', action]);
+                        const gameRoot = path.resolve(readRequiredPositional(positionals, 0, 'game'));
+                        const env = createTargetCommandEnv({
+                            'targets-file': path.join(gameRoot, 'mpgd.targets.json'),
+                            'kit-path': ctx.values['kit-path'],
+                        });
+                        const targets = readOptionalString(ctx.values.targets) ?? '';
+                        const profile = readOptionalString(ctx.values.profile)
+                            ?? (action === 'verify' ? 'production' : 'development');
+                        runPnpm([`game:icons:${action}`, '--', targets, profile], env);
+                    },
+                }),
+            ])),
+            run: () => {
+                console.log('Use "mpgd game icons generate <game>", verify, or inspect.');
+            },
+        }),
     },
     run: () => {
-        console.log('Use "mpgd game create <directory>".');
+        console.log('Use "mpgd game create <directory>", "mpgd game accept <game>", or "mpgd game icons generate <game>".');
     },
 });
 const defaultLegalDir = 'legal';
 const defaultLegalOutDir = 'artifacts/legal-site';
 const legalPageSlugs = ['privacy', 'support', 'terms'];
 const legalPageFileList = legalPageSlugs.map((slug) => `${slug}.html`).join(', ');
+function acceptGame(input) {
+    if (input.skipTargetBuild && !input.skipTargetSmoke) {
+        throw new Error('Use --skip-target-smoke when --skip-target-build is set.');
+    }
+    const gameRoot = assertGameAcceptanceRoot(input.gameRoot);
+    const gamePackage = readPackageJsonOrUndefined(gameRoot, { strictParse: true });
+    if (gamePackage === undefined) {
+        throw new Error(`Missing game package.json: ${gameRoot}`);
+    }
+    const targetsFile = path.join(gameRoot, 'mpgd.targets.json');
+    if (!existsSync(targetsFile)) {
+        throw new Error(`Missing game target config: ${targetsFile}`);
+    }
+    const kitPath = resolveKitPathForTarget({
+        ...(input.kitPath === undefined ? {} : { 'kit-path': input.kitPath }),
+    });
+    const packageManager = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
+    const steps = [
+        packageScriptAcceptanceStep({
+            id: acceptanceStepIds.check,
+            label: 'Game check',
+            script: 'check',
+            gameRoot,
+            packageManager,
+            scripts: gamePackage.scripts,
+            required: true,
+        }),
+        packageScriptAcceptanceStep({
+            id: acceptanceStepIds.test,
+            label: 'Game tests',
+            script: 'test',
+            gameRoot,
+            packageManager,
+            scripts: gamePackage.scripts,
+            required: false,
+            skipped: input.skipTest,
+        }),
+        packageScriptAcceptanceStep({
+            id: acceptanceStepIds.build,
+            label: 'Game build',
+            script: 'build',
+            gameRoot,
+            packageManager,
+            scripts: gamePackage.scripts,
+            required: true,
+        }),
+        input.skipGraph
+            ? skippedAcceptanceStep(acceptanceStepIds.graph, 'TypeScript graph preflight', 'Disabled by --skip-graph.')
+            : {
+                id: acceptanceStepIds.graph,
+                label: 'TypeScript graph preflight',
+                command: packageManager,
+                args: ['graph:preflight'],
+                cwd: kitPath,
+            },
+        packageScriptAcceptanceStep({
+            id: acceptanceStepIds.playtest,
+            label: 'Automated playtest',
+            script: input.playtestScript,
+            gameRoot,
+            packageManager,
+            scripts: gamePackage.scripts,
+            required: false,
+            skipped: input.skipPlaytest,
+        }),
+        targetMatrixAcceptanceStep({
+            action: 'build-all',
+            id: acceptanceStepIds.targetBuild,
+            label: 'Target build matrix',
+            kitPath,
+            packageManager,
+            targetsFile,
+            targets: input.targets,
+            profile: input.profile,
+            aitVariant: input.aitVariant,
+            ...(input.iosVariant === undefined ? {} : { iosVariant: input.iosVariant }),
+            skipped: input.skipTargetBuild,
+        }),
+        targetMatrixAcceptanceStep({
+            action: 'smoke-all',
+            id: acceptanceStepIds.targetSmoke,
+            label: 'Target smoke matrix',
+            kitPath,
+            packageManager,
+            targetsFile,
+            targets: input.targets,
+            profile: input.profile,
+            aitVariant: input.aitVariant,
+            ...(input.iosVariant === undefined ? {} : { iosVariant: input.iosVariant }),
+            skipped: input.skipTargetSmoke,
+        }),
+    ];
+    const reportDir = path.resolve(gameRoot, input.reportDir ?? 'artifacts/acceptance');
+    const releaseManifestFile = resolveGameAcceptanceReleaseManifestFile(gameRoot);
+    const result = runGameAcceptance({
+        gameRoot,
+        reportDir,
+        ...(input.skipTargetBuild
+            ? {}
+            : { releaseManifestFile }),
+        options: {
+            targets: input.targets,
+            profile: input.profile,
+            aitVariant: input.aitVariant,
+            iosVariant: input.iosVariant ?? null,
+            playtestScript: input.playtestScript,
+            skipTest: input.skipTest,
+            skipGraph: input.skipGraph,
+            skipPlaytest: input.skipPlaytest,
+            skipTargetBuild: input.skipTargetBuild,
+            skipTargetSmoke: input.skipTargetSmoke,
+            timeoutMs: String(input.timeoutMs),
+        },
+        steps,
+        commandTimeoutMs: input.timeoutMs,
+        env: {
+            ...process.env,
+            MPGD_KIT_PATH: kitPath,
+            MPGD_RELEASE_MANIFEST_FILE: releaseManifestFile,
+        },
+    });
+    console.log(`[mpgd:accept] JSON report: ${result.jsonFile}`);
+    console.log(`[mpgd:accept] Markdown report: ${result.markdownFile}`);
+    if (result.report.status === 'failed') {
+        throw new Error(`Game acceptance failed. Report: ${result.markdownFile}`);
+    }
+    console.log('[mpgd:accept] passed');
+}
+function assertGameAcceptanceRoot(gameRoot) {
+    const resolved = path.resolve(gameRoot);
+    if (!existsSync(resolved)) {
+        throw new Error(`Game root does not exist: ${resolved}`);
+    }
+    return realpathSync(resolved);
+}
+function packageScriptAcceptanceStep(input) {
+    if (input.skipped === true) {
+        return skippedAcceptanceStep(input.id, input.label, 'Disabled by command option.');
+    }
+    if (input.scripts?.[input.script] === undefined && !input.required) {
+        return skippedAcceptanceStep(input.id, input.label, `Optional package script "${input.script}" is not configured.`);
+    }
+    return {
+        id: input.id,
+        label: input.label,
+        command: input.packageManager,
+        args: ['run', input.script],
+        cwd: input.gameRoot,
+    };
+}
+function targetMatrixAcceptanceStep(input) {
+    if (input.skipped) {
+        return skippedAcceptanceStep(input.id, input.label, 'Disabled by command option.');
+    }
+    const args = [
+        'mpgd',
+        'target',
+        input.action,
+        '--targets-file',
+        input.targetsFile,
+        '--kit-path',
+        input.kitPath,
+        '--targets',
+        input.targets,
+    ];
+    if (input.action === 'build-all') {
+        args.push('--profile', input.profile, '--ait-variant', input.aitVariant);
+        if (input.iosVariant !== undefined) {
+            args.push('--ios-variant', input.iosVariant);
+        }
+    }
+    return {
+        id: input.id,
+        label: input.label,
+        command: input.packageManager,
+        args,
+        cwd: input.kitPath,
+    };
+}
+function skippedAcceptanceStep(id, label, skipReason) {
+    return { id, label, skipReason };
+}
+function readPositiveInteger(value, label) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return parsed;
+}
 const legalCommand = defineI18n({
     name: 'legal',
     description: 'Build static legal/support pages for store and release evidence.',
@@ -738,6 +1137,7 @@ function createGameApp(input) {
         '  mpgd target build-all',
         `--targets-file ${path.join(appDir, 'mpgd.targets.json')}`,
         `--targets ${recommendedMatrixTargets}`,
+        '--profile staging',
         '--ait-variant wrapper',
         '--kit-path <path-to-mpgd-kit>',
     ].join(' '));
@@ -949,6 +1349,7 @@ function toTemplatePath(value) {
 }
 function createTargetCommandEnv(values) {
     const targetsFile = path.resolve(readOptionalString(values['targets-file']) ?? 'mpgd.targets.json');
+    const gameRoot = path.dirname(targetsFile);
     const kitPath = resolveKitPathForTarget(values);
     const resolvedTargetsFile = readOptionalString(values['resolved-targets-file']);
     const preparedTargetsFile = preparePlatformTargetsFile({
@@ -960,10 +1361,75 @@ function createTargetCommandEnv(values) {
     });
     return {
         ...process.env,
+        ...createGameOwnedReleaseEnv(gameRoot, process.env),
         MPGD_KIT_PATH: kitPath,
         MPGD_PLATFORM_TARGETS_FILE: preparedTargetsFile,
     };
 }
+function createGameOwnedReleaseEnv(gameRoot, baseEnv) {
+    const monetizationFiles = resolveGameOwnedMonetizationFiles(gameRoot, baseEnv);
+    const sourceGitSha = readOptionalString(baseEnv.MPGD_SOURCE_GIT_SHA)
+        ?? readSourceGitSha(gameRoot);
+    const appVersion = readOptionalString(baseEnv.APP_VERSION)
+        ?? readGamePackageVersion(gameRoot);
+    return {
+        ...monetizationFiles,
+        MPGD_SOURCE_GIT_SHA: sourceGitSha,
+        ...(appVersion === undefined ? {} : { APP_VERSION: appVersion }),
+    };
+}
+function resolveGameOwnedMonetizationFiles(gameRoot, baseEnv) {
+    const configuredCatalog = readConfiguredPath(baseEnv.MPGD_PRODUCT_CATALOG_FILE);
+    const configuredPlacements = readConfiguredPath(baseEnv.MPGD_AD_PLACEMENTS_FILE);
+    if ((configuredCatalog === undefined) !== (configuredPlacements === undefined)) {
+        throw new Error('MPGD_PRODUCT_CATALOG_FILE and MPGD_AD_PLACEMENTS_FILE must be configured together.');
+    }
+    if (configuredCatalog !== undefined && configuredPlacements !== undefined) {
+        return {
+            MPGD_PRODUCT_CATALOG_FILE: path.resolve(gameRoot, configuredCatalog),
+            MPGD_AD_PLACEMENTS_FILE: path.resolve(gameRoot, configuredPlacements),
+        };
+    }
+    const catalogFile = path.join(gameRoot, 'mpgd.catalog.json');
+    const placementsFile = path.join(gameRoot, 'mpgd.ad-placements.json');
+    const hasCatalog = existsSync(catalogFile);
+    const hasPlacements = existsSync(placementsFile);
+    if (hasCatalog !== hasPlacements) {
+        throw new Error(`Game target builds must provide both mpgd.catalog.json and mpgd.ad-placements.json: ${gameRoot}`);
+    }
+    if (!hasCatalog) {
+        return {};
+    }
+    return {
+        MPGD_PRODUCT_CATALOG_FILE: catalogFile,
+        MPGD_AD_PLACEMENTS_FILE: placementsFile,
+    };
+}
+function readConfiguredPath(value) {
+    const normalized = value?.trim();
+    return normalized === undefined || normalized.length === 0 ? undefined : normalized;
+}
+function readSourceGitSha(gameRoot) {
+    const result = spawnSync('git', ['-C', gameRoot, 'rev-parse', 'HEAD'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    if (result.error !== undefined || result.status !== 0) {
+        return 'uncommitted';
+    }
+    return result.stdout.trim() || 'uncommitted';
+}
+function readGamePackageVersion(gameRoot) {
+    const packageFile = path.join(gameRoot, 'package.json');
+    if (!existsSync(packageFile)) {
+        return undefined;
+    }
+    const packageJson = readJsonForCli(packageFile);
+    if (typeof packageJson !== 'object' || packageJson === null || Array.isArray(packageJson)) {
+        return undefined;
+    }
+    return readOptionalString(packageJson.version);
+}
 function preparePlatformTargetsFile(input) {
     const parsed = readJsonForCli(input.targetsFile);
     const gameRoot = path.dirname(input.targetsFile);
@@ -1022,8 +1488,9 @@ function replaceTargetTokens(value, context) {
 function runTargetCommand(input) {
     const target = normalizeBuildTarget(input.target);
     const env = withTargetVariantEnv(target, input.variant, input.env);
+    const profile = input.profile ?? 'production';
     const args = input.action === 'build'
-        ? ['build:target', target, input.profile ?? 'production']
+        ? ['build:target', target, profile]
         : ['smoke:target', target];
     console.log(`[mpgd] ${input.action} ${target}`);
     runPnpm(args, env);

package/dist/production-target-readiness.d.ts

@@ -0,0 +1,8 @@
+export interface ProductionTargetReadinessInput {
+  readonly target: string;
+  readonly profile: string;
+  readonly targetsFile: string;
+  readonly gameRoot: string;
+  readonly gameServicesUrl?: string;
+}
+export declare function assertProductionTargetReadiness(input: ProductionTargetReadinessInput): void;