@mpgd/cli 0.35.0 → 0.36.1

package/dist/kit-upgrade-target-readiness.d.ts

@@ -0,0 +1,8 @@
+export interface KitUpgradeTargetAdvisory {
+  readonly target: string;
+  readonly kind: 'missing-product-id' | 'missing-placement-id' | 'not-assessed';
+  readonly logicalId?: string;
+  readonly message: string;
+}
+/** Read-only hints, not a substitute for target validation after an upgrade. */
+export declare function inspectKitUpgradeTargetReadiness(gameRoot: string, targetsFile: string): readonly KitUpgradeTargetAdvisory[];

package/dist/kit-upgrade-target-readiness.js

@@ -0,0 +1,119 @@
+import { existsSync, lstatSync, readFileSync, realpathSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { assertAdPlacements, assertProductCatalog } from '@mpgd/catalog';
+import { assertTargetConfigMatrix, createEffectiveTargetConfig } from '@mpgd/target-config';
+const require = createRequire(import.meta.url);
+/** Read-only hints, not a substitute for target validation after an upgrade. */
+export function inspectKitUpgradeTargetReadiness(gameRoot, targetsFile) {
+    if (!existsSync(targetsFile)) {
+        return [notAssessed('*', 'No game-owned targets file is available.')];
+    }
+    if (process.env.MPGD_PRODUCT_CATALOG_FILE?.trim()
+        || process.env.MPGD_AD_PLACEMENTS_FILE?.trim()) {
+        const message = 'Custom catalog or placement paths are not inspected; '
+            + 'validate targets after upgrading.';
+        return [notAssessed('*', message)];
+    }
+    try {
+        const configured = asRecord(readGameOwnedJsonFile(gameRoot, targetsFile), 'targets file');
+        const targets = asRecord(configured.targets, 'targets');
+        const baseFile = require.resolve('@mpgd/target-config/targets.json');
+        const base = assertTargetConfigMatrix(JSON.parse(readFileSync(baseFile, 'utf8')));
+        const catalogFile = path.join(gameRoot, 'mpgd.catalog.json');
+        const placementsFile = path.join(gameRoot, 'mpgd.ad-placements.json');
+        if (existsSync(catalogFile) !== existsSync(placementsFile)) {
+            return [notAssessed('*', 'Default mpgd.catalog.json and mpgd.ad-placements.json must be present together; '
+                    + 'custom paths are not assessed.')];
+        }
+        const catalog = existsSync(catalogFile)
+            ? assertProductCatalog(readGameOwnedJsonFile(gameRoot, catalogFile))
+            : assertProductCatalog({ version: 'none', products: [] });
+        const placements = existsSync(placementsFile)
+            ? assertAdPlacements(readGameOwnedJsonFile(gameRoot, placementsFile))
+            : assertAdPlacements({ version: 'none', placements: [] });
+        const advisories = [];
+        for (const target of Object.keys(targets).sort()) {
+            const policy = base.targets[target];
+            if (policy === undefined) {
+                const message = 'No built-in runtime policy is available; '
+                    + 'validate this custom target after upgrading.';
+                advisories.push(notAssessed(target, message));
+                continue;
+            }
+            try {
+                const platform = asRecord(targets[target], `target ${target}`);
+                const effective = createEffectiveTargetConfig({
+                    target,
+                    targetConfigVersion: base.version,
+                    config: policy,
+                    catalog,
+                    adPlacements: placements,
+                    platformTarget: {
+                        kind: String(platform.kind ?? ''),
+                        adapter: String(platform.adapter ?? ''),
+                        ...(platform.authoritativeGameServices === false
+                            ? { authoritativeGameServices: false }
+                            : {}),
+                    },
+                });
+                // Devvit validates product SKUs against its wrapper contract, not catalog platform IDs.
+                if (effective.runtime !== 'devvit-web') {
+                    for (const product of effective.monetization.products) {
+                        if (product.reason === 'missing-platform-id') {
+                            advisories.push({
+                                target,
+                                kind: 'missing-product-id',
+                                logicalId: product.id,
+                                message: `Product ${product.id} needs platformProductIds.${target}.`,
+                            });
+                        }
+                    }
+                }
+                for (const placement of effective.ads.placements) {
+                    if (placement.reason === 'missing-platform-id') {
+                        advisories.push({
+                            target,
+                            kind: 'missing-placement-id',
+                            logicalId: placement.id,
+                            message: `Ad placement ${placement.id} needs platformPlacementIds.${target}.`,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                advisories.push(notAssessed(target, `Could not inspect target: ${formatError(error)}`));
+            }
+        }
+        return advisories;
+    }
+    catch (error) {
+        return [notAssessed('*', `Target readiness could not be assessed: ${formatError(error)}`)];
+    }
+}
+function readGameOwnedJsonFile(gameRoot, file) {
+    if (!existsSync(file)) {
+        throw new Error(`Missing game-owned ${path.basename(file)}.`);
+    }
+    if (lstatSync(file).isSymbolicLink() || !inside(gameRoot, realpathSync(file))) {
+        throw new Error(`Refusing to inspect a linked or external ${path.basename(file)}.`);
+    }
+    return JSON.parse(readFileSync(file, 'utf8'));
+}
+function asRecord(value, label) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be a JSON object`);
+    }
+    return value;
+}
+function inside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (relative !== '..' && !relative.startsWith(`..${path.sep}`)
+        && !path.isAbsolute(relative));
+}
+function notAssessed(target, message) {
+    return { target, kind: 'not-assessed', message };
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/kit-upgrade.d.ts

@@ -1,3 +1,4 @@
+import { type KitUpgradeTargetAdvisory } from './kit-upgrade-target-readiness.js';
 declare const dependencySections: readonly ['dependencies', 'devDependencies', 'optionalDependencies'];
 type DependencySection = (typeof dependencySections)[number];
 export interface PublishedKitPackage {
@@ -19,6 +20,7 @@ export interface KitUpgradePlan {
   readonly updates: readonly KitUpgradeUpdate[];
   readonly blockers: readonly string[];
   readonly notes: readonly string[];
+  readonly targetAdvisories: readonly KitUpgradeTargetAdvisory[];
   readonly manifestDigests: Readonly<Record<string, string>>;
   readonly targetConfigDigest: {
     readonly file: string;

package/dist/kit-upgrade.js

@@ -4,6 +4,7 @@ import { existsSync, lstatSync, readFileSync, realpathSync, writeFileSync } from
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { compare, intersects, minVersion, satisfies, valid, validRange } from 'semver';
+import { inspectKitUpgradeTargetReadiness, } from './kit-upgrade-target-readiness.js';
 const execFile = promisify(execFileCallback);
 const dependencySections = ['dependencies', 'devDependencies', 'optionalDependencies'];
 export async function planKitUpgrade(gameDirectory, lookup = lookupPublishedKitPackage, targetsFileName) {
@@ -18,6 +19,7 @@ export async function planKitUpgrade(gameDirectory, lookup = lookupPublishedKitP
     const notes = [];
     const blockers = [];
     const { manifests, targetConfigDigest } = discoverGameManifests(gameRoot, notes, blockers, targetsFileName);
+    const targetAdvisories = inspectKitUpgradeTargetReadiness(gameRoot, targetConfigDigest.file);
     const manifestDigests = {};
     const requested = new Set();
     const parsedManifests = new Map();
@@ -124,6 +126,7 @@ export async function planKitUpgrade(gameDirectory, lookup = lookupPublishedKitP
         updates,
         blockers,
         notes: [...new Set(notes)],
+        targetAdvisories,
         manifestDigests,
         targetConfigDigest,
         lockfileDigests,

package/dist/native-build-info.json

@@ -0,0 +1,5 @@
+{
+  "kitGitSha": "646745bcd2b326e05dfb7030e8c15d8a102e054b",
+  "kitDirty": false,
+  "packageVersion": "0.36.1"
+}