@myvillage/cli 1.51.0 → 1.60.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.51.0",
+  "version": "1.60.1",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {
@@ -12,6 +12,7 @@
   "files": [
     "bin/",
     "src/",
+    "tools/",
     "README.md"
   ],
   "keywords": [

package/src/commands/create-game.js

@@ -8,7 +8,7 @@ import inquirer from 'inquirer';
 import { isAuthenticated } from '../utils/auth.js';
 import { createGameProject, createUnityGameProject } from '../utils/templates.js';
 
-export async function createGameCommand() {
+export async function createGameCommand(options = {}) {
   // Check authentication
   if (!isAuthenticated()) {
     console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
@@ -29,7 +29,7 @@ export async function createGameCommand() {
   ]);
 
   if (engine === 'unity') {
-    return createUnityGame();
+    return createUnityGame(options);
   }
 
   // ── Three.js path (existing flow) ──
@@ -122,7 +122,7 @@ export async function createGameCommand() {
 
 // ── Unity path ──
 
-async function createUnityGame() {
+async function createUnityGame(options = {}) {
   const answers = await inquirer.prompt([
     {
       type: 'input',
@@ -185,33 +185,39 @@ async function createUnityGame() {
   const spinner = villageSpinner('Creating Unity game project...').start();
 
   try {
-    createUnityGameProject(targetDir, {
+    const scaffold = await createUnityGameProject(targetDir, {
       name: answers.name,
       description: answers.description,
       type: answers.category,
       ageGroup: answers.ageGroup,
       platform: answers.platform,
+      unityVersion: options.unityVersion,
     });
 
     spinner.succeed(`Unity game "${answers.name}" created!`);
 
     console.log();
     console.log(brand.green(`  \u2713 Unity game "${answers.name}" created!`));
+    console.log(brand.teal(`     Unity: ${scaffold.unityVersion}`));
+    console.log(brand.teal(`     GameKit SDK: ${scaffold.sdkVersion}`));
     console.log();
     console.log(brand.teal('  Next steps:'));
     console.log();
-    console.log(`    1. ${brand.gold('Copy Scripts/')} into your Unity project's Assets/ folder`);
-    console.log(`    2. ${brand.teal('Attach GameSessionReporter and MyVillageAuth to a GameObject')}`);
-    console.log(`    3. ${brand.teal('Build your game in Unity Editor')}`);
+    console.log(`    1. ${brand.gold('Open this project in Unity Hub')} (Add \u2192 Add project from disk)`);
+    console.log(`    2. ${brand.teal('Click menu')} ${brand.gold('MyVillage \u2192 Create Starter Mission Scene')}`);
+    console.log(`    3. ${brand.teal('Press')} ${brand.gold('Play')} ${brand.teal('\u2014 your mission runs end-to-end in the editor')}`);
+    console.log(`    4. ${brand.teal('Edit')} ${brand.gold(`Assets/Scripts/${answers.name.replace(/[^a-zA-Z0-9]/g, '')}.cs`)} ${brand.teal('and iterate (hit Play again)')}`);
+    console.log();
+    console.log(brand.teal('  Ready to ship:'));
     if (answers.platform === 'mobile') {
-      console.log(`    4. ${brand.teal('Place built AssetBundles in')} ${brand.gold('builds/ios/')} ${brand.teal('or')} ${brand.gold('builds/android/')}`);
-      console.log(`    5. ${brand.gold('cd ' + slug + ' && myvillage deploy --platform ios')}`);
+      console.log(`    5. ${brand.teal('Build AssetBundle:')} ${brand.gold('MyVillage \u2192 Build Mission Bundle')}`);
+      console.log(`    6. ${brand.gold('cd ' + slug + ' && myvillage deploy --platform ios')} ${brand.teal('(or android)')}`);
     } else {
-      console.log(`    4. ${brand.teal('Build WebGL to')} ${brand.gold('builds/webgl/')}`);
-      console.log(`    5. ${brand.gold('cd ' + slug + ' && myvillage deploy --platform webgl')}`);
+      console.log(`    5. ${brand.teal('Build WebGL via')} ${brand.gold('File \u2192 Build Settings \u2192 WebGL \u2192 Build')} ${brand.teal('to')} ${brand.gold('builds/webgl/')}`);
+      console.log(`    6. ${brand.gold('cd ' + slug + ' && myvillage deploy --platform webgl')}`);
     }
     console.log();
-    console.log(brand.teal(`  See ${slug}/README.md for full integration guide.`));
+    console.log(brand.teal(`  See ${slug}/README.md for the full developer guide.`));
     console.log();
   } catch (err) {
     spinner.fail('Failed to create Unity game project.');

package/src/commands/deploy.js

@@ -7,7 +7,8 @@ import axios from 'axios';
 import inquirer from 'inquirer';
 import { villageSpinner, brand } from '../utils/brand.js';
 import { isAuthenticated } from '../utils/auth.js';
-import { deployGame, getGameUploadUrl, confirmGameUpload } from '../utils/api.js';
+import { deployGame, getGameUploadUrl, confirmGameUpload, submitGameForReview } from '../utils/api.js';
+import { preflightBundles } from '../utils/preflight.js';
 
 function readPackageJson(dir) {
   const pkgPath = join(dir, 'package.json');
@@ -96,6 +97,28 @@ export async function deployCommand(options = {}) {
   return deployThreeJsGame(projectDir, pkg, options);
 }
 
+// Auto-promote a freshly-deployed DRAFT game to SUBMITTED so the developer
+// doesn't have to run a second command. Re-deploys of games that are already
+// past DRAFT (UNDER_REVIEW, APPROVED, PUBLISHED) keep their existing status.
+async function autoSubmitForReview(gameId, deployResult) {
+  if (deployResult.status !== 'DRAFT') {
+    return deployResult.status;
+  }
+  try {
+    const submitted = await submitGameForReview(gameId);
+    return submitted.game?.status || submitted.status || 'SUBMITTED';
+  } catch (err) {
+    const message = err.response?.data?.error_description
+      || err.response?.data?.error
+      || err.response?.data?.message
+      || err.message;
+    console.log();
+    console.log(chalk.yellow(`  ! Game uploaded but auto-submit failed: ${message}`));
+    console.log(brand.teal('    Run "myvillage game submit" to submit for review manually.'));
+    return deployResult.status;
+  }
+}
+
 // ── Three.js deploy (existing flow) ──
 
 async function deployThreeJsGame(projectDir, pkg) {
@@ -152,15 +175,23 @@ async function deployThreeJsGame(projectDir, pkg) {
       saveGameIdToPackageJson(projectDir, result.gameId, result.slug);
     }
 
+    const finalGameId = result.gameId || pkg.myvillage.gameId;
+
+    spinner.text = 'Submitting for review...';
+    const finalStatus = await autoSubmitForReview(finalGameId, result);
+
     spinner.succeed('Deployment complete!');
     console.log();
-    console.log(brand.green(`  \u2713 Game "${metadata.title}" submitted for review`));
-    console.log(`  Status: ${formatStatus(result.status)}`);
+    if (finalStatus === 'SUBMITTED') {
+      console.log(brand.green(`  \u2713 Game "${metadata.title}" submitted for review`));
+    } else {
+      console.log(brand.green(`  \u2713 Game "${metadata.title}" uploaded`));
+    }
+    console.log(`  Status: ${formatStatus(finalStatus)}`);
     if (result.slug) console.log(brand.teal(`  Slug:    ${result.slug}`));
     if (result.gameId) console.log(brand.teal(`  Game ID: ${result.gameId}`));
 
     // Prompt for thumbnail/banner images
-    const finalGameId = result.gameId || pkg.myvillage.gameId;
     if (finalGameId) {
       await promptForImages(finalGameId);
     }
@@ -186,45 +217,133 @@ async function deployThreeJsGame(projectDir, pkg) {
 
 // ── Unity deploy ──
 
-async function deployUnityGame(projectDir, mvConfig, options) {
-  const platform = options.platform;
+const VALID_UNITY_PLATFORMS = ['ios', 'android', 'webgl'];
 
-  if (!platform) {
-    console.log(chalk.red('  \u2717 --platform is required for Unity games.'));
-    console.log(brand.teal('  Usage: myvillage deploy --platform <ios|android|webgl>'));
+/**
+ * Deploy ALL platforms found in builds/, or just the one specified via
+ * --platform. The host's EdPlatformConfig.BundleUrl already constructs
+ * platform-specific URLs (games/<slug>/bundles/<platform>/<bundle>) and the
+ * backend now stores artifacts per-platform — so deploying iOS, Android, and
+ * WebGL coexists under the same game record without overwriting each other.
+ */
+async function deployUnityGame(projectDir, mvConfig, options) {
+  // Validate any explicit --platform up front so the user fails fast.
+  if (options.platform && !VALID_UNITY_PLATFORMS.includes(options.platform)) {
+    console.log(chalk.red(`  \u2717 Invalid platform "${options.platform}". Must be one of: ${VALID_UNITY_PLATFORMS.join(', ')}`));
     return;
   }
 
-  const validPlatforms = ['ios', 'android', 'webgl'];
-  if (!validPlatforms.includes(platform)) {
-    console.log(chalk.red(`  \u2717 Invalid platform "${platform}". Must be one of: ${validPlatforms.join(', ')}`));
-    return;
+  // Discover which platforms actually have a build sitting in builds/.
+  const buildsRoot = join(projectDir, 'builds');
+  const available = VALID_UNITY_PLATFORMS.filter((p) => {
+    const dir = join(buildsRoot, p);
+    if (!existsSync(dir)) return false;
+    return collectFilePaths(dir).length > 0;
+  });
+
+  // Which platforms are we deploying this run?
+  let platformsToDeploy;
+  if (options.platform) {
+    if (!available.includes(options.platform)) {
+      console.log(chalk.red(`  \u2717 Build directory empty or missing: builds/${options.platform}/`));
+      console.log(brand.teal(`  Build your game in Unity for ${options.platform} first.`));
+      return;
+    }
+    platformsToDeploy = [options.platform];
+  } else {
+    if (available.length === 0) {
+      console.log(chalk.red(`  \u2717 No builds found under builds/.`));
+      console.log(brand.teal('  In Unity, run MyVillage → Build All Platforms (or build one platform manually into builds/<platform>/).'));
+      return;
+    }
+    platformsToDeploy = available;
   }
 
-  // Determine build directory
-  const buildDir = join(projectDir, 'builds', platform);
+  console.log(brand.teal(`  Deploying ${platformsToDeploy.length} platform(s): ${platformsToDeploy.join(', ')}`));
+  console.log();
 
-  if (!existsSync(buildDir)) {
-    console.log(chalk.red(`  \u2717 Build directory not found: builds/${platform}/`));
-    console.log(brand.teal(`  Build your game in Unity and place the output in builds/${platform}/`));
-    return;
+  // Track final outcome across all platforms.
+  let finalGameId = mvConfig.gameId || null;
+  let finalSlug = null;
+  let finalStatus = null;
+  let finalTitle = null;
+
+  for (const platform of platformsToDeploy) {
+    const outcome = await deployUnityPlatform(projectDir, mvConfig, platform, { gameIdOverride: finalGameId });
+    if (!outcome.ok) return; // bail on first platform failure; nothing else makes sense to ship
+    finalGameId = outcome.gameId || finalGameId;
+    finalSlug = outcome.slug || finalSlug;
+    finalStatus = outcome.status || finalStatus;
+    finalTitle = outcome.title || finalTitle;
+    // Reload mvConfig in case the first deploy stamped a new gameId into myvillage.json
+    if (outcome.gameId && !mvConfig.gameId) {
+      mvConfig.gameId = outcome.gameId;
+    }
+  }
+
+  // Single combined summary + one image prompt for the whole multi-platform deploy.
+  console.log();
+  console.log(brand.green(`  \u2713 Game "${finalTitle}" deployed across ${platformsToDeploy.length} platform(s)`));
+  console.log(`  Status:    ${formatStatus(finalStatus)}`);
+  console.log(`  Platforms: ${platformsToDeploy.join(', ')}`);
+  if (finalSlug) console.log(brand.teal(`  Slug:      ${finalSlug}`));
+  if (finalGameId) console.log(brand.teal(`  Game ID:   ${finalGameId}`));
+
+  if (finalGameId) {
+    await promptForImages(finalGameId);
   }
 
+  console.log();
+  console.log(brand.teal('  Run "myvillage status" to check the review status.'));
+  console.log();
+}
+
+/**
+ * Deploy one specific platform. Returns { ok, gameId, slug, status, title } or
+ * { ok: false } and writes a user-readable error to the console.
+ */
+async function deployUnityPlatform(projectDir, mvConfig, platform, { gameIdOverride }) {
+  const buildDir = join(projectDir, 'builds', platform);
   const filePaths = collectFilePaths(buildDir);
 
-  if (filePaths.length === 0) {
-    console.log(chalk.red(`  \u2717 No files found in builds/${platform}/`));
-    return;
+  // GameKit SDK preflight: only runs on iOS/Android (the SDK-based AssetBundle
+  // path) and only when the project declares an sdkVersion in myvillage.json.
+  if ((platform === 'ios' || platform === 'android') && mvConfig.sdkVersion) {
+    const preflightSpinner = villageSpinner(`[${platform}] Running GameKit preflight...`).start();
+    const preflightResult = await preflightBundles({
+      buildDir,
+      sdkVersion: mvConfig.sdkVersion,
+      platform,
+    });
+    if (preflightResult.skipped) {
+      if (preflightResult.fatal) {
+        preflightSpinner.fail(`[${platform}] Preflight could not run: ${preflightResult.reason}`);
+        return { ok: false };
+      }
+      preflightSpinner.warn(`[${platform}] Preflight skipped: ${preflightResult.reason}`);
+    } else if (!preflightResult.ok) {
+      preflightSpinner.fail(`[${platform}] Preflight found ${preflightResult.violations.length} violation(s).`);
+      console.log();
+      for (const v of preflightResult.violations) {
+        console.log(chalk.red(`  \u2717 ${v.kind}`));
+        if (v.bundle) console.log(brand.teal(`     bundle: ${v.bundle}`));
+        if (v.assembly) console.log(brand.teal(`     assembly: ${v.assembly}`));
+        if (v.className) console.log(brand.teal(`     class: ${v.namespace ? v.namespace + '.' : ''}${v.className}`));
+        if (v.reason) console.log(`     ${v.reason}`);
+        console.log();
+      }
+      console.log(brand.teal('  Fix these scripts to extend MissionBase / use SDK templates, rebuild, and retry.'));
+      console.log();
+      return { ok: false };
+    } else {
+      preflightSpinner.succeed(`[${platform}] Preflight passed (${preflightResult.bundlesChecked} bundle(s) checked).`);
+    }
   }
 
-  const spinner = villageSpinner(`Deploying ${platform} build to MyVillageOS...`).start();
+  const spinner = villageSpinner(`[${platform}] Packaging ${filePaths.length} files...`).start();
 
   try {
-    spinner.text = `Packaging ${filePaths.length} files...`;
-
     const formData = new FormData();
-
-    // Determine gameType based on platform
     const gameType = platform === 'webgl' ? 'UNITY_WEBGL' : 'UNITY_NATIVE';
 
     const metadata = {
@@ -235,11 +354,8 @@ async function deployUnityGame(projectDir, mvConfig, options) {
       targetAge: mvConfig.targetAge || 'all',
       buildPlatform: platform,
     };
-
-    // WebGL builds have an index.html entry file
-    if (platform === 'webgl') {
-      metadata.entryFile = 'index.html';
-    }
+    if (mvConfig.sdkVersion) metadata.sdkVersion = mvConfig.sdkVersion;
+    if (platform === 'webgl') metadata.entryFile = 'index.html';
 
     formData.append('metadata', JSON.stringify(metadata));
 
@@ -250,43 +366,40 @@ async function deployUnityGame(projectDir, mvConfig, options) {
       formData.append('files', blob, relPath);
     }
 
-    spinner.text = 'Uploading to MyVillageOS...';
+    spinner.text = `[${platform}] Uploading to MyVillageOS...`;
 
-    const gameIdOrNew = mvConfig.gameId || 'new';
+    const gameIdOrNew = gameIdOverride || mvConfig.gameId || 'new';
     const result = await deployGame(gameIdOrNew, formData);
 
-    // Save gameId back to myvillage.json
-    if (result.gameId && !mvConfig.gameId) {
+    if (result.gameId && !mvConfig.gameId && !gameIdOverride) {
       saveGameIdToMyVillageJson(projectDir, result.gameId, result.slug);
     }
 
-    spinner.succeed(`${platform} deployment complete!`);
-    console.log();
-    console.log(brand.green(`  \u2713 Game "${metadata.title}" (${gameType}) submitted for review`));
-    console.log(`  Status:   ${formatStatus(result.status)}`);
-    console.log(`  Platform: ${platform}`);
-    if (result.slug) console.log(brand.teal(`  Slug:     ${result.slug}`));
-    if (result.gameId) console.log(brand.teal(`  Game ID:  ${result.gameId}`));
+    const finalGameId = result.gameId || gameIdOverride || mvConfig.gameId;
 
-    // Prompt for thumbnail/banner images
-    const finalGameId = result.gameId || mvConfig.gameId;
-    if (finalGameId) {
-      await promptForImages(finalGameId);
-    }
+    spinner.text = `[${platform}] Submitting for review...`;
+    const finalStatus = await autoSubmitForReview(finalGameId, result);
 
-    console.log();
-    console.log(brand.teal('  Run "myvillage status" to check the review status.'));
-    console.log();
+    spinner.succeed(`[${platform}] deployed (${gameType})`);
+
+    return {
+      ok: true,
+      gameId: finalGameId,
+      slug: result.slug,
+      status: finalStatus,
+      title: metadata.title,
+    };
   } catch (err) {
     if (err.response) {
       const message = err.response.data?.error_description
         || err.response.data?.error
         || err.response.data?.message
         || 'Unknown server error';
-      spinner.fail(`Deployment failed: ${message}`);
+      spinner.fail(`[${platform}] Deployment failed: ${message}`);
     } else {
-      spinner.fail(`Deployment failed: ${err.message}`);
+      spinner.fail(`[${platform}] Deployment failed: ${err.message}`);
     }
+    return { ok: false };
   }
 }
 

package/src/index.js

@@ -178,6 +178,7 @@ export function run() {
   program
     .command('create-game')
     .description('Create a new game project with interactive wizard')
+    .option('--unity-version <version>', 'Override the Unity Editor version for Unity scaffolds (e.g. 6000.0.76f1)')
     .action(createGameCommand);
 
   program
@@ -188,7 +189,7 @@ export function run() {
   program
     .command('deploy')
     .description('Build and deploy your game to MyVillageOS')
-    .option('-p, --platform <platform>', 'Target platform (ios, android, webgl) — required for Unity games')
+    .option('-p, --platform <platform>', 'Target Unity platform (ios, android, webgl). Optional — defaults to deploying every platform found in builds/.')
     .action((options) => deployCommand(options));
 
   program

package/src/utils/api.js

@@ -579,6 +579,16 @@ export async function submitGameForReview(gameId) {
   return response.data;
 }
 
+// ── GameKit SDK preflight ──────────────────────────────
+
+// Fetch the GUID allowlist for a specific SDK version. Public endpoint —
+// used by deploy preflight before uploading a Unity bundle.
+export async function getGameKitAllowlist(version) {
+  const client = getApiClient();
+  const response = await client.get(`/gamekit/versions/${encodeURIComponent(version)}/allowlist`);
+  return response.data;
+}
+
 // ── Village Agents (developer agents) ───────────────────
 
 // AgentProfiles owned by the caller that aren't yet linked to a VillageAgent.

package/src/utils/preflight.js

@@ -0,0 +1,172 @@
+import { spawn } from 'child_process';
+import { existsSync, mkdtempSync, readdirSync, statSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { getGameKitAllowlist } from './api.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Path to preflight.py — bundled inside the CLI package at tools/preflight/.
+// Resolves relative to this file so it works whether the CLI is run from
+// `node bin/myvillage.js` locally or from a globally-installed `myvillage`.
+const PREFLIGHT_SCRIPT = resolve(__dirname, '../../tools/preflight/preflight.py');
+
+const PYTHON_CANDIDATES = ['python3', 'python'];
+
+/**
+ * Find the first usable Python interpreter on PATH.
+ * Returns the command name (e.g. "python3") or null if none works.
+ */
+async function findPython() {
+  for (const cmd of PYTHON_CANDIDATES) {
+    try {
+      const ok = await new Promise((resolveCheck) => {
+        const proc = spawn(cmd, ['--version'], { stdio: 'ignore' });
+        proc.on('error', () => resolveCheck(false));
+        proc.on('exit', (code) => resolveCheck(code === 0));
+      });
+      if (ok) return cmd;
+    } catch {
+      /* try next */
+    }
+  }
+  return null;
+}
+
+/**
+ * Find every Unity AssetBundle file under a directory (recursive). Bundles
+ * don't have a single canonical extension — Unity sometimes uses `.bundle`,
+ * sometimes no extension at all, sometimes `.unity3d`. We include files
+ * matching common patterns and exclude obvious non-bundles.
+ */
+function findBundleFiles(dir) {
+  const SKIP_EXT = new Set(['.manifest', '.meta', '.txt', '.json', '.md', '.png', '.jpg', '.jpeg', '.webp']);
+  const results = [];
+  function walk(d) {
+    for (const entry of readdirSync(d)) {
+      const full = join(d, entry);
+      const st = statSync(full);
+      if (st.isDirectory()) {
+        walk(full);
+        continue;
+      }
+      const lower = entry.toLowerCase();
+      const dotIdx = lower.lastIndexOf('.');
+      const ext = dotIdx >= 0 ? lower.slice(dotIdx) : '';
+      if (SKIP_EXT.has(ext)) continue;
+      if (lower.endsWith('.bundle') || lower.endsWith('.unity3d') || ext === '') {
+        results.push(full);
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+
+/**
+ * Run preflight.py against one bundle. Returns the parsed JSON result.
+ */
+async function runPreflight(python, bundlePath, allowlistPath) {
+  return new Promise((resolveCall, rejectCall) => {
+    const proc = spawn(python, [PREFLIGHT_SCRIPT, bundlePath, allowlistPath], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (b) => { stdout += b.toString(); });
+    proc.stderr.on('data', (b) => { stderr += b.toString(); });
+    proc.on('error', rejectCall);
+    proc.on('exit', (code) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(stdout);
+      } catch {
+        rejectCall(new Error(`preflight produced non-JSON output (exit ${code}): ${stderr || stdout}`));
+        return;
+      }
+      resolveCall({ exitCode: code, ...parsed });
+    });
+  });
+}
+
+/**
+ * Run preflight against all AssetBundles in a build directory.
+ *
+ * Returns:
+ *   { skipped: true, reason }        — bundles couldn't be checked (no SDK, no Python, etc.)
+ *   { ok: true, bundlesChecked }     — all bundles passed
+ *   { ok: false, violations, bundle } — at least one violation found
+ */
+export async function preflightBundles({ buildDir, sdkVersion, platform }) {
+  if (!sdkVersion) {
+    return { skipped: true, reason: 'No sdkVersion in myvillage.json — preflight only runs for SDK-based games.' };
+  }
+  if (platform !== 'ios' && platform !== 'android') {
+    return { skipped: true, reason: `Preflight skipped for platform "${platform}" (only runs on iOS/Android AssetBundles).` };
+  }
+  if (!existsSync(PREFLIGHT_SCRIPT)) {
+    return { skipped: true, reason: `preflight.py not found at ${PREFLIGHT_SCRIPT} — CLI install may be incomplete.` };
+  }
+
+  const python = await findPython();
+  if (!python) {
+    return {
+      skipped: true,
+      reason: 'Python 3 not found on PATH. Install Python 3.9+ and then run: pip install UnityPy==1.25.0',
+    };
+  }
+
+  let allowlistResponse;
+  try {
+    allowlistResponse = await getGameKitAllowlist(sdkVersion);
+  } catch (err) {
+    return {
+      skipped: true,
+      reason: `Failed to fetch GameKit allowlist for SDK ${sdkVersion}: ${err.message}. Upload aborted — re-run with network access.`,
+      fatal: true,
+    };
+  }
+
+  const tmpDir = mkdtempSync(join(tmpdir(), 'myvillage-preflight-'));
+  const allowlistPath = join(tmpDir, 'allowlist.json');
+  writeFileSync(allowlistPath, JSON.stringify(allowlistResponse.allowlist));
+
+  const bundles = findBundleFiles(buildDir);
+  if (bundles.length === 0) {
+    return { skipped: true, reason: `No AssetBundle files found in ${buildDir}. Did the Unity build run?` };
+  }
+
+  const allViolations = [];
+  let bundlesChecked = 0;
+  for (const bundle of bundles) {
+    try {
+      const result = await runPreflight(python, bundle, allowlistPath);
+      bundlesChecked++;
+      if (result.violations && result.violations.length > 0) {
+        for (const v of result.violations) allViolations.push({ ...v, bundle });
+      }
+      if (result.status === 'error') {
+        return {
+          ok: false,
+          fatal: true,
+          violations: [{ kind: 'preflight_error', bundle, reason: result.error || 'unknown' }],
+          bundlesChecked,
+        };
+      }
+    } catch (err) {
+      return {
+        ok: false,
+        fatal: true,
+        violations: [{ kind: 'preflight_crash', bundle, reason: err.message }],
+        bundlesChecked,
+      };
+    }
+  }
+
+  return {
+    ok: allViolations.length === 0,
+    violations: allViolations,
+    bundlesChecked,
+  };
+}