@mpgd/cli 0.3.2 → 0.4.1

package/dist/index.js

@@ -11,12 +11,38 @@ const packageRoot = resolvePackageRoot(sourceDir);
 const detectedKitRoot = resolveDefaultKitRoot();
 const gameTemplateDir = path.resolve(packageRoot, 'templates/phaser-game');
 const cliVersion = readPackageVersion(packageRoot);
-const defaultMatrixTargets = 'web,ait,reddit';
+const recommendedMatrixTargets = 'web,microsoft-store,ait,reddit';
 const defaultDependencyVersion = `^${cliVersion}`;
+const mpgdTemplateDependencyPackages = [
+    { name: '@mpgd/adapter-ait', packageDir: 'adapters/ait' },
+    { name: '@mpgd/adapter-browser', packageDir: 'adapters/browser' },
+    { name: '@mpgd/adapter-capacitor', packageDir: 'adapters/capacitor' },
+    { name: '@mpgd/adapter-devvit', packageDir: 'adapters/devvit' },
+    { name: '@mpgd/analytics', packageDir: 'packages/analytics' },
+    { name: '@mpgd/bridge', packageDir: 'packages/bridge' },
+    { name: '@mpgd/catalog', packageDir: 'packages/catalog' },
+    { name: '@mpgd/cli', packageDir: 'packages/cli' },
+    { name: '@mpgd/game-services', packageDir: 'packages/game-services' },
+    { name: '@mpgd/i18n', packageDir: 'packages/i18n' },
+    { name: '@mpgd/phaser-assets', packageDir: 'packages/phaser-assets' },
+    { name: '@mpgd/platform', packageDir: 'packages/platform' },
+    { name: '@mpgd/target-config', packageDir: 'packages/target-config' },
+];
+const recommendedMatrixTargetOrder = ['web-preview', 'microsoft-store', 'ait', 'reddit'];
+const allMatrixTargetOrder = [
+    'web-preview',
+    'microsoft-store',
+    'android',
+    'ios',
+    'ait',
+    'reddit',
+];
 const supportedBuildTargets = [
     'browser',
     'web',
     'web-preview',
+    'microsoft-store',
+    'msstore',
     'android',
     'ios',
     'ait',
@@ -30,6 +56,7 @@ export async function runMpgdCli(args) {
         version: cliVersion,
         subCommands: {
             game: gameCommand,
+            legal: legalCommand,
             target: targetCommand,
             kit: kitCommand,
         },
@@ -148,8 +175,7 @@ const gameCommand = defineI18n({
                 'dependency-version': {
                     type: 'string',
                     required: false,
-                    default: defaultDependencyVersion,
-                    description: 'Version range for @mpgd packages.',
+                    description: 'Override version range for every @mpgd package.',
                 },
                 workspace: {
                     type: 'boolean',
@@ -174,13 +200,13 @@ const gameCommand = defineI18n({
                 const packageName = readOptionalString(ctx.values['package-name']);
                 const dependencyVersion = ctx.values.workspace === true
                     ? 'workspace:*'
-                    : (readOptionalString(ctx.values['dependency-version']) ?? defaultDependencyVersion);
+                    : readOptionalString(ctx.values['dependency-version']);
                 const kitPath = readGameCreateKitPath(ctx.values, ctx.values.workspace === true);
                 createGameApp({
                     directory,
                     ...(title === undefined ? {} : { title }),
                     ...(packageName === undefined ? {} : { packageName }),
-                    dependencyVersion,
+                    ...(dependencyVersion === undefined ? {} : { dependencyVersion }),
                     workspace: ctx.values.workspace === true,
                     ...(kitPath === undefined ? {} : { kitPath }),
                     dryRun: ctx.values['dry-run'] === true,
@@ -192,6 +218,55 @@ const gameCommand = defineI18n({
         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(', ');
+const legalCommand = defineI18n({
+    name: 'legal',
+    description: 'Build static legal/support pages for store and release evidence.',
+    resource: commandResource({
+        en: 'Build static legal/support pages for store and release evidence.',
+        ko: '스토어와 출시 증빙용 정적 약관/지원 페이지를 빌드합니다.',
+    }),
+    subCommands: {
+        build: defineI18n({
+            name: 'build',
+            description: 'Build privacy, support, and terms HTML pages.',
+            resource: commandResource({
+                en: 'Build privacy, support, and terms HTML pages.',
+                ko: 'privacy, support, terms HTML 페이지를 빌드합니다.',
+            }, legalArgResources()),
+            args: legalArgs(),
+            run: (ctx) => {
+                const result = buildLegalSite({
+                    ...resolveLegalCommandOptions(ctx.values),
+                    check: false,
+                });
+                console.log(`Built legal site: ${result.outDir}`);
+            },
+        }),
+        check: defineI18n({
+            name: 'check',
+            description: 'Check generated legal pages are current.',
+            resource: commandResource({
+                en: 'Check generated legal pages are current.',
+                ko: '생성된 legal 페이지가 최신인지 확인합니다.',
+            }, legalArgResources()),
+            args: legalArgs(),
+            run: (ctx) => {
+                const result = buildLegalSite({
+                    ...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({
     name: 'target',
     description: 'Build and smoke target artifacts with generated game target config.',
@@ -311,7 +386,6 @@ const targetCommand = defineI18n({
                 targets: {
                     type: 'string',
                     required: false,
-                    default: defaultMatrixTargets,
                     description: 'Comma-separated target list, or all.',
                 },
                 profile: {
@@ -337,11 +411,12 @@ const targetCommand = defineI18n({
             run: (ctx) => {
                 const aitVariant = readOptionalString(ctx.values['ait-variant']);
                 const iosVariant = readOptionalString(ctx.values['ios-variant']);
+                const env = createTargetCommandEnv(ctx.values);
                 runTargetMatrix({
                     action: 'build',
-                    targets: parseTargetList(readOptionalString(ctx.values.targets)),
+                    targets: parseTargetList(readOptionalString(ctx.values.targets), env),
                     profile: readOptionalString(ctx.values.profile) ?? 'production',
-                    env: createTargetCommandEnv(ctx.values),
+                    env,
                     ...(aitVariant === undefined ? {} : { aitVariant }),
                     ...(iosVariant === undefined ? {} : { iosVariant }),
                 });
@@ -358,16 +433,41 @@ const targetCommand = defineI18n({
                 targets: {
                     type: 'string',
                     required: false,
-                    default: defaultMatrixTargets,
                     description: 'Comma-separated target list, or all.',
                 },
                 ...targetConfigArgs(),
             },
             run: (ctx) => {
+                const env = createTargetCommandEnv(ctx.values);
                 runTargetMatrix({
                     action: 'smoke',
-                    targets: parseTargetList(readOptionalString(ctx.values.targets)),
-                    env: createTargetCommandEnv(ctx.values),
+                    targets: parseTargetList(readOptionalString(ctx.values.targets), env),
+                    env,
+                });
+            },
+        }),
+        doctor: defineI18n({
+            name: 'doctor',
+            description: 'Verify existing target artifacts and game-owned output paths.',
+            resource: commandResource({
+                en: 'Verify existing target artifacts and game-owned output paths.',
+                ko: '기존 타깃 산출물과 게임 소유 출력 경로를 검증합니다.',
+            }, matrixArgResources()),
+            args: {
+                targets: {
+                    type: 'string',
+                    required: false,
+                    default: 'all',
+                    description: 'Comma-separated target list, or all.',
+                },
+                ...targetConfigArgs(),
+            },
+            run: (ctx) => {
+                const env = createTargetCommandEnv(ctx.values);
+                runTargetMatrix({
+                    action: 'smoke',
+                    targets: parseTargetList(readOptionalString(ctx.values.targets) ?? 'all', env),
+                    env,
                 });
             },
         }),
@@ -470,20 +570,146 @@ function matrixArgResources() {
         },
     };
 }
+function legalArgs() {
+    return {
+        'legal-dir': {
+            type: 'string',
+            required: false,
+            default: defaultLegalDir,
+            description: `Directory containing ${legalPageFileList}.`,
+        },
+        'out-dir': {
+            type: 'string',
+            required: false,
+            default: defaultLegalOutDir,
+            description: 'Output directory for the static legal site.',
+        },
+    };
+}
+function legalArgResources() {
+    return {
+        'legal-dir': {
+            en: `Directory containing ${legalPageFileList}.`,
+            ko: `${legalPageFileList} 이 있는 디렉터리.`,
+        },
+        'out-dir': {
+            en: 'Output directory for the static legal site.',
+            ko: '정적 legal 사이트 출력 디렉터리.',
+        },
+    };
+}
+function resolveLegalCommandOptions(values) {
+    return {
+        legalDir: readOptionalString(values['legal-dir']) ?? defaultLegalDir,
+        outDir: readOptionalString(values['out-dir']) ?? defaultLegalOutDir,
+    };
+}
+function buildLegalSite(input) {
+    const legalDir = path.resolve(process.cwd(), input.legalDir);
+    const outDir = path.resolve(process.cwd(), input.outDir);
+    const outputs = createLegalSiteOutputs(legalDir, outDir);
+    if (input.check) {
+        const stale = outputs.filter((output) => {
+            if (!existsSync(output.file)) {
+                return true;
+            }
+            return readFileSync(output.file, 'utf8') !== output.content;
+        });
+        if (stale.length > 0) {
+            throw new Error([
+                'Legal site output is stale. Run "mpgd legal build".',
+                ...stale.map((output) => `- ${path.relative(process.cwd(), output.file)}`),
+            ].join('\n'));
+        }
+        return {
+            outDir,
+        };
+    }
+    for (const output of outputs) {
+        mkdirSync(path.dirname(output.file), { recursive: true });
+        writeFileSync(output.file, output.content);
+    }
+    return {
+        outDir,
+    };
+}
+function createLegalSiteOutputs(legalDir, outDir) {
+    const relativeLegalDir = path.relative(process.cwd(), legalDir);
+    const relativeOutDir = path.relative(process.cwd(), outDir);
+    if (relativeLegalDir.startsWith('..') || path.isAbsolute(relativeLegalDir)) {
+        throw new Error(`legal-dir must be inside the project root: ${legalDir}`);
+    }
+    if (relativeOutDir.startsWith('..') || path.isAbsolute(relativeOutDir)) {
+        throw new Error(`out-dir must be inside the project root: ${outDir}`);
+    }
+    const sourceRoot = toTemplatePath(relativeLegalDir || '.');
+    const outputs = legalPageSlugs.map((slug) => {
+        const sourceFile = path.join(legalDir, `${slug}.html`);
+        if (!existsSync(sourceFile)) {
+            throw new Error(`Missing legal page source: ${sourceFile}`);
+        }
+        return {
+            file: path.join(outDir, slug, 'index.html'),
+            content: normalizeLegalHtml(readFileSync(sourceFile, 'utf8'), sourceFile),
+        };
+    });
+    return [
+        ...outputs,
+        {
+            file: path.join(outDir, '_headers'),
+            content: [
+                '/*',
+                '  X-Content-Type-Options: nosniff',
+                '  Referrer-Policy: strict-origin-when-cross-origin',
+                '  Cache-Control: public, max-age=300',
+                '',
+            ].join('\n'),
+        },
+        {
+            file: path.join(outDir, '_redirects'),
+            content: [
+                '/ /support/ 302',
+                '/privacy /privacy/ 301',
+                '/support /support/ 301',
+                '/terms /terms/ 301',
+                '',
+            ].join('\n'),
+        },
+        {
+            file: path.join(outDir, 'legal-site.json'),
+            content: `${JSON.stringify({
+                version: 1,
+                pages: legalPageSlugs.map((slug) => ({
+                    slug,
+                    path: `/${slug}/`,
+                    source: `${sourceRoot}/${slug}.html`,
+                })),
+            }, null, 2)}\n`,
+        },
+    ];
+}
+function normalizeLegalHtml(content, sourceFile) {
+    if (!/^<!doctype html>/iu.test(content) || !/<html[\s>]/iu.test(content)) {
+        throw new Error(`${sourceFile} must be a complete HTML document.`);
+    }
+    return content.endsWith('\n') ? content : `${content}\n`;
+}
 function createGameApp(input) {
     const appDir = resolveAppDirectory(input.directory);
     const gameName = path.basename(appDir);
     assertValidGameName(gameName);
     const packageName = input.packageName ?? gameName;
     assertValidPackageName(packageName);
-    assertValidDependencyVersion(input.dependencyVersion);
+    if (input.dependencyVersion !== undefined) {
+        assertValidDependencyVersion(input.dependencyVersion);
+    }
     if (existsSync(appDir)) {
         throw new Error(`Game directory already exists: ${appDir}`);
     }
     const context = createTemplateContext({
         gameName,
         packageName,
-        dependencyVersion: input.dependencyVersion,
+        ...(input.dependencyVersion === undefined ? {} : { dependencyVersion: input.dependencyVersion }),
         appDir,
         workspace: input.workspace,
         ...(input.kitPath === undefined ? {} : { kitPath: input.kitPath }),
@@ -505,13 +731,13 @@ function createGameApp(input) {
     console.log(`Created ${appDir}`);
     console.log('Next steps:');
     console.log(`  cd ${appDir}`);
-    console.log('  pnpm install --filter . --filter ./apps/target-devvit');
+    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 ${defaultMatrixTargets}`,
+        `--targets ${recommendedMatrixTargets}`,
         '--ait-variant wrapper',
         '--kit-path <path-to-mpgd-kit>',
     ].join(' '));
@@ -535,10 +761,13 @@ function assertValidPackageName(name) {
     }
 }
 function assertValidDependencyVersion(version) {
-    if (!/^(?:workspace:\*|[~^]?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)$/.test(version)) {
+    if (!isValidDependencyVersion(version)) {
         throw new Error('Dependency version must be workspace:* or a semver version/range such as ^0.1.0.');
     }
 }
+function isValidDependencyVersion(version) {
+    return /^(?:workspace:\*|[~^]?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)$/.test(version);
+}
 function createTemplateContext(input) {
     const title = input.title === undefined || input.title.length === 0 ? input.gameName : input.title;
     assertValidGameTitle(title);
@@ -553,8 +782,16 @@ function createTemplateContext(input) {
         devvitAppName: toDevvitAppName(input.gameName),
         gameTitle: title,
         gameTitleTsLiteral: toJavaScriptStringLiteral(title),
+        legalLastUpdated: new Date().toISOString().slice(0, 10),
         packageName: input.packageName,
-        dependencyVersion: input.dependencyVersion,
+        defaultDependencyVersion: input.dependencyVersion ?? defaultDependencyVersion,
+        mpgdDependencyVersionReplacements: resolveMpgdDependencyVersionReplacements({
+            ...(input.dependencyVersion === undefined
+                ? {}
+                : { overrideVersion: input.dependencyVersion }),
+            workspace: input.workspace,
+            ...(kitPath === undefined ? {} : { kitPath }),
+        }),
         tsconfigExtendsLine: input.workspace
             ? `  "extends": "${workspacePrefix}/tsconfig.base.json",`
             : '',
@@ -589,6 +826,43 @@ function createTemplateContext(input) {
         camelName: toCamelCase(input.gameName),
     };
 }
+function resolveMpgdDependencyVersionReplacements(input) {
+    const packageJson = readPackageJsonOrUndefined(packageRoot, { strictParse: true });
+    const kitRoot = input.kitPath ?? detectedKitRoot;
+    return mpgdTemplateDependencyPackages.map((dependency) => {
+        const version = input.overrideVersion
+            ?? (input.workspace ? 'workspace:*' : undefined)
+            ?? resolvePublishedTemplateDependencyVersion(dependency.name, packageJson)
+            ?? resolveWorkspaceTemplateDependencyVersion(kitRoot, dependency.packageDir)
+            ?? defaultDependencyVersion;
+        return {
+            placeholder: mpgdDependencyVersionPlaceholder(dependency.name),
+            version,
+        };
+    });
+}
+function resolvePublishedTemplateDependencyVersion(packageName, packageJson) {
+    if (packageName === '@mpgd/cli') {
+        return `^${cliVersion}`;
+    }
+    const version = packageJson?.devDependencies?.[packageName];
+    return version !== undefined && version !== 'workspace:*' && isValidDependencyVersion(version)
+        ? version
+        : undefined;
+}
+function resolveWorkspaceTemplateDependencyVersion(kitRoot, packageDir) {
+    if (kitRoot === undefined) {
+        return undefined;
+    }
+    const version = readPackageVersion(path.join(kitRoot, packageDir));
+    return version === '0.0.0' ? undefined : `^${version}`;
+}
+function mpgdDependencyVersionPlaceholder(packageName) {
+    return `__MPGD_DEPENDENCY_VERSION_${packageName
+        .replace(/^@mpgd\//, '')
+        .replaceAll('-', '_')
+        .toUpperCase()}__`;
+}
 function assertValidGameTitle(title) {
     if (title.trim().length === 0) {
         throw new Error('Game title cannot be empty.');
@@ -617,13 +891,14 @@ function walkTemplateDir(templateDir, relativeDir, files) {
     }
 }
 function renderTemplate(content, context) {
-    return content
+    let rendered = content
         .replaceAll('__GAME_NAME__', context.gameName)
         .replaceAll('__DEVVIT_APP_NAME__', context.devvitAppName)
         .replaceAll('__GAME_TITLE_TS_LITERAL__', context.gameTitleTsLiteral)
         .replaceAll('__GAME_TITLE__', context.gameTitle)
+        .replaceAll('__LEGAL_LAST_UPDATED__', context.legalLastUpdated)
         .replaceAll('__PACKAGE_NAME__', context.packageName)
-        .replaceAll('__MPGD_DEPENDENCY_VERSION__', context.dependencyVersion)
+        .replaceAll('__MPGD_DEPENDENCY_VERSION__', context.defaultDependencyVersion)
         .replaceAll('__TSCONFIG_EXTENDS_LINE__', context.tsconfigExtendsLine)
         .replaceAll('__TSCONFIG_WORKSPACE_INCLUDES__', context.tsconfigWorkspaceIncludes)
         .replaceAll('__TSCONFIG_WORKSPACE_EXCLUDES__', context.tsconfigWorkspaceExcludes)
@@ -632,6 +907,10 @@ function renderTemplate(content, context) {
         .replaceAll('__PNPM_WORKSPACE_KIT_PACKAGES__', context.pnpmWorkspaceKitPackages)
         .replaceAll('__PASCAL_NAME__', context.pascalName)
         .replaceAll('__CAMEL_NAME__', context.camelName);
+    for (const replacement of context.mpgdDependencyVersionReplacements) {
+        rendered = rendered.replaceAll(replacement.placeholder, replacement.version);
+    }
+    return rendered;
 }
 function templateOutputPath(relativePath) {
     return path.basename(relativePath) === 'gitignore'
@@ -792,10 +1071,13 @@ function withTargetVariantEnv(target, variant, env) {
     }
     return env;
 }
-function parseTargetList(value) {
-    const raw = value ?? defaultMatrixTargets;
+function parseTargetList(value, env) {
+    const raw = (value ?? 'default').trim();
     if (raw === 'all') {
-        return ['web-preview', 'android', 'ios', 'ait', 'reddit'];
+        return configuredTargetsForOrder(env, allMatrixTargetOrder, 'all');
+    }
+    if (raw === 'default') {
+        return configuredTargetsForOrder(env, recommendedMatrixTargetOrder, 'default');
     }
     const targets = raw
         .split(',')
@@ -807,10 +1089,50 @@ function parseTargetList(value) {
     }
     return [...new Set(targets)];
 }
+function configuredTargetsForOrder(env, order, label) {
+    const configuredTargets = readConfiguredBuildTargets(env);
+    const targets = order.filter((target) => configuredTargets.has(target));
+    if (targets.length === 0) {
+        throw new Error(`No ${label} targets are configured in ${readConfiguredTargetsFile(env)}.`);
+    }
+    return targets;
+}
+function readConfiguredBuildTargets(env) {
+    const file = readConfiguredTargetsFile(env);
+    const parsed = readJsonForCli(file);
+    assertJsonObject(parsed, `targets file ${file}`);
+    assertJsonObject(parsed.targets, `targets in ${file}`);
+    const targets = new Set();
+    for (const target of Object.keys(parsed.targets)) {
+        const normalized = normalizeConfiguredBuildTarget(target);
+        if (normalized !== undefined) {
+            targets.add(normalized);
+        }
+    }
+    return targets;
+}
+function readConfiguredTargetsFile(env) {
+    const file = env.MPGD_PLATFORM_TARGETS_FILE;
+    if (file === undefined || file.length === 0) {
+        throw new Error('Missing MPGD_PLATFORM_TARGETS_FILE.');
+    }
+    return file;
+}
+function normalizeConfiguredBuildTarget(target) {
+    try {
+        return normalizeBuildTarget(target);
+    }
+    catch {
+        return undefined;
+    }
+}
 function normalizeBuildTarget(target) {
     if (target === 'browser' || target === 'web') {
         return 'web-preview';
     }
+    if (target === 'msstore') {
+        return 'microsoft-store';
+    }
     if (target === 'devvit') {
         return 'reddit';
     }
@@ -819,6 +1141,11 @@ function normalizeBuildTarget(target) {
     }
     return target;
 }
+function assertJsonObject(input, label) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        throw new Error(`${label} must be an object.`);
+    }
+}
 function runPnpm(args, commandEnv) {
     const kitPath = commandEnv.MPGD_KIT_PATH;
     if (kitPath === undefined || kitPath.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/cli",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "description": "Gunshi CLI for mpgd-kit starter generation and target workflow orchestration.",
   "license": "MIT",
   "repository": {
@@ -48,7 +48,19 @@
   "devDependencies": {
     "@types/node": "^24.0.0",
     "ttsc": "0.16.9",
-    "typescript": "7.0.1-rc"
+    "typescript": "7.0.1-rc",
+    "@mpgd/adapter-ait": "0.3.3",
+    "@mpgd/adapter-browser": "0.3.2",
+    "@mpgd/adapter-capacitor": "0.3.3",
+    "@mpgd/analytics": "0.3.2",
+    "@mpgd/adapter-devvit": "0.3.3",
+    "@mpgd/bridge": "0.4.0",
+    "@mpgd/catalog": "0.3.2",
+    "@mpgd/phaser-assets": "0.4.0",
+    "@mpgd/platform": "0.3.2",
+    "@mpgd/target-config": "0.3.4",
+    "@mpgd/i18n": "0.3.3",
+    "@mpgd/game-services": "0.3.3"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",