auramaxx 0.0.20 → 0.1.0

package/src/server/cli/commands/onboard.ts

@@ -1,7 +1,12 @@
 import { execFileSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
 import { printBanner, printComplete, paint, ANSI } from '../lib/theme';
 import { promptSelect } from '../lib/prompt';
 
+const COMMAND_DIR = path.dirname(fileURLToPath(import.meta.url));
+const CREATE_COMMAND_PATH = path.join(COMMAND_DIR, 'create.ts');
+
 async function main() {
   printBanner();
 
@@ -28,9 +33,20 @@ async function main() {
     process.exit((error as { status?: number }).status || 1);
   }
 
-  printComplete('auramaxx installed. Get started with:');
-  console.log(`    ${paint('auramaxx start', ANSI.fgAccent)}`);
+  printComplete('auramaxx installed. Launching AuraJS create...');
+  console.log(`    ${paint('auramaxx create my-game', ANSI.fgAccent)}`);
   console.log('');
+
+  try {
+    execFileSync(process.execPath, ['--import', 'tsx', CREATE_COMMAND_PATH], {
+      stdio: 'inherit',
+      env: process.env,
+    });
+  } catch (error: unknown) {
+    console.error('');
+    console.error('  Create flow failed. Try manually: auramaxx create my-game');
+    process.exit((error as { status?: number }).status || 1);
+  }
 }
 
 main().catch((err) => {

package/src/server/cli/commands/play.ts

@@ -1,19 +1,74 @@
 import { execFileSync } from 'child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'fs';
+import { homedir, tmpdir } from 'os';
+import { join, resolve } from 'path';
+import { pathToFileURL } from 'url';
 import { printBanner, printSection, paint, ANSI } from '../lib/theme';
+import {
+  assertPublishedGameBinIntegrity,
+  buildPublishedGameLaunchEnv,
+  verifyPublishedGamePackageIntegrity,
+} from '../lib/published-game-integrity';
 
-function parseArgs(argv: string[]) {
+export { buildPublishedGameLaunchEnv } from '../lib/published-game-integrity';
+
+const FORWARDED_GAME_COMMANDS = new Set(['play', 'fork', 'join', 'publish', 'session', 'state', 'inspect', 'action']);
+
+export interface PlayCommandArgs {
+  help: boolean;
+  name: string | null;
+  gameArgs: string[];
+}
+
+export interface PlayCommandPlan extends PlayCommandArgs {
+  gameBin: string | null;
+  packageName: string | null;
+  forwardedArgs: string[];
+}
+
+export function parseArgs(argv: string[]): PlayCommandArgs {
   const separatorIndex = argv.indexOf('--');
   const head = separatorIndex >= 0 ? argv.slice(0, separatorIndex) : argv;
   const tail = separatorIndex >= 0 ? argv.slice(separatorIndex + 1) : [];
-  const positional = head.filter((arg) => !arg.startsWith('--'));
-  return {
-    help: argv.includes('--help') || argv.includes('-h'),
-    name: positional[0] || null,
-    gameArgs: [...positional.slice(1), ...tail],
-  };
+
+  let help = false;
+  let nameIndex = -1;
+  for (let index = 0; index < head.length; index += 1) {
+    const token = head[index];
+    if (token === '--help' || token === '-h') {
+      if (nameIndex === -1) {
+        help = true;
+        continue;
+      }
+    }
+    if (!token.startsWith('-')) {
+      nameIndex = index;
+      break;
+    }
+  }
+
+  const name = nameIndex >= 0 ? head[nameIndex] : null;
+  const gameArgs = nameIndex >= 0
+    ? [...head.slice(nameIndex + 1), ...tail]
+    : [...tail];
+
+  return { help, name, gameArgs };
+}
+
+export function resolvePackageName(spec: string): string {
+  const trimmed = spec.trim();
+  if (!trimmed) return trimmed;
+
+  if (trimmed.startsWith('@')) {
+    const match = trimmed.match(/^@[^/]+\/[^@/]+/);
+    return match?.[0] || trimmed;
+  }
+
+  const atIndex = trimmed.indexOf('@');
+  return atIndex === -1 ? trimmed : trimmed.slice(0, atIndex);
 }
 
-function resolveGameBin(spec: string): string {
+export function resolveGameBin(spec: string): string {
   const trimmed = spec.trim();
   if (!trimmed) return trimmed;
 
@@ -26,43 +81,246 @@ function resolveGameBin(spec: string): string {
   return atIndex === -1 ? trimmed : trimmed.slice(0, atIndex);
 }
 
-async function main() {
-  const args = parseArgs(process.argv.slice(2));
+export function resolveForwardedGameArgs(gameArgs: string[]): string[] {
+  if (!Array.isArray(gameArgs) || gameArgs.length === 0) {
+    return ['play'];
+  }
+
+  const first = String(gameArgs[0] || '').trim();
+  if (FORWARDED_GAME_COMMANDS.has(first)) {
+    return [...gameArgs];
+  }
+
+  return ['play', ...gameArgs];
+}
+
+export function buildPlayPlan(argv: string[]): PlayCommandPlan {
+  const parsed = parseArgs(argv);
+  return {
+    ...parsed,
+    gameBin: parsed.name ? resolveGameBin(parsed.name) : null,
+    packageName: parsed.name ? resolvePackageName(parsed.name) : null,
+    forwardedArgs: resolveForwardedGameArgs(parsed.gameArgs),
+  };
+}
+
+function resolveNpmCommand(): string {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+function normalizeRelativePath(pathLike: string): string {
+  return String(pathLike || '')
+    .trim()
+    .replace(/^[.][\\/]/, '')
+    .replaceAll('\\', '/');
+}
+
+function resolveInstalledPackageRoot(installRoot: string, packageName: string): string {
+  return resolve(installRoot, 'node_modules', ...packageName.split('/'));
+}
+
+function resolvePublishedGameTrustRoot(source: NodeJS.ProcessEnv): string {
+  const walletDataDir = typeof source.WALLET_DATA_DIR === 'string' && source.WALLET_DATA_DIR.trim().length > 0
+    ? source.WALLET_DATA_DIR.trim()
+    : null;
+  return walletDataDir || join(homedir(), '.auramaxx');
+}
+
+function readInstalledPackageJson(packageRoot: string) {
+  const packagePath = join(packageRoot, 'package.json');
+  if (!existsSync(packagePath)) {
+    throw new Error(`Could not read installed package metadata at ${packagePath}.`);
+  }
+  return JSON.parse(readFileSync(packagePath, 'utf8'));
+}
+
+function resolveInstalledBinRelativePath(
+  gamePackage: Record<string, unknown>,
+  expectedBinName: string | null,
+): string {
+  if (typeof gamePackage?.bin === 'string' && gamePackage.bin.trim().length > 0) {
+    return normalizeRelativePath(gamePackage.bin);
+  }
+
+  const binEntries = Object.entries((gamePackage?.bin || {}) as Record<string, unknown>)
+    .filter(([, value]) => typeof value === 'string' && value.trim().length > 0)
+    .map(([name, value]) => ({
+      name,
+      relativePath: normalizeRelativePath(String(value)),
+    }));
+
+  if (expectedBinName) {
+    const matched = binEntries.find((entry) => entry.name === expectedBinName);
+    if (matched) {
+      return matched.relativePath;
+    }
+  }
+
+  if (binEntries.length === 1) {
+    return binEntries[0].relativePath;
+  }
+
+  throw new Error(
+    `Published game package did not expose the expected bin "${expectedBinName || '<unknown>'}".`,
+  );
+}
+
+export function buildSecureInstallArgs(packageSpec: string, installRoot: string): string[] {
+  return ['install', '--ignore-scripts', '--no-save', '--prefix', installRoot, '--legacy-peer-deps', packageSpec];
+}
+
+function formatInstallError(error: unknown, packageSpec: string): Error {
+  const stderr = typeof (error as { stderr?: unknown })?.stderr === 'string'
+    ? (error as { stderr: string }).stderr.trim()
+    : '';
+  const stdout = typeof (error as { stdout?: unknown })?.stdout === 'string'
+    ? (error as { stdout: string }).stdout.trim()
+    : '';
+  const message = stderr || stdout || (error instanceof Error ? error.message : String(error));
+  return new Error(`Refusing to run ${packageSpec}: ${message}`);
+}
+
+export async function installVerifiedGamePackage(
+  plan: PlayCommandPlan,
+  {
+    execFileSyncImpl = execFileSync,
+    env = process.env,
+  }: {
+    execFileSyncImpl?: typeof execFileSync;
+    env?: NodeJS.ProcessEnv;
+  } = {},
+) {
+  if (!plan.name || !plan.packageName) {
+    throw new Error('installVerifiedGamePackage requires a resolved package spec.');
+  }
+
+  const installRoot = mkdtempSync(join(tmpdir(), 'auramaxx-play-'));
+  try {
+    execFileSyncImpl(resolveNpmCommand(), buildSecureInstallArgs(plan.name, installRoot), {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: {
+        ...env,
+        npm_config_ignore_scripts: 'true',
+      },
+      encoding: 'utf8',
+    });
 
-  if (args.help || !args.name) {
+    const packageRoot = resolveInstalledPackageRoot(installRoot, plan.packageName);
+    if (!existsSync(packageRoot)) {
+      throw new Error(`Installed package root was not found at ${packageRoot}.`);
+    }
+
+    const gamePackage = readInstalledPackageJson(packageRoot);
+    const dependencySpec = String(gamePackage?.dependencies?.['@auraindustry/aurajs'] || '').trim();
+    const integrity = assertPublishedGameBinIntegrity({
+      packageRoot,
+      projectPackage: gamePackage,
+      packageName: plan.packageName,
+      expectedAurajsVersion: dependencySpec,
+    });
+    const packageIntegrity = verifyPublishedGamePackageIntegrity({
+      packageRoot,
+      expectedPackageName: plan.packageName,
+      trustRoot: resolvePublishedGameTrustRoot(env),
+    });
+
+    const binRelativePath = resolveInstalledBinRelativePath(
+      gamePackage,
+      plan.gameBin || resolveGameBin(plan.name),
+    );
+    const binAbsolutePath = resolve(packageRoot, binRelativePath);
+    if (!existsSync(binAbsolutePath)) {
+      throw new Error(`Published game bin target "${binRelativePath}" is missing from the installed package.`);
+    }
+
+    return {
+      installRoot,
+      packageRoot,
+      packageName: plan.packageName,
+      gamePackage,
+      binRelativePath,
+      binAbsolutePath,
+      integrity,
+      packageIntegrity,
+    };
+  } catch (error: unknown) {
+    rmSync(installRoot, { recursive: true, force: true });
+    throw formatInstallError(error, plan.name);
+  }
+}
+
+function describeForwardedCommand(command: string): string {
+  switch (command) {
+    case 'fork':
+      return 'Forking editable package into local project...';
+    case 'join':
+      return 'Joining multiplayer room...';
+    case 'session':
+      return 'Starting game session...';
+    case 'state':
+      return 'Delegating to game state...';
+    case 'inspect':
+      return 'Delegating to game inspect...';
+    case 'action':
+      return 'Delegating to game action...';
+    case 'publish':
+      return 'Delegating to game publish...';
+    case 'play':
+    default:
+      return 'Starting game...';
+  }
+}
+
+export async function main(argv: string[] = process.argv.slice(2)) {
+  const plan = buildPlayPlan(argv);
+
+  if (plan.help || !plan.name) {
     printBanner('PLAY');
-    console.log(`  ${paint('Usage:', ANSI.bold)} auramaxx play <game>`);
+    console.log(`  ${paint('Usage:', ANSI.bold)} auramaxx play <game> [play|fork|join|session|state|inspect|action|publish]`);
+    console.log('');
+    console.log(`  ${paint('Examples:', ANSI.dim)}`);
+    console.log('    auramaxx play aurasu');
+    console.log('    auramaxx play aurasu fork ./aurasu-local');
+    console.log('    auramaxx play local-room-game join AURA2P');
+    console.log('    auramaxx play aurasu session start');
+    console.log('    auramaxx play aurasu state export --compact');
     console.log('');
-    console.log(`  ${paint('Example:', ANSI.dim)} auramaxx play aurasu`);
-    console.log(`  ${paint('Runs:', ANSI.dim)} npx aurasu play`);
+    console.log(`  ${paint('Runs:', ANSI.dim)} verified signed temporary install -> local game wrapper`);
     console.log('');
-    if (!args.name && !args.help) {
-      console.error(`  Missing game name.`);
+    if (!plan.name && !plan.help) {
+      console.error('  Missing game name.');
       process.exit(1);
     }
     return;
   }
 
-  const gameName = args.name;
-  const gameBin = resolveGameBin(gameName);
-  const gameArgs = args.gameArgs.length > 0 ? args.gameArgs : ['play'];
-
-  printBanner(gameName.toUpperCase());
-  printSection(gameName, 'Starting game...');
+  printBanner(plan.name.toUpperCase());
+  printSection(plan.name, describeForwardedCommand(plan.forwardedArgs[0] || 'play'));
 
+  let install: Awaited<ReturnType<typeof installVerifiedGamePackage>> | null = null;
   try {
-    execFileSync('npm', ['exec', '--yes', '--package', gameName, '--', gameBin, ...gameArgs], {
+    install = await installVerifiedGamePackage(plan);
+    const env = buildPublishedGameLaunchEnv(
+      process.env,
+      plan.forwardedArgs[0] === 'join' ? { AURA_GAME_JOIN_MODE: 'play' } : {},
+    );
+    execFileSync(process.execPath, [install.binAbsolutePath, ...plan.forwardedArgs], {
       stdio: 'inherit',
-      env: process.env,
+      cwd: install.packageRoot,
+      env,
     });
-  } catch (error: unknown) {
-    const status = (error as { status?: number }).status;
-    if (status) process.exit(status);
-    throw error;
+  } finally {
+    if (install?.installRoot) {
+      rmSync(install.installRoot, { recursive: true, force: true });
+    }
   }
 }
-
-main().catch((err) => {
-  console.error(err instanceof Error ? err.message : String(err));
-  process.exit(1);
-});
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    const status = (err as { status?: number; exitCode?: number })?.status
+      ?? (err as { status?: number; exitCode?: number })?.exitCode
+      ?? 1;
+    process.exit(Number.isInteger(status) ? status : 1);
+  });
+}

package/.next/BUILD_ID

@@ -1 +0,0 @@
-q3rrQEmg9jZ5Lt-BCTiTK