@mpgd/cli 0.14.0 → 0.15.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, writeFileSync, } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import completion from '@gunshi/plugin-completion';
@@ -10,6 +10,7 @@ import { defaultGameAcceptanceCommandTimeoutMs, resolveGameAcceptanceReleaseMani
 import { resolveGameplayE2EReportFile } from './gameplay-e2e.js';
 import { createMicrosoftStorePackageAcceptanceRuntime, runMicrosoftStorePackageAcceptance, } from './microsoft-store-package-acceptance.js';
 import { runMicrosoftStorePackageGeneration } from './microsoft-store-package-generation.js';
+import { defaultMpgdKitPath, initializeMicrosoftStoreStarter, listMicrosoftStoreInitializerTemplateFiles, prepareBaseGameTemplateFile, } from './microsoft-store-starter.js';
 import { runMicrosoftStoreSubmissionPreflight } from './microsoft-store-submission.js';
 export { renderGameAcceptanceMarkdown, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, defaultGameAcceptanceCommandTimeoutMs, maximumGameplayE2EReportBytes, } from './game-acceptance.js';
 export { createBrowserGameplayE2EDriver, } from './browser-gameplay-e2e.js';
@@ -25,6 +26,10 @@ const detectedKitRoot = resolveDefaultKitRoot();
 const gameTemplateDir = path.resolve(packageRoot, 'templates/phaser-game');
 const cliVersion = readPackageVersion(packageRoot);
 const recommendedMatrixTargets = 'web,microsoft-store,verse8,ait,reddit';
+const recommendedMatrixTargetsWithoutMicrosoftStore = recommendedMatrixTargets
+    .split(',')
+    .filter((target) => target !== 'microsoft-store')
+    .join(',');
 const defaultDependencyVersion = `^${cliVersion}`;
 const standaloneTemplateDependencyVersionFallbacks = {
     // Initial-published independently from the CLI release line; package metadata wins once concrete.
@@ -189,6 +194,10 @@ const gameCommand = defineI18n({
                     en: 'Print files that would be generated without writing them.',
                     ko: '파일을 쓰지 않고 생성 예정 목록만 출력합니다.',
                 },
+                'microsoft-store': {
+                    en: 'Include the Microsoft Store PWA target and release workflow.',
+                    ko: 'Microsoft Store PWA 타깃과 출시 워크플로를 포함합니다.',
+                },
             }),
             args: {
                 directory: {
@@ -226,6 +235,11 @@ const gameCommand = defineI18n({
                     required: false,
                     description: 'Print files that would be generated without writing them.',
                 },
+                'microsoft-store': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Include the Microsoft Store PWA target and release workflow.',
+                },
             },
             run: (ctx) => {
                 const positionals = readLocalPositionals(ctx.positionals, ['game', 'create']);
@@ -244,6 +258,7 @@ const gameCommand = defineI18n({
                     workspace: ctx.values.workspace === true,
                     ...(kitPath === undefined ? {} : { kitPath }),
                     dryRun: ctx.values['dry-run'] === true,
+                    microsoftStore: ctx.values['microsoft-store'] === true,
                 });
             },
         }),
