@myvillage/cli 1.9.0 → 1.10.0

package/src/commands/game.js

@@ -0,0 +1,631 @@
+import { existsSync, readFileSync, writeFileSync, statSync } from 'fs';
+import { join, resolve, basename, extname } from 'path';
+import chalk from 'chalk';
+import axios from 'axios';
+import inquirer from 'inquirer';
+import pLimit from 'p-limit';
+import { villageSpinner, brand } from '../utils/brand.js';
+import { isAuthenticated } from '../utils/auth.js';
+import {
+  getGameMissions,
+  updateGameMissions,
+  getGameUploadUrl,
+  confirmGameUpload,
+  getGameDetail,
+  updateGameMetadata,
+  submitGameForReview,
+} from '../utils/api.js';
+
+// ── game missions init ────────────────────────────────
+
+export async function gameMissionsInitCommand() {
+  const manifestPath = resolve(process.cwd(), 'manifest.json');
+
+  if (existsSync(manifestPath)) {
+    console.log(chalk.yellow('  manifest.json already exists. Edit it directly or use "myvillage game missions sync" to upload.'));
+    return;
+  }
+
+  const template = {
+    version: '1.0',
+    engine: 'unity',
+    engineVersion: '6000.0.27f1',
+    platforms: ['ios', 'android'],
+    missions: [
+      {
+        id: 'example-mission',
+        title: 'Example Mission',
+        bundleName: 'example',
+        category: 'EDUCATION',
+        subject: 'math',
+        difficulty: ['easy', 'medium'],
+        mvtReward: 10,
+        unlockRequirements: [],
+        thumbnailPath: 'thumbnails/example.png',
+      },
+    ],
+  };
+
+  writeFileSync(manifestPath, JSON.stringify(template, null, 2) + '\n');
+
+  console.log(brand.green('  ✓ Created manifest.json'));
+  console.log();
+  console.log(brand.teal('  Edit the missions array, then run:'));
+  console.log(`    ${brand.gold('myvillage game missions sync')}  ${brand.teal('— Upload to ed-platform')}`);
+  console.log();
+}
+
+// ── game missions sync ────────────────────────────────
+
+export async function gameMissionsSyncCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const gameId = getGameId();
+  if (!gameId) return;
+
+  const manifestPath = resolve(process.cwd(), 'manifest.json');
+  if (!existsSync(manifestPath)) {
+    console.log(chalk.red('  ✗ No manifest.json found. Run "myvillage game missions init" first.'));
+    return;
+  }
+
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  } catch (err) {
+    console.log(chalk.red(`  ✗ Invalid JSON in manifest.json: ${err.message}`));
+    return;
+  }
+
+  const spinner = villageSpinner('Uploading manifest...').start();
+
+  try {
+    const result = await updateGameMissions(gameId, manifest);
+    spinner.succeed('Manifest synced successfully!');
+    console.log();
+
+    const missions = result.manifest?.missions || manifest.missions || [];
+    console.log(brand.green(`  ✓ ${missions.length} mission(s) uploaded`));
+
+    for (const m of missions) {
+      const reward = m.mvtReward ? ` (${m.mvtReward} MVT)` : '';
+      console.log(`    ${brand.gold('•')} ${m.title || m.id}${brand.teal(reward)}`);
+    }
+
+    if (result.manifestS3Key) {
+      console.log();
+      console.log(brand.teal(`  S3 key: ${result.manifestS3Key}`));
+    }
+    console.log();
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    spinner.fail(`Manifest sync failed: ${message}`);
+
+    if (err.response?.data?.details) {
+      console.log(chalk.red('  Validation errors:'));
+      for (const detail of err.response.data.details) {
+        console.log(chalk.red(`    • ${detail}`));
+      }
+    }
+  }
+}
+
+// ── game missions list ────────────────────────────────
+
+export async function gameMissionsListCommand(options) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const gameId = getGameId();
+  if (!gameId) return;
+
+  const spinner = villageSpinner('Fetching missions...').start();
+
+  try {
+    const result = await getGameMissions(gameId);
+    spinner.stop();
+
+    if (!result.manifest) {
+      console.log(brand.teal('  No manifest uploaded yet. Run "myvillage game missions sync" first.'));
+      return;
+    }
+
+    const manifest = result.manifest;
+    console.log();
+    console.log(brand.gold(`  ${manifest.engine || 'Game'} v${manifest.version || '?'}`));
+    console.log(brand.teal(`  Platforms: ${(manifest.platforms || []).join(', ')}`));
+    console.log();
+
+    if (!manifest.missions || manifest.missions.length === 0) {
+      console.log(brand.teal('  No missions defined.'));
+      return;
+    }
+
+    for (const m of manifest.missions) {
+      const reward = m.mvtReward ? `${m.mvtReward} MVT` : '—';
+      const diff = m.difficulty ? m.difficulty.join('/') : '—';
+      const lock = m.unlockRequirements?.length
+        ? chalk.yellow(` 🔒 requires: ${m.unlockRequirements.join(', ')}`)
+        : '';
+
+      console.log(`  ${brand.gold(m.title || m.id)}`);
+      console.log(`    ID: ${m.id}  Bundle: ${m.bundleName}  Category: ${m.category}`);
+      console.log(`    Difficulty: ${diff}  Reward: ${brand.green(reward)}${lock}`);
+      console.log();
+    }
+
+    if (options?.json) {
+      console.log(JSON.stringify(manifest, null, 2));
+    }
+  } catch (err) {
+    const message = err.response?.data?.error || err.message;
+    spinner.fail(`Failed to fetch missions: ${message}`);
+  }
+}
+
+// ── game bundles upload ───────────────────────────────
+
+export async function gameBundlesUploadCommand(filePath, options) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const gameId = getGameId();
+  if (!gameId) return;
+
+  const platform = options.platform;
+  if (!platform) {
+    console.log(chalk.red('  ✗ --platform is required (ios, android, webgl)'));
+    return;
+  }
+
+  const bundleName = options.bundleName || basename(filePath).replace(/\.[^.]+$/, '');
+  const resolvedPath = resolve(filePath);
+
+  if (!existsSync(resolvedPath)) {
+    console.log(chalk.red(`  ✗ File not found: ${resolvedPath}`));
+    return;
+  }
+
+  const fileSize = statSync(resolvedPath).size;
+  const fileName = `bundles/${platform}/${bundleName}`;
+  const contentType = 'application/octet-stream';
+
+  const spinner = villageSpinner(`${bundleName} (${formatBytes(fileSize)}) — requesting upload URL...`).start();
+
+  try {
+    // 1. Get presigned URL
+    const urlResult = await getGameUploadUrl(gameId, {
+      fileName,
+      assetType: 'ASSET_BUNDLE',
+      contentType,
+      fileSize,
+    });
+
+    // 2. Upload to S3
+    spinner.text = chalk.yellow(`${bundleName} — uploading to storage...`);
+    const fileBuffer = readFileSync(resolvedPath);
+
+    await axios.put(urlResult.uploadUrl, fileBuffer, {
+      headers: { 'Content-Type': contentType },
+      maxBodyLength: Infinity,
+      maxContentLength: Infinity,
+      onUploadProgress: (progressEvent) => {
+        if (progressEvent.total) {
+          const pct = Math.round((progressEvent.loaded / progressEvent.total) * 100);
+          spinner.text = chalk.yellow(`${bundleName} — ${pct}% (${formatBytes(progressEvent.loaded)} / ${formatBytes(progressEvent.total)})`);
+        }
+      },
+    });
+
+    // 3. Confirm
+    spinner.text = chalk.yellow(`${bundleName} — confirming...`);
+    await confirmGameUpload(gameId, {
+      s3Key: urlResult.s3Key,
+      fileName,
+      assetType: 'ASSET_BUNDLE',
+      contentType,
+    });
+
+    spinner.succeed(`${bundleName} (${formatBytes(fileSize)}) — uploaded for ${platform}`);
+  } catch (err) {
+    const message = err.response?.data?.error || err.message;
+    spinner.fail(`${bundleName} — upload failed: ${message}`);
+  }
+}
+
+// ── game bundles upload-dir ───────────────────────────
+
+export async function gameBundlesUploadDirCommand(dirPath, options) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const gameId = getGameId();
+  if (!gameId) return;
+
+  const platform = options.platform;
+  if (!platform) {
+    console.log(chalk.red('  ✗ --platform is required (ios, android, webgl)'));
+    return;
+  }
+
+  const resolvedDir = resolve(dirPath);
+  if (!existsSync(resolvedDir)) {
+    console.log(chalk.red(`  ✗ Directory not found: ${resolvedDir}`));
+    return;
+  }
+
+  // Collect all files in directory
+  const { readdirSync } = await import('fs');
+  const entries = readdirSync(resolvedDir, { withFileTypes: true });
+  const files = entries
+    .filter((e) => e.isFile())
+    .map((e) => ({
+      path: join(resolvedDir, e.name),
+      bundleName: e.name,
+    }));
+
+  if (files.length === 0) {
+    console.log(chalk.yellow(`  No files found in ${dirPath}`));
+    return;
+  }
+
+  console.log(brand.teal(`  Uploading ${files.length} bundle(s) for ${platform}...\n`));
+
+  const limit = pLimit(3);
+  const tasks = files.map((file) =>
+    limit(async () => {
+      const fileSize = statSync(file.path).size;
+      const fileName = `bundles/${platform}/${file.bundleName}`;
+      const contentType = 'application/octet-stream';
+      const spinner = villageSpinner(`${file.bundleName} (${formatBytes(fileSize)})...`).start();
+
+      try {
+        const urlResult = await getGameUploadUrl(gameId, {
+          fileName,
+          assetType: 'ASSET_BUNDLE',
+          contentType,
+          fileSize,
+        });
+
+        const fileBuffer = readFileSync(file.path);
+        await axios.put(urlResult.uploadUrl, fileBuffer, {
+          headers: { 'Content-Type': contentType },
+          maxBodyLength: Infinity,
+          maxContentLength: Infinity,
+          onUploadProgress: (progressEvent) => {
+            if (progressEvent.total) {
+              const pct = Math.round((progressEvent.loaded / progressEvent.total) * 100);
+              spinner.text = chalk.yellow(`${file.bundleName} — ${pct}%`);
+            }
+          },
+        });
+
+        await confirmGameUpload(gameId, {
+          s3Key: urlResult.s3Key,
+          fileName,
+          assetType: 'ASSET_BUNDLE',
+          contentType,
+        });
+
+        spinner.succeed(`${file.bundleName} (${formatBytes(fileSize)})`);
+      } catch (err) {
+        const message = err.response?.data?.error || err.message;
+        spinner.fail(`${file.bundleName} — failed: ${message}`);
+      }
+    })
+  );
+
+  await Promise.all(tasks);
+  console.log();
+}
+
+// ── game update ─────────────────────────────────────
+
+export async function gameUpdateCommand(options) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const gameId = getGameId();
+  if (!gameId) return;
+
+  // Fetch current game details to show current values
+  const spinner = villageSpinner('Fetching current game info...').start();
+  let game;
+  try {
+    const result = await getGameDetail(gameId);
+    game = result.game;
+    spinner.stop();
+  } catch (err) {
+    const message = err.response?.data?.error || err.message;
+    spinner.fail(`Failed to fetch game: ${message}`);
+    return;
+  }
+
+  console.log();
+  console.log(brand.gold(`  Updating: ${game.title}`));
+  console.log(brand.teal(`  Status: ${game.status}  |  Slug: ${game.slug}`));
+  console.log();
+  console.log(brand.teal('  Press Enter to keep current values.'));
+  console.log();
+
+  const CATEGORIES = ['EDUCATION', 'ACTION', 'ADVENTURE', 'PUZZLE', 'SIMULATION', 'STRATEGY', 'OTHER'];
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'title',
+      message: 'Title:',
+      default: game.title,
+    },
+    {
+      type: 'input',
+      name: 'description',
+      message: 'Description:',
+      default: game.description || '',
+    },
+    {
+      type: 'list',
+      name: 'category',
+      message: 'Category:',
+      choices: CATEGORIES,
+      default: game.category || 'OTHER',
+    },
+    {
+      type: 'input',
+      name: 'targetAge',
+      message: 'Target age:',
+      default: game.targetAge || '',
+    },
+    {
+      type: 'input',
+      name: 'tags',
+      message: 'Tags (comma-separated):',
+      default: (game.tags || []).join(', '),
+    },
+  ]);
+
+  // Build update payload — only send fields that changed
+  const updates = {};
+  if (answers.title !== game.title) updates.title = answers.title;
+  if (answers.description !== (game.description || '')) updates.description = answers.description;
+  if (answers.category !== (game.category || 'OTHER')) updates.category = answers.category;
+  if (answers.targetAge !== (game.targetAge || '')) updates.targetAge = answers.targetAge;
+
+  const newTags = answers.tags
+    ? answers.tags.split(',').map((t) => t.trim()).filter(Boolean)
+    : [];
+  const oldTags = game.tags || [];
+  if (JSON.stringify(newTags) !== JSON.stringify(oldTags)) updates.tags = newTags;
+
+  if (Object.keys(updates).length === 0) {
+    console.log(brand.teal('\n  No changes made.\n'));
+    return;
+  }
+
+  const updateSpinner = villageSpinner('Saving changes...').start();
+
+  try {
+    const result = await updateGameMetadata(gameId, updates);
+    updateSpinner.succeed('Game updated!');
+    console.log();
+    for (const [key, val] of Object.entries(updates)) {
+      const display = Array.isArray(val) ? val.join(', ') : val;
+      console.log(`  ${brand.gold(key)}: ${display}`);
+    }
+    console.log();
+  } catch (err) {
+    const message = err.response?.data?.error || err.message;
+    updateSpinner.fail(`Update failed: ${message}`);
+  }
+}
+
+// ── game upload-thumbnail ───────────────────────────
+
+export async function gameUploadThumbnailCommand(filePath) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const gameId = getGameId();
+  if (!gameId) return;
+
+  const resolvedPath = resolve(filePath);
+
+  if (!existsSync(resolvedPath)) {
+    console.log(chalk.red(`  ✗ File not found: ${resolvedPath}`));
+    return;
+  }
+
+  const ext = extname(resolvedPath).toLowerCase();
+  const allowedExts = ['.png', '.jpg', '.jpeg', '.webp', '.gif'];
+  if (!allowedExts.includes(ext)) {
+    console.log(chalk.red(`  ✗ Unsupported image format "${ext}". Use: ${allowedExts.join(', ')}`));
+    return;
+  }
+
+  const contentTypes = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+  };
+  const contentType = contentTypes[ext];
+  const fileSize = statSync(resolvedPath).size;
+  const fileName = `thumbnail${ext}`;
+
+  const spinner = villageSpinner(`Uploading thumbnail (${formatBytes(fileSize)})...`).start();
+
+  try {
+    // 1. Get presigned URL
+    const urlResult = await getGameUploadUrl(gameId, {
+      fileName,
+      assetType: 'THUMBNAIL',
+      contentType,
+      fileSize,
+    });
+
+    // 2. Upload to S3
+    spinner.text = chalk.yellow('Uploading to storage...');
+    const fileBuffer = readFileSync(resolvedPath);
+
+    await axios.put(urlResult.uploadUrl, fileBuffer, {
+      headers: { 'Content-Type': contentType },
+      maxBodyLength: Infinity,
+      maxContentLength: Infinity,
+      onUploadProgress: (progressEvent) => {
+        if (progressEvent.total) {
+          const pct = Math.round((progressEvent.loaded / progressEvent.total) * 100);
+          spinner.text = chalk.yellow(`Uploading thumbnail — ${pct}%`);
+        }
+      },
+    });
+
+    // 3. Confirm
+    spinner.text = chalk.yellow('Confirming upload...');
+    await confirmGameUpload(gameId, {
+      s3Key: urlResult.s3Key,
+      fileName,
+      assetType: 'THUMBNAIL',
+      contentType,
+    });
+
+    spinner.succeed('Thumbnail uploaded!');
+    console.log(brand.teal(`  S3 key: ${urlResult.s3Key}`));
+    console.log();
+  } catch (err) {
+    const message = err.response?.data?.error || err.message;
+    spinner.fail(`Thumbnail upload failed: ${message}`);
+  }
+}
+
+// ── game submit ─────────────────────────────────────
+
+export async function gameSubmitCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const gameId = getGameId();
+  if (!gameId) return;
+
+  // Fetch current status first
+  const checkSpinner = villageSpinner('Checking game status...').start();
+  let game;
+  try {
+    const result = await getGameDetail(gameId);
+    game = result.game;
+    checkSpinner.stop();
+  } catch (err) {
+    const message = err.response?.data?.error || err.message;
+    checkSpinner.fail(`Failed to fetch game: ${message}`);
+    return;
+  }
+
+  if (game.status === 'SUBMITTED') {
+    console.log(brand.teal(`\n  "${game.title}" is already submitted for review.\n`));
+    return;
+  }
+
+  if (game.status === 'PUBLISHED') {
+    console.log(brand.teal(`\n  "${game.title}" is already published.\n`));
+    return;
+  }
+
+  if (game.status !== 'DRAFT') {
+    console.log(brand.teal(`\n  "${game.title}" has status "${game.status}" — only DRAFT games can be submitted.\n`));
+    return;
+  }
+
+  console.log();
+  console.log(brand.gold(`  Submit "${game.title}" for admin review?`));
+  console.log(brand.teal('  An admin will review your game, set MVT rewards, and publish it.'));
+  console.log();
+
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Submit for review?',
+      default: true,
+    },
+  ]);
+
+  if (!confirm) {
+    console.log(brand.teal('\n  Cancelled.\n'));
+    return;
+  }
+
+  const spinner = villageSpinner('Submitting for review...').start();
+
+  try {
+    const result = await submitGameForReview(gameId);
+    spinner.succeed('Game submitted for review!');
+    console.log();
+    console.log(brand.green(`  ✓ "${game.title}" is now awaiting admin review.`));
+    console.log(brand.teal('  Run "myvillage status" to check the review status.'));
+    console.log();
+  } catch (err) {
+    const message = err.response?.data?.error || err.message;
+    spinner.fail(`Submit failed: ${message}`);
+  }
+}
+
+// ── Helpers ───────────────────────────────────────────
+
+function getGameId() {
+  // Check myvillage.json for gameId (Unity projects)
+  const mvPath = join(process.cwd(), 'myvillage.json');
+  if (existsSync(mvPath)) {
+    try {
+      const config = JSON.parse(readFileSync(mvPath, 'utf-8'));
+      if (config.gameId) return config.gameId;
+    } catch { /* ignore */ }
+  }
+
+  // Check package.json for gameId (Three.js projects)
+  const pkgPath = join(process.cwd(), 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      if (pkg.myvillage?.gameId) return pkg.myvillage.gameId;
+    } catch { /* ignore */ }
+  }
+
+  // Check manifest.json for a gameId field
+  const manifestPath = join(process.cwd(), 'manifest.json');
+  if (existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+      if (manifest.gameId) return manifest.gameId;
+    } catch { /* ignore */ }
+  }
+
+  console.log(chalk.red('  ✗ No game ID found.'));
+  console.log(brand.teal('  Either:'));
+  console.log(brand.teal('    • Run "myvillage deploy" first to register the game'));
+  console.log(brand.teal('    • Add "gameId" to your myvillage.json or package.json'));
+  console.log(brand.teal('    • Add "gameId" to your manifest.json'));
+  return null;
+}
+
+function formatBytes(bytes) {
+  if (!bytes) return 'unknown';
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}