@auraindustry/aurajs 0.0.1

package/src/cli.mjs

@@ -0,0 +1,764 @@
+#!/usr/bin/env node
+
+import { basename, extname, resolve } from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+import { readFileSync, copyFileSync, chmodSync, rmSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import {
+  bundleProject,
+  createIncrementalBundler,
+  formatBundleError,
+  isBundleError,
+} from './bundler.mjs';
+import { scaffold } from './scaffold.mjs';
+import { packageAssets } from './asset-pack.mjs';
+import { writeBuildManifest } from './build-contract.mjs';
+import { parseTestArgs, runHeadlessTest, HeadlessTestError } from './headless-test.mjs';
+import { loadConfig, ConfigError } from './config.mjs';
+import { resolveAndCacheHostBinary, HostBinaryResolutionError } from './host-binary.mjs';
+import { runConformanceCommand } from './conformance-runner.mjs';
+
+// ---------------------------------------------------------------------------
+// Version
+// ---------------------------------------------------------------------------
+
+const PKG_PATH = new URL('../package.json', import.meta.url);
+const VERSION = JSON.parse(readFileSync(PKG_PATH, 'utf8')).version;
+
+// ---------------------------------------------------------------------------
+// Command registry
+// ---------------------------------------------------------------------------
+
+const COMMANDS = {
+  init: { description: 'Scaffold a new AuraJS project', usage: 'aura init <name>' },
+  dev: { description: 'Run with hot-reload and dev tools', usage: 'aura dev' },
+  build: {
+    description: 'Build a release binary (current host platform in v1)',
+    usage: 'aura build [--target <windows|mac|linux|all>] [--asset-mode <embed|sibling>]',
+    details: [
+      '  Options:',
+      '    --target <windows|mac|linux|all>  Target label; current host only in v1',
+      '    --asset-mode <embed|sibling>      Package assets in pak or sibling assets/',
+      '',
+      '  Notes:',
+      '    - In v1, `aura build` always emits the current host platform output.',
+      '    - `--target all` keeps current host output; use CI matrix for all platforms.',
+    ],
+  },
+  run: { description: 'Build and run the game', usage: 'aura run' },
+  clean: { description: 'Delete build artifacts', usage: 'aura clean' },
+  test: { description: 'Run game logic in headless mode', usage: 'aura test [file] [--width N] [--height N] [--frames N]' },
+  conformance: { description: 'Run API conformance suites in headless mode', usage: 'aura conformance [--mode shim|native|both] [--json]' },
+};
+
+const SUPPORTED_BUILD_TARGETS = new Set(['windows', 'mac', 'linux', 'all']);
+
+class BuildStageError extends Error {
+  constructor(stage, cause) {
+    super(`Build stage "${stage}" failed: ${cause?.message || String(cause)}`);
+    this.name = 'BuildStageError';
+    this.stage = stage;
+    this.cause = cause;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Help
+// ---------------------------------------------------------------------------
+
+function printHelp() {
+  const lines = [
+    '',
+    `  aurajs v${VERSION}`,
+    '  Write games in JavaScript, build native binaries.',
+    '',
+    '  Usage:  aura <command> [options]',
+    '',
+    '  Commands:',
+  ];
+
+  const maxCmd = Math.max(...Object.keys(COMMANDS).map((c) => c.length));
+  for (const [name, cmd] of Object.entries(COMMANDS)) {
+    lines.push(`    ${name.padEnd(maxCmd + 2)}${cmd.description}`);
+  }
+
+  lines.push('');
+  lines.push('  Options:');
+  lines.push('    --help, -h       Show this help message');
+  lines.push('    --version, -v    Show version number');
+  lines.push('');
+  lines.push('  Run "aura <command> --help" for command-specific help.');
+  lines.push('');
+
+  console.log(lines.join('\n'));
+}
+
+function printCommandHelp(name) {
+  const cmd = COMMANDS[name];
+  if (!cmd) {
+    error(`Unknown command: ${name}`);
+    return;
+  }
+  const lines = [
+    '',
+    `  ${cmd.usage}`,
+    '',
+    `  ${cmd.description}`,
+    '',
+  ];
+  if (Array.isArray(cmd.details) && cmd.details.length > 0) {
+    lines.push(...cmd.details);
+    lines.push('');
+  }
+  console.log(lines.join('\n'));
+}
+
+// ---------------------------------------------------------------------------
+// Error handling
+// ---------------------------------------------------------------------------
+
+function error(message, exitCode = 1) {
+  console.error(`\n  aura error: ${message}\n`);
+  process.exit(exitCode);
+}
+
+function parseTarget(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === '--target' && args[i + 1]) {
+      const value = args[i + 1].toLowerCase();
+      if (value === 'macos' || value === 'darwin') return 'mac';
+      if (value === 'win' || value === 'win32') return 'windows';
+      return value;
+    }
+  }
+  return null;
+}
+
+function currentPlatformTarget() {
+  if (process.platform === 'win32') return 'windows';
+  if (process.platform === 'darwin') return 'mac';
+  return 'linux';
+}
+
+function parseAssetMode(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === '--asset-mode' && args[i + 1]) {
+      return args[i + 1].toLowerCase();
+    }
+  }
+  return 'embed';
+}
+
+function encodeOptionalModulesEnv(modules) {
+  if (!modules || typeof modules !== 'object') {
+    return '';
+  }
+  const enabled = [];
+  if (modules.physics === true) enabled.push('physics');
+  if (modules.network === true) enabled.push('net');
+  if (modules.multiplayer === true) enabled.push('multiplayer');
+  if (modules.steam === true) enabled.push('steam');
+  return enabled.join(',');
+}
+
+function runBuildStage(stage, fn) {
+  try {
+    return fn();
+  } catch (err) {
+    throw new BuildStageError(stage, err);
+  }
+}
+
+function sanitizeExecutableBaseName(value) {
+  const normalized = String(value || '').trim();
+  const compact = normalized
+    .replace(/\s+/g, '-')
+    .replace(/[^A-Za-z0-9._-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^[-._]+|[-._]+$/g, '');
+  if (compact.length === 0) {
+    throw new Error(`Unable to derive a safe executable name from identity.executable="${value}".`);
+  }
+  return compact;
+}
+
+function resolveBuildIdentity(config) {
+  const identity = config?.identity || {};
+  const name = typeof identity.name === 'string' && identity.name.trim().length > 0
+    ? identity.name.trim()
+    : 'AuraJS Game';
+  const version = typeof identity.version === 'string' && identity.version.trim().length > 0
+    ? identity.version.trim()
+    : '0.1.0';
+  const executableBaseName = sanitizeExecutableBaseName(identity.executable || 'game');
+  const iconPath = typeof identity.icon === 'string' && identity.icon.trim().length > 0
+    ? identity.icon.trim()
+    : null;
+  return {
+    name,
+    version,
+    executableBaseName,
+    iconPath,
+  };
+}
+
+function resolveBuildIcon({ projectRoot, targetOutRoot, iconPath }) {
+  if (!iconPath) {
+    return {
+      configuredPath: null,
+      sourcePath: null,
+      outputPath: null,
+      status: 'not_configured',
+      reasonCode: 'icon_not_configured',
+    };
+  }
+
+  const sourcePath = resolve(projectRoot, iconPath);
+  if (!existsSync(sourcePath)) {
+    throw new Error(`Configured identity.icon was not found: ${iconPath}`);
+  }
+
+  const extension = extname(sourcePath).toLowerCase();
+  const supported = new Set(['.png', '.jpg', '.jpeg', '.ico', '.icns']);
+  if (!supported.has(extension)) {
+    throw new Error(`Configured identity.icon must use one of ${[...supported].join(', ')}, got: ${basename(sourcePath)}`);
+  }
+
+  const outputDir = resolve(targetOutRoot, 'meta');
+  mkdirSync(outputDir, { recursive: true });
+  const outputPath = resolve(outputDir, `icon${extension}`);
+  copyFileSync(sourcePath, outputPath);
+
+  return {
+    configuredPath: iconPath,
+    sourcePath,
+    outputPath,
+    status: 'copied',
+    reasonCode: 'icon_copied',
+  };
+}
+
+function executableNameForPlatform(target, executableBaseName = 'game') {
+  if (target === 'windows') {
+    return `${executableBaseName}.exe`;
+  }
+  return executableBaseName;
+}
+
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+
+async function cmdInit(args) {
+  const name = args[0];
+  if (!name) {
+    error('Missing project name. Usage: aura init <name>');
+  }
+
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    error('Project name must contain only letters, numbers, hyphens, and underscores.');
+  }
+
+  const dest = resolve(process.cwd(), name);
+
+  try {
+    const result = scaffold(name, dest);
+    console.log(`\n  Created "${name}" at ${dest}`);
+    console.log('');
+    for (const file of result.files) {
+      console.log(`    ${file}`);
+    }
+    console.log('');
+    console.log('  Get started:');
+    console.log(`    cd ${name}`);
+    console.log('    aura dev');
+    console.log('');
+  } catch (err) {
+    error(err.message);
+  }
+}
+
+async function cmdDev(_args) {
+  const projectRoot = process.cwd();
+  const config = await loadConfig({ projectRoot, mode: 'dev' });
+  const identity = resolveBuildIdentity(config);
+  const hostBinary = resolveAndCacheHostBinary();
+  const incremental = createIncrementalBundler({
+    projectRoot,
+    entryFile: config.build.entry,
+  });
+
+  let shuttingDown = false;
+  let hostChild = null;
+  let restartChain = Promise.resolve();
+
+  const runBundle = (trigger) => {
+    const result = incremental.build({ mode: 'dev' });
+    console.log(`\n  aura dev: ${trigger}`);
+    console.log(`  Bundle: ${result.outFile}`);
+    console.log(`  Modules: ${result.moduleCount}`);
+    console.log(`  Hash: ${result.hash.slice(0, 8)}`);
+    console.log(`  Rebuild: ${result.elapsedMs}ms`);
+    return result;
+  };
+
+  const stopHost = async (reason) => {
+    const child = hostChild;
+    if (!child) return;
+
+    hostChild = null;
+
+    // Child is already gone — nothing to signal.
+    if (child.exitCode !== null || child.signalCode !== null) {
+      return;
+    }
+
+    await new Promise((resolvePromise) => {
+      let settled = false;
+      let killTimer = null;
+
+      const settle = () => {
+        if (settled) return;
+        settled = true;
+        if (killTimer !== null) {
+          clearTimeout(killTimer);
+        }
+        resolvePromise();
+      };
+
+      const onExit = () => {
+        child.removeListener('exit', onExit);
+        settle();
+      };
+
+      child.once('exit', onExit);
+
+      killTimer = setTimeout(() => {
+        try {
+          child.kill('SIGKILL');
+        } catch {}
+      }, 1500);
+
+      try {
+        child.kill('SIGTERM');
+      } catch {
+        settle();
+      }
+    });
+
+    if (!shuttingDown) {
+      console.log(`  aura dev: host stopped (${reason}).`);
+    }
+  };
+
+  const startHost = (entrypoint, reason) => {
+    if (shuttingDown) return;
+
+    const child = spawn(hostBinary.binaryPath, [entrypoint], {
+      cwd: projectRoot,
+      stdio: 'inherit',
+      env: {
+        ...process.env,
+        AURA_MODE: 'dev',
+        AURA_OPTIONAL_MODULES: encodeOptionalModulesEnv(config.modules),
+        AURA_GAME_NAME: identity.name,
+        AURA_GAME_VERSION: identity.version,
+        AURA_GAME_EXECUTABLE: identity.executableBaseName,
+      },
+    });
+
+    hostChild = child;
+    console.log(`  aura dev: host started (pid=${child.pid ?? 'n/a'}, reason=${reason}).`);
+
+    child.once('error', (err) => {
+      if (!shuttingDown) {
+        console.error(`\n  aura dev host error: ${err.message}\n`);
+      }
+    });
+
+    child.once('exit', (code, signal) => {
+      if (hostChild === child) {
+        hostChild = null;
+      }
+      if (!shuttingDown) {
+        if (signal) {
+          console.log(`  aura dev: host exited by signal ${signal}.`);
+        } else {
+          console.log(`  aura dev: host exited with code ${code ?? 0}.`);
+        }
+      }
+    });
+  };
+
+  const queueHostRestart = (entrypoint, reason) => {
+    restartChain = restartChain
+      .then(async () => {
+        if (hostChild) {
+          console.log(`  aura dev: restarting host (${reason}).`);
+          await stopHost('reload');
+        }
+        if (!shuttingDown) {
+          startHost(entrypoint, reason);
+        }
+      })
+      .catch((err) => {
+        console.error(`\n  aura dev restart error: ${err.message}\n`);
+      });
+    return restartChain;
+  };
+
+  const initial = runBundle('initial bundle complete');
+  console.log(`  Host package: ${hostBinary.packageName}`);
+  console.log(`  Host binary: ${hostBinary.binaryPath}`);
+  console.log(`  Host cache: ${hostBinary.cacheStatus} (${hostBinary.cacheDir})`);
+  for (const diagnostic of hostBinary.diagnostics || []) {
+    console.log(`  Host diagnostic: ${diagnostic}`);
+  }
+  startHost(initial.outFile, 'initial');
+  console.log('\n  Watching src/ for changes... (Ctrl+C to stop)');
+
+  let pendingTimer = null;
+
+  const stopWatch = incremental.watch(
+    () => {
+      clearTimeout(pendingTimer);
+      pendingTimer = setTimeout(() => {
+        try {
+          const next = runBundle('source change rebuilt');
+          void queueHostRestart(next.outFile, 'source change');
+        } catch (bundleError) {
+          console.error(`\n  aura dev rebuild failed:\n${formatBundleError(bundleError, projectRoot)}\n`);
+        }
+      }, 75);
+    },
+    (watchError) => {
+      console.error(`\n  aura dev watch error: ${watchError.message}\n`);
+    },
+  );
+
+  await new Promise((resolvePromise) => {
+    let closed = false;
+
+    const shutdown = () => {
+      if (closed) return;
+      closed = true;
+      shuttingDown = true;
+      process.off('SIGINT', shutdown);
+      process.off('SIGTERM', shutdown);
+      clearTimeout(pendingTimer);
+      stopWatch();
+      incremental.dispose();
+      restartChain
+        .then(() => stopHost('shutdown'))
+        .finally(() => resolvePromise());
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+  });
+}
+
+async function cmdBuild(args) {
+  const target = parseTarget(args);
+  if (target && !SUPPORTED_BUILD_TARGETS.has(target)) {
+    throw new Error(`Unsupported --target "${target}". Supported values: windows, mac, linux, all.`);
+  }
+
+  const requestedTarget = target || currentPlatformTarget();
+  const projectRoot = process.cwd();
+  const config = await loadConfig({ projectRoot, mode: 'build' });
+  const identity = resolveBuildIdentity(config);
+  const platformTarget = currentPlatformTarget();
+  const effectiveTarget = platformTarget;
+  const targetOutRoot = resolve(projectRoot, config.build.outDir, effectiveTarget);
+  const executableFileName = executableNameForPlatform(effectiveTarget, identity.executableBaseName);
+
+  // CLI --asset-mode flag overrides config if provided.
+  const cliAssetMode = parseAssetMode(args);
+  const assetMode = args.some((a) => a === '--asset-mode') ? cliAssetMode : config.build.assetMode;
+
+  const result = runBuildStage('bundle', () => bundleProject({
+    projectRoot,
+    mode: 'build',
+    entryFile: config.build.entry,
+    outFile: resolve(targetOutRoot, 'js/game.bundle.js'),
+  }));
+
+  const assets = runBuildStage('asset-pack', () => packageAssets({
+    projectRoot,
+    outRoot: targetOutRoot,
+    mode: assetMode,
+  }));
+  const hostBinary = runBuildStage('host-binary-resolve', () => resolveAndCacheHostBinary());
+  const executablePath = runBuildStage('host-binary-copy', () => {
+    const outPath = resolve(targetOutRoot, executableFileName);
+    copyFileSync(hostBinary.binaryPath, outPath);
+    if (effectiveTarget !== 'windows') {
+      chmodSync(outPath, 0o755);
+    }
+    return outPath;
+  });
+  const icon = runBuildStage('identity-icon', () => resolveBuildIcon({
+    projectRoot,
+    targetOutRoot,
+    iconPath: identity.iconPath,
+  }));
+  const buildManifestPath = runBuildStage('build-contract', () => writeBuildManifest({
+    outRoot: targetOutRoot,
+    bundlePath: result.outFile,
+    assetsManifestPath: assets.manifestPath,
+    executablePath,
+    assetMode: assets.mode,
+    identity: {
+      name: identity.name,
+      version: identity.version,
+      windowTitle: config.window.title,
+      executableBaseName: identity.executableBaseName,
+      executableFileName,
+    },
+    icon,
+  }));
+
+  console.log('\n  aura build: JavaScript bundle complete.');
+  console.log(`  Game: ${identity.name}`);
+  console.log(`  Version: ${identity.version}`);
+  console.log(`  Bundle: ${result.outFile}`);
+  console.log(`  Modules: ${result.moduleCount}`);
+  console.log(`  Hash: ${result.hash.slice(0, 8)}`);
+  console.log(`  Time: ${result.elapsedMs}ms`);
+  console.log('');
+  console.log(`  Assets: ${assets.assetCount}`);
+  console.log(`  Asset mode: ${assets.mode}`);
+  console.log(`  Asset manifest hash: ${assets.manifestHash}`);
+  console.log(
+    `  Asset incremental: copied=${assets.incremental.copied} skipped=${assets.incremental.skipped} removed=${assets.incremental.removed} reusedPack=${assets.incremental.reusedPack}`,
+  );
+  if (assets.packPath) {
+    console.log(`  Asset pack: ${assets.packPath}`);
+  }
+  console.log(`  Asset manifest: ${assets.manifestPath}`);
+  console.log(`  Build manifest: ${buildManifestPath}`);
+  console.log(`  Host package: ${hostBinary.packageName}`);
+  console.log(`  Host binary: ${hostBinary.binaryPath}`);
+  console.log(`  Host cache: ${hostBinary.cacheStatus} (${hostBinary.cacheDir})`);
+  for (const diagnostic of hostBinary.diagnostics || []) {
+    console.log(`  Host diagnostic: ${diagnostic}`);
+  }
+  console.log(`  Executable: ${executablePath}`);
+  console.log(`  Executable base name: ${identity.executableBaseName}`);
+  if (icon.status === 'copied') {
+    console.log(`  Icon: ${icon.outputPath}`);
+  } else {
+    console.log(`  Icon: ${icon.status} (${icon.reasonCode})`);
+  }
+  console.log(`  Output target: ${effectiveTarget}`);
+
+  if (target && target !== platformTarget && target !== 'all') {
+    console.log('');
+    console.log(`  Native target requested: ${requestedTarget}`);
+    console.log(`  Built target: ${platformTarget} (current host only in v1).`);
+    console.log('  Note: cross-platform native compile is handled by CI in v1.');
+  } else if (target === 'all') {
+    console.log('');
+    console.log('  --target all in v1 builds only the current host platform.');
+    console.log('  Note: use CI matrix to build and publish all targets.');
+  }
+
+  console.log('');
+
+  return {
+    projectRoot,
+    config,
+    requestedTarget,
+    platformTarget,
+    effectiveTarget,
+    targetOutRoot,
+    executablePath,
+    bundlePath: result.outFile,
+    assetsManifestPath: assets.manifestPath,
+    buildManifestPath,
+    assetMode: assets.mode,
+    identity,
+  };
+}
+
+async function cmdRun(args) {
+  const built = await cmdBuild(args);
+  const launchContract = built.buildManifestPath;
+
+  console.log('  aura run: launching native host.');
+  console.log(`  Executable: ${built.executablePath}`);
+  console.log(`  Build manifest: ${launchContract}`);
+  console.log(`  Working dir: ${built.projectRoot}`);
+  console.log('');
+
+  const child = spawnSync(built.executablePath, [launchContract], {
+    cwd: built.projectRoot,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      AURA_MODE: 'release',
+      AURA_OPTIONAL_MODULES: encodeOptionalModulesEnv(built.config.modules),
+      AURA_GAME_NAME: built.identity.name,
+      AURA_GAME_VERSION: built.identity.version,
+      AURA_GAME_EXECUTABLE: built.identity.executableBaseName,
+    },
+  });
+
+  if (child.error) {
+    throw new Error(
+      `Failed to launch built host "${built.executablePath}": ${child.error.message}`,
+    );
+  }
+
+  if (typeof child.status === 'number' && child.status !== 0) {
+    throw new Error(`Native host exited with code ${child.status}.`);
+  }
+
+  if (child.signal) {
+    throw new Error(`Native host terminated by signal ${child.signal}.`);
+  }
+}
+
+async function cmdClean(_args) {
+  const projectRoot = process.cwd();
+  const config = await loadConfig({ projectRoot, mode: 'build' });
+
+  const candidates = [
+    resolve(projectRoot, config.build.outDir),
+    resolve(projectRoot, '.aura/dev'),
+    resolve(projectRoot, '.aura/test'),
+  ];
+
+  const removed = [];
+  for (const path of candidates) {
+    if (!existsSync(path)) continue;
+    rmSync(path, { recursive: true, force: true });
+    removed.push(path);
+  }
+
+  const auraRoot = resolve(projectRoot, '.aura');
+  if (existsSync(auraRoot) && readdirSync(auraRoot).length === 0) {
+    rmSync(auraRoot, { recursive: true, force: true });
+    removed.push(auraRoot);
+  }
+
+  console.log('\n  aura clean: complete.');
+  if (removed.length === 0) {
+    console.log('  Nothing to remove.');
+  } else {
+    for (const path of removed) {
+      console.log(`  Removed: ${path}`);
+    }
+  }
+  console.log('');
+}
+
+async function cmdTest(args) {
+  const parsed = parseTestArgs(args);
+  const result = await runHeadlessTest({
+    projectRoot: process.cwd(),
+    file: parsed.file,
+    width: parsed.width,
+    height: parsed.height,
+    frames: parsed.frames,
+  });
+
+  console.log('\n  aura test: headless run complete.');
+  console.log(`  Entry: ${result.entryFile}`);
+  console.log(`  Bundle: ${result.bundle.outFile}`);
+  console.log(`  Modules: ${result.bundle.moduleCount}`);
+  console.log(`  Frames: ${result.frames}`);
+  console.log(`  Window: ${result.width}x${result.height}`);
+  console.log(`  Assertions passed: ${result.passes}`);
+  console.log(`  Draw calls captured: ${result.drawCalls}`);
+  console.log(`  Audio calls captured: ${result.audioCalls}`);
+  console.log('');
+}
+
+async function cmdConformance(args) {
+  const exitCode = await runConformanceCommand(args, console);
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}
+
+const HANDLERS = {
+  init: cmdInit,
+  dev: cmdDev,
+  build: cmdBuild,
+  run: cmdRun,
+  clean: cmdClean,
+  test: cmdTest,
+  conformance: cmdConformance,
+};
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const argv = process.argv.slice(2);
+
+  if (argv.length === 0) {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (argv.includes('--version') || argv.includes('-v')) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+
+  if (argv[0] === '--help' || argv[0] === '-h') {
+    printHelp();
+    process.exit(0);
+  }
+
+  const command = argv[0];
+
+  if (argv.includes('--help') || argv.includes('-h')) {
+    printCommandHelp(command);
+    process.exit(0);
+  }
+
+  if (!COMMANDS[command]) {
+    error(`Unknown command: "${command}". Run "aura --help" for available commands.`);
+  }
+
+  const commandArgs = argv.slice(1).filter((a) => a !== '--help' && a !== '-h');
+  try {
+    await HANDLERS[command](commandArgs);
+  } catch (err) {
+    if (err instanceof ConfigError) {
+      error(err.message, 4);
+    }
+    if (err instanceof HeadlessTestError) {
+      if (Array.isArray(err.details?.failures) && err.details.failures.length > 0) {
+        console.error('\n  aura test failures:');
+        for (const failure of err.details.failures) {
+          console.error(`  - ${failure}`);
+        }
+        console.error('');
+      }
+      error(err.message, 3);
+    }
+    if (isBundleError(err)) {
+      error(formatBundleError(err, process.cwd()), 2);
+    }
+    if (err instanceof BuildStageError) {
+      if (isBundleError(err.cause)) {
+        error(`Build stage "${err.stage}" failed:\n${formatBundleError(err.cause, process.cwd())}`, 2);
+      }
+      if (err.cause instanceof HostBinaryResolutionError) {
+        error(`Build stage "${err.stage}" failed: ${err.cause.message}`, 5);
+      }
+      error(err.message);
+    }
+    if (err instanceof HostBinaryResolutionError) {
+      error(err.message, 5);
+    }
+    error(err.message);
+  }
+}
+
+main();