@@ -739,6 +754,79 @@ const targetCommand = defineI18n({
         ko: '타깃 출시 산출물을 빌드하고 스모크, 패키지 생성, 제출 사전 검증 및 인수 검증을 수행합니다.',
     }),
     subCommands: {
+        init: defineI18n({
+            name: 'init',
+            description: 'Initialize an optional target workflow in an existing game.',
+            resource: commandResource({
+                en: 'Initialize an optional target workflow in an existing game without overwriting conflicts.',
+                ko: '충돌 파일을 덮어쓰지 않고 기존 게임에 선택적 타깃 워크플로를 초기화합니다.',
+            }, {
+                target: {
+                    en: 'Target to initialize. Currently supports microsoft-store.',
+                    ko: '초기화할 타깃. 현재 microsoft-store를 지원합니다.',
+                },
+                game: {
+                    en: 'Existing game root. Defaults to the current directory.',
+                    ko: '기존 게임 루트. 기본값은 현재 디렉터리입니다.',
+                },
+                'kit-path': {
+                    en: 'Default mpgd-kit path written into generated target scripts.',
+                    ko: '생성되는 타깃 스크립트에 기록할 기본 mpgd-kit 경로.',
+                },
+                'dry-run': {
+                    en: 'Validate and print planned file changes without writing them.',
+                    ko: '파일을 쓰지 않고 예정 변경을 검증하고 출력합니다.',
+                },
+            }),
+            args: {
+                target: {
+                    type: 'positional',
+                    required: true,
+                    description: 'Target to initialize. Currently supports microsoft-store.',
+                },
+                game: {
+                    type: 'string',
+                    required: false,
+                    default: '.',
+                    description: 'Existing game root. Defaults to the current directory.',
+                },
+                'kit-path': {
+                    type: 'string',
+                    required: false,
+                    description: 'Default mpgd-kit path written into generated target scripts.',
+                },
+                'dry-run': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Validate and print planned file changes without writing them.',
+                },
+            },
+            run: (ctx) => {
+                const positionals = readLocalPositionals(ctx.positionals, ['target', 'init']);
+                const requestedTarget = readRequiredPositional(positionals, 0, 'target');
+                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) ?? '.');
+                const configuredKitPath = readOptionalString(ctx.values['kit-path']);
+                const resolvedKitPath = configuredKitPath === undefined
+                    ? detectedKitRoot
+                    : assertKitRoot(path.resolve(configuredKitPath));
+                const defaultKitPath = resolvedKitPath === undefined
+                    ? defaultMpgdKitPath
+                    : toTemplatePath(path.relative(gameRoot, resolvedKitPath) || '.');
+                const dryRun = ctx.values['dry-run'] === true;
+                const result = initializeMicrosoftStoreStarter({
+                    gameRoot,
+                    templateRoot: gameTemplateDir,
+                    defaultKitPath,
+                    dryRun,
+                });
+                for (const file of result.changedFiles) {
+                }
+            },
+        }),
         build: defineI18n({
             name: 'build',
             description: 'Build one target artifact.',
@@ -1483,17 +1571,54 @@ function createGameApp(input) {
         workspace: input.workspace,
         ...(input.kitPath === undefined ? {} : { kitPath: input.kitPath }),
         ...(input.title === undefined ? {} : { title: input.title }),
+        microsoftStore: input.microsoftStore,
+    });
+    const files = collectTemplateFiles(gameTemplateDir).flatMap((file) => {
+        const prepared = prepareBaseGameTemplateFile({
+            relativePath: file.relativePath,
+            content: file.content,
+        });
+        return prepared === undefined
+            ? []
+            : [{ ...file, content: renderTemplate(prepared, context) }];
     });
-    const files = collectTemplateFiles(gameTemplateDir);
     if (input.dryRun) {
-        for (const file of files) {
+        const plannedFiles = input.microsoftStore
+            ? [...files.map((file) => file.relativePath), ...listMicrosoftStoreInitializerTemplateFiles()]
+            : files.map((file) => file.relativePath);
+        for (const relativePath of [...new Set(plannedFiles)].sort()) {
         }
         return;
     }
-    for (const file of files) {
-        const outputFile = path.join(appDir, file.relativePath);
-        mkdirSync(path.dirname(outputFile), { recursive: true });
-        writeFileSync(outputFile, renderTemplate(file.content, context));
+    let createdAppDirectory = false;
+    try {
+        mkdirSync(path.dirname(appDir), { recursive: true });
+        mkdirSync(appDir);
+        createdAppDirectory = true;
+        for (const file of files) {
+            const outputFile = path.join(appDir, file.relativePath);
+            mkdirSync(path.dirname(outputFile), { recursive: true });
+            writeFileSync(outputFile, file.content);
+        }
+        if (input.microsoftStore) {
+            initializeMicrosoftStoreStarter({
+                gameRoot: appDir,
+                templateRoot: gameTemplateDir,
+                defaultKitPath: context.defaultKitPath,
+                dryRun: false,
+            });
+        }
+    }
+    catch (error) {
+        if (createdAppDirectory) {
+            try {
+                rmSync(appDir, { force: true, recursive: true });
+            }
+            catch (cleanupError) {
+                console.warn(`Failed to clean up incomplete game directory ${appDir}: ${formatError(cleanupError)}`);
+            }
+        }
+        throw error;
     }
 }
 function assertValidGameName(name) {
@@ -1567,7 +1692,10 @@ function createTemplateContext(input) {
         workspaceI18nBuildPrefix: input.workspace
             ? `pnpm --dir ${workspacePrefix} i18n:build && `
             : '',
-        defaultKitPath: kitPath === undefined ? '../mpgd-kit' : workspacePrefix,
+        defaultKitPath: kitPath === undefined ? defaultMpgdKitPath : workspacePrefix,
+        recommendedMatrixTargets: input.microsoftStore
+            ? recommendedMatrixTargets
+            : recommendedMatrixTargetsWithoutMicrosoftStore,
         pnpmWorkspaceKitPackages: input.workspace
             ? [
                 `  - '${workspacePrefix}/packages/*'`,
@@ -1659,6 +1787,7 @@ function renderTemplate(content, context) {
         .replaceAll('__TSCONFIG_WORKSPACE_EXCLUDES__', context.tsconfigWorkspaceExcludes)
         .replaceAll('__WORKSPACE_I18N_BUILD_PREFIX__', context.workspaceI18nBuildPrefix)
         .replaceAll('__DEFAULT_KIT_PATH__', context.defaultKitPath)
+        .replaceAll('__RECOMMENDED_MATRIX_TARGETS__', context.recommendedMatrixTargets)
         .replaceAll('__PNPM_WORKSPACE_KIT_PACKAGES__', context.pnpmWorkspaceKitPackages)
         .replaceAll('__PASCAL_NAME__', context.pascalName)
         .replaceAll('__CAMEL_NAME__', context.camelName);

package/dist/microsoft-store-starter.d.ts

@@ -0,0 +1,28 @@
+export declare const microsoftStoreBlockStart = "<!-- mpgd:microsoft-store:start -->";
+export declare const microsoftStoreBlockEnd = "<!-- mpgd:microsoft-store:end -->";
+export declare const defaultMpgdKitPath = "../mpgd-kit";
+export declare const microsoftStoreDocumentationAnchors: {
+  readonly 'README.md': '- Verse8 is a game-owned iframe web target';
+  readonly 'agent/acceptance.md': '## Verse8 Agent8 Structured Server';
+  readonly 'agent/brief.md': undefined;
+};
+export interface InitializeMicrosoftStoreStarterInput {
+  readonly gameRoot: string;
+  readonly templateRoot: string;
+  readonly defaultKitPath: string;
+  readonly dryRun: boolean;
+}
+export interface InitializeMicrosoftStoreStarterResult {
+  readonly changedFiles: readonly string[];
+}
+interface MicrosoftStoreStarterApplyRuntime {
+  readonly beforeCommit?: (relativePath: string) => void;
+  readonly beforeRollbackEntry?: (relativePath: string) => void;
+}
+export declare function prepareBaseGameTemplateFile(input: {
+  readonly relativePath: string;
+  readonly content: string;
+}): string | undefined;
+export declare function listMicrosoftStoreInitializerTemplateFiles(): readonly string[];
+export declare function initializeMicrosoftStoreStarter(input: InitializeMicrosoftStoreStarterInput, runtime?: MicrosoftStoreStarterApplyRuntime): InitializeMicrosoftStoreStarterResult;
+export {};