@myvillage/cli 1.0.0

package/src/commands/status.js

@@ -0,0 +1,126 @@
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { isAuthenticated } from '../utils/auth.js';
+import { getMyGames, getGameStats } from '../utils/api.js';
+
+function readPackageJson(dir) {
+  const pkgPath = join(dir, 'package.json');
+  if (!existsSync(pkgPath)) return null;
+
+  try {
+    return JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function formatDate(dateStr) {
+  if (!dateStr) return 'N/A';
+  return new Date(dateStr).toLocaleDateString('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+}
+
+export async function statusCommand() {
+  // Check authentication
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const projectDir = resolve(process.cwd());
+  const pkg = readPackageJson(projectDir);
+
+  // If in a game project directory with a gameId, show that game's status
+  if (pkg?.myvillage?.gameId) {
+    await showGameStatus(pkg.myvillage.gameId);
+    return;
+  }
+
+  // Otherwise, list all deployed games
+  await showAllGames();
+}
+
+async function showGameStatus(gameId) {
+  const spinner = ora('Fetching game status...').start();
+
+  try {
+    const stats = await getGameStats(gameId);
+
+    spinner.stop();
+
+    console.log();
+    console.log(chalk.bold(`  ${stats.name || gameId}`));
+    console.log();
+    console.log(`  Status:       ${formatStatus(stats.status)}`);
+    console.log(`  Play Count:   ${chalk.cyan(stats.playCount ?? 0)}`);
+    console.log(`  MVT Earned:   ${chalk.yellow(stats.mvtEarned ?? 0)} tokens`);
+    console.log(`  Last Updated: ${chalk.dim(formatDate(stats.lastUpdated))}`);
+
+    if (stats.url) {
+      console.log(`  URL:          ${chalk.cyan(stats.url)}`);
+    }
+    console.log();
+  } catch (err) {
+    const message = err.response?.data?.message || err.message;
+    spinner.fail(`Failed to fetch game status: ${message}`);
+  }
+}
+
+async function showAllGames() {
+  const spinner = ora('Fetching your games...').start();
+
+  try {
+    const data = await getMyGames();
+    const games = data.games || data || [];
+
+    spinner.stop();
+
+    if (!games.length) {
+      console.log();
+      console.log(chalk.dim('  No deployed games found.'));
+      console.log(chalk.dim('  Create a game with "myvillage create-game" and deploy it!'));
+      console.log();
+      return;
+    }
+
+    console.log();
+    console.log(chalk.bold(`  Your Games (${games.length})`));
+    console.log();
+
+    for (const game of games) {
+      console.log(`  ${chalk.yellow(game.name || game.gameId)}`);
+      console.log(`    Status: ${formatStatus(game.status)}  |  Plays: ${chalk.cyan(game.playCount ?? 0)}  |  MVT: ${chalk.yellow(game.mvtEarned ?? 0)}`);
+
+      if (game.url) {
+        console.log(`    ${chalk.dim(game.url)}`);
+      }
+
+      console.log();
+    }
+  } catch (err) {
+    const message = err.response?.data?.message || err.message;
+    spinner.fail(`Failed to fetch games: ${message}`);
+  }
+}
+
+function formatStatus(status) {
+  switch (status) {
+    case 'live':
+      return chalk.green('Live');
+    case 'building':
+      return chalk.yellow('Building');
+    case 'failed':
+      return chalk.red('Failed');
+    case 'pending':
+      return chalk.dim('Pending');
+    default:
+      return chalk.dim(status || 'Unknown');
+  }
+}

package/src/index.js

@@ -0,0 +1,50 @@
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import updateNotifier from 'update-notifier';
+import { loginCommand } from './commands/login.js';
+import { logoutCommand } from './commands/logout.js';
+import { createGameCommand } from './commands/create-game.js';
+import { deployCommand } from './commands/deploy.js';
+import { statusCommand } from './commands/status.js';
+
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+
+export function run() {
+  // Check for CLI updates
+  updateNotifier({ pkg }).notify();
+
+  const program = new Command();
+
+  program
+    .name('myvillage')
+    .description('MyVillageOS CLI for student game developers')
+    .version(pkg.version);
+
+  program
+    .command('login')
+    .description('Authenticate with MyVillageOS')
+    .action(loginCommand);
+
+  program
+    .command('logout')
+    .description('Clear stored credentials')
+    .action(logoutCommand);
+
+  program
+    .command('create-game')
+    .description('Create a new game project with interactive wizard')
+    .action(createGameCommand);
+
+  program
+    .command('deploy')
+    .description('Deploy your game to MyVillageOS')
+    .action(deployCommand);
+
+  program
+    .command('status')
+    .description('Check deployment status and game analytics')
+    .action(statusCommand);
+
+  program.parse();
+}

package/src/utils/api.js

@@ -0,0 +1,121 @@
+import axios from 'axios';
+import { getConfig } from './config.js';
+import { loadCredentials, saveCredentials, getAccessToken } from './auth.js';
+
+const USER_AGENT = 'MyVillageOS-CLI/1.0.0';
+
+function createClient() {
+  const config = getConfig();
+
+  const client = axios.create({
+    baseURL: config.apiBaseUrl,
+    headers: {
+      'User-Agent': USER_AGENT,
+    },
+  });
+
+  // Add auth token to requests
+  client.interceptors.request.use((reqConfig) => {
+    const token = getAccessToken();
+    if (token) {
+      reqConfig.headers.Authorization = `Bearer ${token}`;
+    }
+    return reqConfig;
+  });
+
+  // Handle 401 with token refresh
+  client.interceptors.response.use(
+    (response) => response,
+    async (error) => {
+      const originalRequest = error.config;
+
+      if (error.response?.status === 401 && !originalRequest._retry) {
+        originalRequest._retry = true;
+
+        const refreshed = await refreshAccessToken();
+        if (refreshed) {
+          originalRequest.headers.Authorization = `Bearer ${getAccessToken()}`;
+          return client(originalRequest);
+        }
+      }
+
+      return Promise.reject(error);
+    }
+  );
+
+  return client;
+}
+
+async function refreshAccessToken() {
+  const config = getConfig();
+  const creds = loadCredentials();
+
+  if (!creds?.refresh_token) {
+    return false;
+  }
+
+  try {
+    const response = await axios.post(
+      `${config.oauthBaseUrl}/token`,
+      new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: creds.refresh_token,
+        client_id: config.clientId,
+      }),
+      {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+          'User-Agent': USER_AGENT,
+        },
+      }
+    );
+
+    const { access_token, refresh_token, expires_in } = response.data;
+
+    saveCredentials({
+      ...creds,
+      access_token,
+      refresh_token: refresh_token || creds.refresh_token,
+      expires_at: Date.now() + expires_in * 1000,
+    });
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getApiClient() {
+  return createClient();
+}
+
+export async function getUserInfo(accessToken) {
+  const config = getConfig();
+
+  const response = await axios.get(`${config.oauthBaseUrl}/userinfo`, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      'User-Agent': USER_AGENT,
+    },
+  });
+
+  return response.data;
+}
+
+export async function deployGame(gameData) {
+  const client = getApiClient();
+  const response = await client.post('/games/deploy', gameData);
+  return response.data;
+}
+
+export async function getMyGames() {
+  const client = getApiClient();
+  const response = await client.get('/games/my-games');
+  return response.data;
+}
+
+export async function getGameStats(gameId) {
+  const client = getApiClient();
+  const response = await client.get(`/games/${gameId}/stats`);
+  return response.data;
+}

package/src/utils/auth.js

@@ -0,0 +1,104 @@
+import { existsSync, readFileSync, writeFileSync, unlinkSync, chmodSync } from 'fs';
+import { homedir, hostname, userInfo } from 'os';
+import { join } from 'path';
+import { createCipheriv, createDecipheriv, scryptSync, randomBytes } from 'crypto';
+import { getConfigDir } from './config.js';
+
+const CREDENTIALS_FILE = join(homedir(), '.myvillage', 'credentials.json');
+const ALGORITHM = 'aes-256-gcm';
+
+// Derive an encryption key from machine-specific data
+function getEncryptionKey() {
+  const machineId = `${hostname()}-${userInfo().username}-myvillage-cli`;
+  return scryptSync(machineId, 'myvillageos-salt', 32);
+}
+
+function encrypt(text) {
+  const key = getEncryptionKey();
+  const iv = randomBytes(16);
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+
+  let encrypted = cipher.update(text, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+
+  const authTag = cipher.getAuthTag().toString('hex');
+
+  return JSON.stringify({
+    iv: iv.toString('hex'),
+    encrypted,
+    authTag,
+  });
+}
+
+function decrypt(payload) {
+  const key = getEncryptionKey();
+  const { iv, encrypted, authTag } = JSON.parse(payload);
+
+  const decipher = createDecipheriv(ALGORITHM, key, Buffer.from(iv, 'hex'));
+  decipher.setAuthTag(Buffer.from(authTag, 'hex'));
+
+  let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+  decrypted += decipher.final('utf8');
+
+  return decrypted;
+}
+
+export function saveCredentials(credentials) {
+  getConfigDir(); // Ensure directory exists
+  const encrypted = encrypt(JSON.stringify(credentials));
+  writeFileSync(CREDENTIALS_FILE, encrypted, { mode: 0o600 });
+
+  // Ensure restrictive permissions
+  try {
+    chmodSync(CREDENTIALS_FILE, 0o600);
+  } catch {
+    // Permissions may not be supported on all platforms
+  }
+}
+
+export function loadCredentials() {
+  if (!existsSync(CREDENTIALS_FILE)) {
+    return null;
+  }
+
+  try {
+    const data = readFileSync(CREDENTIALS_FILE, 'utf-8');
+    const decrypted = decrypt(data);
+    return JSON.parse(decrypted);
+  } catch {
+    return null;
+  }
+}
+
+export function clearCredentials() {
+  if (existsSync(CREDENTIALS_FILE)) {
+    unlinkSync(CREDENTIALS_FILE);
+    return true;
+  }
+  return false;
+}
+
+export function isAuthenticated() {
+  const creds = loadCredentials();
+  if (!creds || !creds.access_token) {
+    return false;
+  }
+
+  // Check if token is expired
+  if (creds.expires_at && Date.now() >= creds.expires_at) {
+    // Token expired, but we might have a refresh token
+    return !!creds.refresh_token;
+  }
+
+  return true;
+}
+
+export function getAccessToken() {
+  const creds = loadCredentials();
+  return creds?.access_token || null;
+}
+
+export function getRefreshToken() {
+  const creds = loadCredentials();
+  return creds?.refresh_token || null;
+}

package/src/utils/config.js

@@ -0,0 +1,48 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const CONFIG_DIR = join(homedir(), '.myvillage');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+const DEFAULT_CONFIG = {
+  apiBaseUrl: 'https://portal.myvillageproject.ai/api/v1',
+  oauthBaseUrl: 'https://portal.myvillageproject.ai/api/oauth',
+  clientId: 'myvillage-cli',
+  callbackPort: 3737,
+};
+
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export function getConfig() {
+  ensureConfigDir();
+
+  if (!existsSync(CONFIG_FILE)) {
+    writeFileSync(CONFIG_FILE, JSON.stringify(DEFAULT_CONFIG, null, 2));
+    return { ...DEFAULT_CONFIG };
+  }
+
+  try {
+    const data = readFileSync(CONFIG_FILE, 'utf-8');
+    return { ...DEFAULT_CONFIG, ...JSON.parse(data) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export function setConfig(updates) {
+  ensureConfigDir();
+  const current = getConfig();
+  const merged = { ...current, ...updates };
+  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
+  return merged;
+}
+
+export function getConfigDir() {
+  ensureConfigDir();
+  return CONFIG_DIR;
+}