@myvillage/cli 1.9.0 → 1.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.9.0",
+  "version": "1.10.1",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {

package/src/commands/create-game.js

@@ -6,7 +6,7 @@ import ora from 'ora';
 import { villageSpinner, brand } from '../utils/brand.js';
 import inquirer from 'inquirer';
 import { isAuthenticated } from '../utils/auth.js';
-import { createGameProject } from '../utils/templates.js';
+import { createGameProject, createUnityGameProject } from '../utils/templates.js';
 
 export async function createGameCommand() {
   // Check authentication
@@ -15,7 +15,25 @@ export async function createGameCommand() {
     return;
   }
 
-  // Interactive prompts
+  // Engine choice
+  const { engine } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'engine',
+      message: 'Which engine are you using?',
+      choices: [
+        { name: 'Three.js — Web-based 3D game (runs in browser)', value: 'threejs' },
+        { name: 'Unity — Mobile or WebGL game (built in Unity Editor)', value: 'unity' },
+      ],
+    },
+  ]);
+
+  if (engine === 'unity') {
+    return createUnityGame();
+  }
+
+  // ── Three.js path (existing flow) ──
+
   const answers = await inquirer.prompt([
     {
       type: 'list',
@@ -57,7 +75,6 @@ export async function createGameCommand() {
     },
   ]);
 
-  // Create project directory
   const slug = answers.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
   const targetDir = resolve(process.cwd(), slug);
 
@@ -69,7 +86,6 @@ export async function createGameCommand() {
   const spinner = villageSpinner('Creating game project...').start();
 
   try {
-    // Generate project from template
     createGameProject(targetDir, {
       name: answers.name,
       description: answers.description,
@@ -79,7 +95,6 @@ export async function createGameCommand() {
 
     spinner.text = 'Installing dependencies...';
 
-    // Run npm install in the new project directory
     execSync('npm install', {
       cwd: targetDir,
       stdio: 'pipe',
@@ -87,7 +102,6 @@ export async function createGameCommand() {
 
     spinner.succeed(`Game "${answers.name}" created successfully!`);
 
-    // Display next steps
     console.log();
     console.log(brand.green(`  \u2713 Game "${answers.name}" created successfully!`));
     console.log();
@@ -105,3 +119,102 @@ export async function createGameCommand() {
     console.error(chalk.red(`  ${err.message}`));
   }
 }
+
+// ── Unity path ──
+
+async function createUnityGame() {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Game name:',
+      default: 'My Unity Game',
+      validate: (input) => {
+        if (!input.trim()) return 'Game name is required.';
+        return true;
+      },
+    },
+    {
+      type: 'input',
+      name: 'description',
+      message: 'Game description:',
+      default: 'A Unity game for MyVillageOS',
+    },
+    {
+      type: 'list',
+      name: 'category',
+      message: 'Game category:',
+      choices: [
+        { name: 'Education', value: 'education' },
+        { name: 'Action', value: 'action' },
+        { name: 'Adventure', value: 'adventure' },
+        { name: 'Puzzle', value: 'puzzle' },
+        { name: 'Other', value: 'other' },
+      ],
+    },
+    {
+      type: 'list',
+      name: 'platform',
+      message: 'Target platform:',
+      choices: [
+        { name: 'Mobile (iOS / Android) — AssetBundle loaded by Izi Graham', value: 'mobile' },
+        { name: 'WebGL — Runs in browser on M-UNI', value: 'webgl' },
+      ],
+    },
+    {
+      type: 'list',
+      name: 'ageGroup',
+      message: 'Target age group:',
+      choices: [
+        { name: '5-8 years', value: '5-8' },
+        { name: '9-12 years', value: '9-12' },
+        { name: '13-15 years', value: '13-15' },
+        { name: '16-18 years', value: '16-18' },
+      ],
+    },
+  ]);
+
+  const slug = answers.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
+  const targetDir = resolve(process.cwd(), slug);
+
+  if (existsSync(targetDir)) {
+    console.log(chalk.red(`\n  \u2717 Directory "${slug}" already exists.`));
+    return;
+  }
+
+  const spinner = villageSpinner('Creating Unity game project...').start();
+
+  try {
+    createUnityGameProject(targetDir, {
+      name: answers.name,
+      description: answers.description,
+      type: answers.category,
+      ageGroup: answers.ageGroup,
+      platform: answers.platform,
+    });
+
+    spinner.succeed(`Unity game "${answers.name}" created!`);
+
+    console.log();
+    console.log(brand.green(`  \u2713 Unity game "${answers.name}" created!`));
+    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')}`);
+    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')}`);
+    } 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();
+    console.log(brand.teal(`  See ${slug}/README.md for full integration guide.`));
+    console.log();
+  } catch (err) {
+    spinner.fail('Failed to create Unity game project.');
+    console.error(chalk.red(`  ${err.message}`));
+  }
+}

package/src/commands/deploy.js

@@ -1,11 +1,13 @@
-import { existsSync, readFileSync, writeFileSync, readdirSync } from 'fs';
-import { join, resolve, relative } from 'path';
+import { existsSync, readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
+import { join, resolve, relative, extname } from 'path';
 import { execSync } from 'child_process';
 import chalk from 'chalk';
 import ora from 'ora';
+import axios from 'axios';
+import inquirer from 'inquirer';
 import { villageSpinner, brand } from '../utils/brand.js';
 import { isAuthenticated } from '../utils/auth.js';
-import { deployGame } from '../utils/api.js';
+import { deployGame, getGameUploadUrl, confirmGameUpload } from '../utils/api.js';
 
 function readPackageJson(dir) {
   const pkgPath = join(dir, 'package.json');
@@ -18,6 +20,17 @@ function readPackageJson(dir) {
   }
 }
 
+function readMyVillageJson(dir) {
+  const configPath = join(dir, 'myvillage.json');
+  if (!existsSync(configPath)) return null;
+
+  try {
+    return JSON.parse(readFileSync(configPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
 function saveGameIdToPackageJson(dir, gameId, slug) {
   const pkgPath = join(dir, 'package.json');
   const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
@@ -25,6 +38,15 @@ function saveGameIdToPackageJson(dir, gameId, slug) {
   writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
 }
 
+function saveGameIdToMyVillageJson(dir, gameId, slug) {
+  const configPath = join(dir, 'myvillage.json');
+  const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+  config.gameId = gameId;
+  config.slug = slug;
+  config.lastDeployed = new Date().toISOString();
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+
 // Recursively collect file paths from a directory
 function collectFilePaths(dir) {
   const paths = [];
@@ -45,7 +67,7 @@ function collectFilePaths(dir) {
   return paths;
 }
 
-export async function deployCommand() {
+export async function deployCommand(options = {}) {
   // Check authentication
   if (!isAuthenticated()) {
     console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
@@ -53,15 +75,30 @@ export async function deployCommand() {
   }
 
   const projectDir = resolve(process.cwd());
+  const mvConfig = readMyVillageJson(projectDir);
   const pkg = readPackageJson(projectDir);
 
-  // Verify this is a valid MyVillageOS game project
-  if (!pkg || !pkg.myvillage) {
+  // Detect project type
+  const isUnity = mvConfig && mvConfig.engine === 'unity';
+  const isThreeJs = pkg && pkg.myvillage;
+
+  if (!isUnity && !isThreeJs) {
     console.log(chalk.red('  \u2717 Not a valid game project directory.'));
     console.log(brand.teal('  Make sure you are inside a game directory created with "myvillage create-game".'));
+    console.log(brand.teal('  Expected: package.json with myvillage block, or myvillage.json with engine: unity'));
     return;
   }
 
+  if (isUnity) {
+    return deployUnityGame(projectDir, mvConfig, options);
+  }
+
+  return deployThreeJsGame(projectDir, pkg, options);
+}
+
+// ── Three.js deploy (existing flow) ──
+
+async function deployThreeJsGame(projectDir, pkg) {
   const spinner = villageSpinner('Building game...').start();
 
   try {
@@ -80,7 +117,6 @@ export async function deployCommand() {
 
     spinner.text = 'Packaging build artifacts...';
 
-    // Collect build files
     const filePaths = collectFilePaths(distDir);
 
     if (filePaths.length === 0) {
@@ -88,10 +124,8 @@ export async function deployCommand() {
       return;
     }
 
-    // Build multipart FormData
     const formData = new FormData();
 
-    // Add metadata
     const metadata = {
       title: pkg.myvillage.name || pkg.name,
       description: pkg.description || '',
@@ -102,7 +136,6 @@ export async function deployCommand() {
     };
     formData.append('metadata', JSON.stringify(metadata));
 
-    // Add each file with relative path as the filename
     for (const fullPath of filePaths) {
       const relPath = relative(distDir, fullPath);
       const fileBuffer = readFileSync(fullPath);
@@ -112,11 +145,9 @@ export async function deployCommand() {
 
     spinner.text = 'Deploying to MyVillageOS...';
 
-    // Use existing gameId if this project was deployed before, otherwise "new"
     const gameIdOrNew = pkg.myvillage.gameId || 'new';
     const result = await deployGame(gameIdOrNew, formData);
 
-    // Save gameId to package.json for subsequent deploys
     if (result.gameId && !pkg.myvillage.gameId) {
       saveGameIdToPackageJson(projectDir, result.gameId, result.slug);
     }
@@ -125,12 +156,13 @@ export async function deployCommand() {
     console.log();
     console.log(brand.green(`  \u2713 Game "${metadata.title}" submitted for review`));
     console.log(`  Status: ${formatStatus(result.status)}`);
+    if (result.slug) console.log(brand.teal(`  Slug:    ${result.slug}`));
+    if (result.gameId) console.log(brand.teal(`  Game ID: ${result.gameId}`));
 
-    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);
     }
 
     console.log();
@@ -138,14 +170,12 @@ export async function deployCommand() {
     console.log();
   } catch (err) {
     if (err.response) {
-      // API error
       const message = err.response.data?.error_description
         || err.response.data?.error
         || err.response.data?.message
         || 'Unknown server error';
       spinner.fail(`Deployment failed: ${message}`);
     } else if (err.stderr) {
-      // Build error
       spinner.fail('Build failed.');
       console.error(chalk.red(`  ${err.stderr.toString().trim()}`));
     } else {
@@ -154,6 +184,219 @@ export async function deployCommand() {
   }
 }
 
+// ── Unity deploy ──
+
+async function deployUnityGame(projectDir, mvConfig, options) {
+  const platform = options.platform;
+
+  if (!platform) {
+    console.log(chalk.red('  \u2717 --platform is required for Unity games.'));
+    console.log(brand.teal('  Usage: myvillage deploy --platform <ios|android|webgl>'));
+    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;
+  }
+
+  // Determine build directory
+  const buildDir = join(projectDir, 'builds', platform);
+
+  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;
+  }
+
+  const filePaths = collectFilePaths(buildDir);
+
+  if (filePaths.length === 0) {
+    console.log(chalk.red(`  \u2717 No files found in builds/${platform}/`));
+    return;
+  }
+
+  const spinner = villageSpinner(`Deploying ${platform} build to MyVillageOS...`).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 = {
+      title: mvConfig.name,
+      description: mvConfig.description || '',
+      category: (mvConfig.category || 'OTHER').toUpperCase(),
+      gameType,
+      targetAge: mvConfig.targetAge || 'all',
+      buildPlatform: platform,
+    };
+
+    // WebGL builds have an index.html entry file
+    if (platform === 'webgl') {
+      metadata.entryFile = 'index.html';
+    }
+
+    formData.append('metadata', JSON.stringify(metadata));
+
+    for (const fullPath of filePaths) {
+      const relPath = relative(buildDir, fullPath);
+      const fileBuffer = readFileSync(fullPath);
+      const blob = new Blob([fileBuffer], { type: getContentType(relPath) });
+      formData.append('files', blob, relPath);
+    }
+
+    spinner.text = 'Uploading to MyVillageOS...';
+
+    const gameIdOrNew = mvConfig.gameId || 'new';
+    const result = await deployGame(gameIdOrNew, formData);
+
+    // Save gameId back to myvillage.json
+    if (result.gameId && !mvConfig.gameId) {
+      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}`));
+
+    // Prompt for thumbnail/banner images
+    const finalGameId = result.gameId || mvConfig.gameId;
+    if (finalGameId) {
+      await promptForImages(finalGameId);
+    }
+
+    console.log();
+    console.log(brand.teal('  Run "myvillage status" to check the review status.'));
+    console.log();
+  } 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}`);
+    } else {
+      spinner.fail(`Deployment failed: ${err.message}`);
+    }
+  }
+}
+
+// ── Image upload helpers ──
+
+const IMAGE_EXTS = ['.png', '.jpg', '.jpeg', '.webp', '.gif'];
+const IMAGE_CONTENT_TYPES = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.webp': 'image/webp',
+  '.gif': 'image/gif',
+};
+
+async function uploadImageAsset(gameId, filePath, assetType) {
+  const resolved = resolve(filePath);
+  if (!existsSync(resolved)) {
+    console.log(chalk.red(`  ✗ File not found: ${resolved}`));
+    return false;
+  }
+
+  const ext = extname(resolved).toLowerCase();
+  if (!IMAGE_EXTS.includes(ext)) {
+    console.log(chalk.red(`  ✗ Unsupported format "${ext}". Use: ${IMAGE_EXTS.join(', ')}`));
+    return false;
+  }
+
+  const contentType = IMAGE_CONTENT_TYPES[ext];
+  const fileSize = statSync(resolved).size;
+  const fileName = `${assetType.toLowerCase()}${ext}`;
+  const label = assetType.toLowerCase();
+
+  const spinner = villageSpinner(`Uploading ${label}...`).start();
+
+  try {
+    const urlResult = await getGameUploadUrl(gameId, {
+      fileName,
+      assetType,
+      contentType,
+      fileSize,
+    });
+
+    const fileBuffer = readFileSync(resolved);
+    await axios.put(urlResult.uploadUrl, fileBuffer, {
+      headers: { 'Content-Type': contentType },
+      maxBodyLength: Infinity,
+      maxContentLength: Infinity,
+    });
+
+    await confirmGameUpload(gameId, {
+      s3Key: urlResult.s3Key,
+      fileName,
+      assetType,
+      contentType,
+    });
+
+    spinner.succeed(`${label.charAt(0).toUpperCase() + label.slice(1)} uploaded!`);
+    return true;
+  } catch (err) {
+    const message = err.response?.data?.error || err.message;
+    spinner.fail(`${label} upload failed: ${message}`);
+    return false;
+  }
+}
+
+async function promptForImages(gameId) {
+  console.log();
+  const { addThumbnail } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'addThumbnail',
+    message: 'Upload a thumbnail image? (shown on game cards)',
+    default: false,
+  }]);
+
+  if (addThumbnail) {
+    const { thumbnailPath } = await inquirer.prompt([{
+      type: 'input',
+      name: 'thumbnailPath',
+      message: 'Path to thumbnail image:',
+      validate: (input) => {
+        if (!input.trim()) return 'Path is required.';
+        if (!existsSync(resolve(input.trim()))) return 'File not found.';
+        return true;
+      },
+    }]);
+    await uploadImageAsset(gameId, thumbnailPath.trim(), 'THUMBNAIL');
+  }
+
+  const { addBanner } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'addBanner',
+    message: 'Upload a banner image? (shown on featured displays)',
+    default: false,
+  }]);
+
+  if (addBanner) {
+    const { bannerPath } = await inquirer.prompt([{
+      type: 'input',
+      name: 'bannerPath',
+      message: 'Path to banner image:',
+      validate: (input) => {
+        if (!input.trim()) return 'Path is required.';
+        if (!existsSync(resolve(input.trim()))) return 'File not found.';
+        return true;
+      },
+    }]);
+    await uploadImageAsset(gameId, bannerPath.trim(), 'BANNER');
+  }
+}
+
 function formatStatus(status) {
   switch (status) {
     case 'SUBMITTED':
@@ -193,6 +436,11 @@ function getContentType(filePath) {
     woff2: 'font/woff2',
     ttf: 'font/ttf',
     wasm: 'application/wasm',
+    // Unity-specific
+    data: 'application/octet-stream',
+    unityweb: 'application/octet-stream',
+    br: 'application/x-brotli',
+    gz: 'application/gzip',
   };
   return types[ext] || 'application/octet-stream';
 }