@mpgd/cli 0.6.0 → 0.8.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',
@@ -108,8 +120,6 @@ const entryCommand = defineI18n({
         ko: 'mpgd-kit 스타터와 타깃 워크플로우를 관리합니다.',
     }),
     run: () => {
-        console.log('Use a sub-command: game, target, kit.');
-        console.log('Run "pnpm mpgd --help" for available commands.');
     },
 });
 const gameCommand = defineI18n({
@@ -213,15 +223,397 @@ 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: () => {
+            },
+        }),
     },
     run: () => {
-        console.log('Use "mpgd game create <directory>".');
     },
 });
 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,
+        },
+    });
+    if (result.report.status === 'failed') {
+        throw new Error(`Game acceptance failed. Report: ${result.markdownFile}`);
+    }
+}
+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.',
@@ -243,7 +635,6 @@ const legalCommand = defineI18n({
                     ...resolveLegalCommandOptions(ctx.values),
                     check: false,
                 });
-                console.log(`Built legal site: ${result.outDir}`);
             },
         }),
         check: defineI18n({
@@ -259,12 +650,10 @@ const legalCommand = defineI18n({
                     ...resolveLegalCommandOptions(ctx.values),
                     check: true,
                 });
-                console.log(`Legal site checked: ${result.outDir}`);
             },
         }),
     },
     run: () => {
-        console.log('Use "mpgd legal build" or "mpgd legal check".');
     },
 });
 const targetCommand = defineI18n({
@@ -473,7 +862,6 @@ const targetCommand = defineI18n({
         }),
     },
     run: () => {
-        console.log('Use "mpgd target build <target>" or "mpgd target smoke <target>".');
     },
 });
 const kitCommand = defineI18n({
@@ -492,17 +880,10 @@ const kitCommand = defineI18n({
                 ko: 'CLI, kit, template, target wrapper 상태를 출력합니다.',
             }),
             run: () => {
-                console.log(`cli package: ${packageRoot}`);
-                console.log(`mpgd-kit: ${detectedKitRoot ?? 'not detected'}`);
-                console.log(`cli template: ${existsSync(gameTemplateDir) ? 'ok' : 'missing'}`);
-                console.log(`mobile wrapper: ${kitFileStatus('apps/mobile-capacitor/package.json')}`);
-                console.log(`ait wrapper: ${kitFileStatus('apps/target-ait/package.json')}`);
-                console.log(`devvit wrapper: ${kitFileStatus('apps/target-devvit/package.json')}`);
             },
         }),
     },
     run: () => {
-        console.log('Use "mpgd kit doctor".');
     },
 });
 function commandResource(description, args = {}) {
@@ -717,9 +1098,7 @@ function createGameApp(input) {
     });
     const files = collectTemplateFiles(gameTemplateDir);
     if (input.dryRun) {
-        console.log(`Would create ${path.relative(process.cwd(), appDir) || appDir}:`);
         for (const file of files) {
-            console.log(`- ${path.join(path.relative(process.cwd(), appDir), file.relativePath)}`);
         }
         return;
     }
@@ -728,19 +1107,6 @@ function createGameApp(input) {
         mkdirSync(path.dirname(outputFile), { recursive: true });
         writeFileSync(outputFile, renderTemplate(file.content, context));
     }
-    console.log(`Created ${appDir}`);
-    console.log('Next steps:');
-    console.log(`  cd ${appDir}`);
-    console.log('  pnpm install -w');
-    console.log('  pnpm dev');
-    console.log('Target builds require an mpgd-kit checkout:');
-    console.log([
-        '  mpgd target build-all',
-        `--targets-file ${path.join(appDir, 'mpgd.targets.json')}`,
-        `--targets ${recommendedMatrixTargets}`,
-        '--ait-variant wrapper',
-        '--kit-path <path-to-mpgd-kit>',
-    ].join(' '));
 }
 function assertValidGameName(name) {
     if (!/^[a-z][a-z0-9-]*$/.test(name)) {
@@ -1010,7 +1376,7 @@ function readConfiguredPath(value) {
     return normalized === undefined || normalized.length === 0 ? undefined : normalized;
 }
 function readSourceGitSha(gameRoot) {
-    const result = spawnSync('git', ['-C', gameRoot, 'rev-parse', '--short', 'HEAD'], {
+    const result = spawnSync('git', ['-C', gameRoot, 'rev-parse', 'HEAD'], {
         encoding: 'utf8',
         stdio: ['ignore', 'pipe', 'ignore'],
     });
@@ -1088,10 +1454,10 @@ 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);
 }
 function runTargetMatrix(input) {

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;