@auraindustry/aurajs 0.1.1 → 0.1.5

package/src/mobile/android/build.mjs

@@ -0,0 +1,606 @@
+import { spawnSync } from 'node:child_process';
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const ANDROID_BUILD_MANIFEST_SCHEMA = 'aurajs.android-build-manifest.v1';
+export const ANDROID_BUILD_MANIFEST_VERSION = '1.0.0';
+export const ANDROID_BUILD_TARGET = 'android';
+export const ANDROID_BOOTSTRAP_CHOICE = 'aurajs_android_shell_v1';
+export const ANDROID_PACKAGED_ASSETS_ROOT = 'assets/aura';
+export const ANDROID_NATIVE_LIBRARY_NAME = 'libaurajs_host.so';
+export const ANDROID_NATIVE_LIBRARY_BASENAME = 'aurajs_host';
+export const ANDROID_ABI_FLOOR = Object.freeze(['arm64-v8a']);
+export const ANDROID_RELEASE_OUTPUT_RELATIVE_PATH = 'app/build/outputs/bundle/release/app-release.aab';
+export const ANDROID_DEBUG_OUTPUT_RELATIVE_PATH = 'app/build/outputs/apk/debug/app-debug.apk';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const TEMPLATE_ROOT = resolve(here, '../../../../platform/android/template');
+const DIST_ROOT = resolve(here, '../../../../platform/dist/android');
+
+const TEMPLATE_FILES = Object.freeze([
+  'settings.gradle.kts',
+  'build.gradle.kts',
+  'gradle.properties',
+  'gradlew',
+  'gradlew.bat',
+  'gradle/wrapper/gradle-wrapper.jar',
+  'gradle/wrapper/gradle-wrapper.properties',
+  'app/build.gradle.kts',
+  'app/proguard-rules.pro',
+  'app/src/main/AndroidManifest.xml',
+  'app/src/main/java/dev/aurajs/runtime/MainActivity.kt',
+]);
+
+const TEMPLATE_BINARY_FILES = new Set([
+  'gradle/wrapper/gradle-wrapper.jar',
+]);
+
+export function detectAndroidToolchain(options = {}) {
+  const env = options.env && typeof options.env === 'object' ? options.env : process.env;
+  const cwd = resolve(options.cwd || process.cwd());
+  const sdkRoot = normalizeOptionalPath(env.ANDROID_SDK_ROOT || env.ANDROID_HOME || null);
+  const ndkRoot = normalizeOptionalPath(env.ANDROID_NDK_ROOT || env.ANDROID_NDK_HOME || null);
+  const javaHome = normalizeOptionalPath(env.JAVA_HOME || null);
+  const localGradlePath = resolve(cwd, 'gradlew');
+  const reasonCodes = [];
+
+  if (!sdkRoot) reasonCodes.push('android_sdk_missing');
+  if (!javaHome) reasonCodes.push('android_java_home_missing');
+
+  return {
+    ready: reasonCodes.length === 0,
+    sdkRoot,
+    ndkRoot,
+    javaHome,
+    gradleWrapperPath: existsSync(localGradlePath) ? localGradlePath : null,
+    reasonCodes,
+  };
+}
+
+export function stageAndroidProject(options = {}) {
+  const projectRoot = resolve(options.projectRoot || process.cwd());
+  const outRoot = resolve(options.outRoot || join(projectRoot, 'build', 'android'));
+  const bundlePath = resolveRequiredPath(options.bundlePath, 'bundlePath');
+  const assetsPackPath = resolveRequiredPath(
+    options.assetsPackPath || options.assetPackPath,
+    'assetsPackPath',
+  );
+  const sourceBuildManifestPath = options.sourceBuildManifestPath
+    ? resolve(options.sourceBuildManifestPath)
+    : null;
+  const runtimeConfigPath = options.runtimeConfigPath
+    ? resolve(options.runtimeConfigPath)
+    : null;
+  const nativeHostLibraryContract = resolveNativeHostLibraryContract({
+    projectRoot,
+    nativeHostLibraryPath: options.nativeHostLibraryPath || null,
+    distRoot: options.distRoot || DIST_ROOT,
+  });
+  const toolchain = detectAndroidToolchain({
+    env: options.env,
+    cwd: projectRoot,
+  });
+
+  const identity = normalizeAndroidIdentity(options.identity || {});
+  const renderContext = {
+    APP_SLUG: identity.slug,
+    APP_NAME: identity.name,
+    APPLICATION_ID: identity.applicationId,
+    VERSION_CODE: String(identity.versionCode),
+    VERSION_NAME: identity.versionName,
+    NATIVE_LIBRARY_BASENAME: ANDROID_NATIVE_LIBRARY_BASENAME,
+  };
+
+  mkdirSync(outRoot, { recursive: true });
+  const appRoot = join(outRoot, 'app');
+  const stagedAssetsRoot = join(appRoot, 'src', 'main', ANDROID_PACKAGED_ASSETS_ROOT);
+  const stagedNativeLibRoot = join(appRoot, 'src', 'main', 'jniLibs', ANDROID_ABI_FLOOR[0]);
+  mkdirSync(stagedAssetsRoot, { recursive: true });
+  mkdirSync(stagedNativeLibRoot, { recursive: true });
+  mkdirSync(join(outRoot, 'release'), { recursive: true });
+  mkdirSync(join(outRoot, 'debug'), { recursive: true });
+
+  const templateOutputs = [];
+  for (const relativeTemplatePath of TEMPLATE_FILES) {
+    const templatePath = join(TEMPLATE_ROOT, ...relativeTemplatePath.split('/'));
+    const outputPath = join(outRoot, ...relativeTemplatePath.split('/'));
+    mkdirSync(dirname(outputPath), { recursive: true });
+    if (TEMPLATE_BINARY_FILES.has(relativeTemplatePath)) {
+      copyFileSync(templatePath, outputPath);
+    } else {
+      const rendered = renderTemplate(readFileSync(templatePath, 'utf8'), renderContext);
+      writeFileSync(outputPath, rendered, 'utf8');
+    }
+    if (relativeTemplatePath === 'gradlew') {
+      chmodSync(outputPath, 0o755);
+    }
+    templateOutputs.push(relativeTemplatePath.replace(/\\/g, '/'));
+  }
+
+  const stagedBundlePath = join(stagedAssetsRoot, 'bundle.js');
+  const stagedAssetPackPath = join(stagedAssetsRoot, 'assets.pak');
+  copyFileSync(bundlePath, stagedBundlePath);
+  copyFileSync(assetsPackPath, stagedAssetPackPath);
+
+  const stagedBuildManifestPath = sourceBuildManifestPath
+    ? join(stagedAssetsRoot, 'build-manifest.json')
+    : null;
+  if (sourceBuildManifestPath) {
+    copyFileSync(sourceBuildManifestPath, stagedBuildManifestPath);
+  }
+
+  const stagedRuntimeConfigPath = runtimeConfigPath
+    ? join(stagedAssetsRoot, 'runtime-config.json')
+    : null;
+  if (runtimeConfigPath) {
+    copyFileSync(runtimeConfigPath, stagedRuntimeConfigPath);
+  }
+
+  let stagedNativeLibraryPath = null;
+  let nativeLibraryStaged = false;
+  let nativeLibrarySizeBytes = null;
+  if (nativeHostLibraryContract.exists) {
+    stagedNativeLibraryPath = join(stagedNativeLibRoot, ANDROID_NATIVE_LIBRARY_NAME);
+    copyFileSync(nativeHostLibraryContract.sourcePath, stagedNativeLibraryPath);
+    nativeLibraryStaged = true;
+    nativeLibrarySizeBytes = statSync(stagedNativeLibraryPath).size;
+  }
+
+  const manifest = {
+    schema: ANDROID_BUILD_MANIFEST_SCHEMA,
+    schemaVersion: ANDROID_BUILD_MANIFEST_VERSION,
+    buildTarget: ANDROID_BUILD_TARGET,
+    releaseArtifact: `release/${identity.slug}.aab`,
+    debugArtifact: options.includeDebugArtifact === false ? null : `debug/${identity.slug}-debug.apk`,
+    applicationId: identity.applicationId,
+    appName: identity.name,
+    versionCode: identity.versionCode,
+    versionName: identity.versionName,
+    abis: [...ANDROID_ABI_FLOOR],
+    nativeLibraries: [ANDROID_NATIVE_LIBRARY_NAME],
+    packagedAssetsRoot: ANDROID_PACKAGED_ASSETS_ROOT,
+    bootstrapChoice: ANDROID_BOOTSTRAP_CHOICE,
+    templateRoot: 'app',
+    stagedFiles: {
+      bundle: toPosix(relative(outRoot, stagedBundlePath)),
+      assetPack: toPosix(relative(outRoot, stagedAssetPackPath)),
+      buildManifest: stagedBuildManifestPath ? toPosix(relative(outRoot, stagedBuildManifestPath)) : null,
+      runtimeConfig: stagedRuntimeConfigPath ? toPosix(relative(outRoot, stagedRuntimeConfigPath)) : null,
+      nativeLibrary: stagedNativeLibraryPath ? toPosix(relative(outRoot, stagedNativeLibraryPath)) : null,
+    },
+    buildStatus: {
+      release: 'not_built',
+      debug: options.includeDebugArtifact === false ? 'not_requested' : 'not_built',
+      reasonCode: 'android_external_build_not_run',
+    },
+    toolchain,
+    staging: {
+      templateFiles: templateOutputs,
+      nativeLibraryStaged,
+      nativeLibrarySizeBytes,
+      nativeLibraryContract: {
+        sourceKind: nativeHostLibraryContract.sourceKind,
+        reasonCode: nativeHostLibraryContract.reasonCode,
+        sourcePath: nativeHostLibraryContract.sourcePath
+          ? relativeToRootOrAbsolute(projectRoot, nativeHostLibraryContract.sourcePath)
+          : null,
+      },
+    },
+  };
+
+  const manifestPath = join(outRoot, 'android-build-manifest.json');
+  writeCanonicalJsonFile(manifestPath, manifest);
+
+  return {
+    outRoot,
+    appRoot,
+    manifestPath,
+    stagedAssetsRoot,
+    stagedNativeLibRoot,
+    toolchain,
+    manifest,
+  };
+}
+
+export function detectAndroidGradleExecutable(options = {}) {
+  const env = options.env && typeof options.env === 'object' ? options.env : process.env;
+  const spawnSyncImpl = options.spawnSyncImpl || spawnSync;
+  const cwd = resolve(options.cwd || process.cwd());
+  const explicitPath = normalizeOptionalPath(env.AURA_ANDROID_GRADLE || options.gradleExecutable || null);
+  if (explicitPath) {
+    return {
+      available: true,
+      executablePath: explicitPath,
+      sourceKind: 'explicit_input',
+      reasonCode: 'android_gradle_explicit',
+    };
+  }
+
+  const localGradlePath = normalizeOptionalPath(join(cwd, 'gradlew'));
+  if (localGradlePath) {
+    return {
+      available: true,
+      executablePath: localGradlePath,
+      sourceKind: 'local_wrapper',
+      reasonCode: 'android_gradle_wrapper',
+    };
+  }
+
+  const probe = spawnSyncImpl('gradle', ['--version'], {
+    cwd,
+    encoding: 'utf8',
+    env,
+  });
+  if (probe && probe.status === 0) {
+    return {
+      available: true,
+      executablePath: 'gradle',
+      sourceKind: 'path',
+      reasonCode: 'android_gradle_path',
+    };
+  }
+
+  return {
+    available: false,
+    executablePath: null,
+    sourceKind: 'missing',
+    reasonCode: 'android_gradle_missing',
+  };
+}
+
+export function buildAndroidArtifacts(options = {}) {
+  const outRoot = resolveRequiredPath(options.outRoot, 'outRoot');
+  const manifestPath = resolveRequiredPath(
+    options.manifestPath || join(outRoot, 'android-build-manifest.json'),
+    'manifestPath',
+  );
+  const env = options.env && typeof options.env === 'object' ? options.env : process.env;
+  const spawnSyncImpl = options.spawnSyncImpl || spawnSync;
+  const buildTargets = normalizeAndroidBuildTargets(options.buildTargets);
+  const manifest = readAndroidBuildManifest(manifestPath);
+  const toolchain = detectAndroidToolchain({
+    env,
+    cwd: outRoot,
+  });
+  const gradle = detectAndroidGradleExecutable({
+    env,
+    cwd: outRoot,
+    spawnSyncImpl,
+    gradleExecutable: options.gradleExecutable || null,
+  });
+
+  if (!toolchain.ready) {
+    manifest.buildStatus = {
+      ...manifest.buildStatus,
+      reasonCode: 'android_toolchain_unavailable',
+      release: buildTargets.release ? 'not_built' : manifest.buildStatus.release,
+      debug: buildTargets.debug ? 'not_built' : manifest.buildStatus.debug,
+    };
+    writeCanonicalJsonFile(manifestPath, manifest);
+    return {
+      ok: false,
+      reasonCode: 'android_toolchain_unavailable',
+      manifestPath,
+      manifest,
+      toolchain,
+      gradle,
+    };
+  }
+
+  if (!gradle.available) {
+    manifest.buildStatus = {
+      ...manifest.buildStatus,
+      reasonCode: 'android_gradle_missing',
+      release: buildTargets.release ? 'not_built' : manifest.buildStatus.release,
+      debug: buildTargets.debug ? 'not_built' : manifest.buildStatus.debug,
+    };
+    writeCanonicalJsonFile(manifestPath, manifest);
+    return {
+      ok: false,
+      reasonCode: 'android_gradle_missing',
+      manifestPath,
+      manifest,
+      toolchain,
+      gradle,
+    };
+  }
+
+  const nativeLibraryReasonCode = manifest.staging?.nativeLibraryContract?.reasonCode || null;
+  if (!manifest.staging?.nativeLibraryStaged) {
+    manifest.buildStatus = {
+      ...manifest.buildStatus,
+      reasonCode: nativeLibraryReasonCode || 'android_native_host_library_missing',
+      release: buildTargets.release ? 'not_built' : manifest.buildStatus.release,
+      debug: buildTargets.debug ? 'not_built' : manifest.buildStatus.debug,
+    };
+    writeCanonicalJsonFile(manifestPath, manifest);
+    return {
+      ok: false,
+      reasonCode: nativeLibraryReasonCode || 'android_native_host_library_missing',
+      manifestPath,
+      manifest,
+      toolchain,
+      gradle,
+    };
+  }
+
+  const localPropertiesPath = writeAndroidLocalProperties(outRoot, toolchain.sdkRoot);
+  const outputs = {
+    release: null,
+    debug: null,
+  };
+  const executedTasks = [];
+  const baseEnv = {
+    ...env,
+  };
+  if (toolchain.sdkRoot) {
+    baseEnv.ANDROID_SDK_ROOT = toolchain.sdkRoot;
+  }
+  if (toolchain.javaHome) {
+    baseEnv.JAVA_HOME = toolchain.javaHome;
+  }
+
+  if (buildTargets.release) {
+    executeAndroidGradleTask({
+      outRoot,
+      gradle,
+      env: baseEnv,
+      spawnSyncImpl,
+      taskName: 'bundleRelease',
+    });
+    const stagedReleasePath = join(outRoot, manifest.releaseArtifact);
+    copyBuildOutput(
+      join(outRoot, ANDROID_RELEASE_OUTPUT_RELATIVE_PATH),
+      stagedReleasePath,
+      'release artifact',
+    );
+    outputs.release = stagedReleasePath;
+    executedTasks.push('bundleRelease');
+  }
+
+  if (buildTargets.debug && manifest.debugArtifact) {
+    executeAndroidGradleTask({
+      outRoot,
+      gradle,
+      env: baseEnv,
+      spawnSyncImpl,
+      taskName: 'assembleDebug',
+    });
+    const stagedDebugPath = join(outRoot, manifest.debugArtifact);
+    copyBuildOutput(
+      join(outRoot, ANDROID_DEBUG_OUTPUT_RELATIVE_PATH),
+      stagedDebugPath,
+      'debug artifact',
+    );
+    outputs.debug = stagedDebugPath;
+    executedTasks.push('assembleDebug');
+  }
+
+  manifest.toolchain = {
+    ...toolchain,
+    gradleExecutable: gradle.executablePath,
+    gradleReasonCode: gradle.reasonCode,
+  };
+  manifest.buildStatus = {
+    release: buildTargets.release ? 'built' : manifest.buildStatus.release,
+    debug: buildTargets.debug
+      ? (manifest.debugArtifact ? 'built' : 'not_requested')
+      : manifest.buildStatus.debug,
+    reasonCode: 'android_gradle_build_complete',
+    executedTasks,
+    localPropertiesPath: relativeToRootOrAbsolute(outRoot, localPropertiesPath),
+  };
+  writeCanonicalJsonFile(manifestPath, manifest);
+
+  return {
+    ok: true,
+    reasonCode: 'android_gradle_build_complete',
+    manifestPath,
+    manifest,
+    toolchain: manifest.toolchain,
+    gradle,
+    outputs,
+    localPropertiesPath,
+  };
+}
+
+function normalizeAndroidIdentity(identity) {
+  const name = normalizeName(identity.name || 'AuraJS Game');
+  const slug = normalizeSlug(identity.slug || name);
+  const applicationId = normalizeApplicationId(identity.applicationId || `dev.aurajs.${slug}`);
+  const versionCode = normalizeVersionCode(identity.versionCode);
+  const versionName = normalizeVersionName(identity.versionName);
+  return {
+    name,
+    slug,
+    applicationId,
+    versionCode,
+    versionName,
+  };
+}
+
+function normalizeName(value) {
+  const text = String(value || '').trim();
+  return text || 'AuraJS Game';
+}
+
+function normalizeSlug(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    || 'aurajs-game';
+}
+
+function normalizeApplicationId(value) {
+  const text = String(value || '').trim();
+  if (!/^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*)+$/.test(text)) {
+    throw new Error(`invalid Android application id "${text}"`);
+  }
+  return text;
+}
+
+function normalizeVersionCode(value) {
+  const parsed = Number.parseInt(String(value ?? '1'), 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error('versionCode must be a positive integer');
+  }
+  return parsed;
+}
+
+function normalizeVersionName(value) {
+  const text = String(value ?? '0.1.0').trim();
+  return text || '0.1.0';
+}
+
+function renderTemplate(source, values) {
+  let output = String(source);
+  for (const [key, value] of Object.entries(values)) {
+    output = output.replaceAll(`{{${key}}}`, String(value));
+  }
+  return output;
+}
+
+function resolveRequiredPath(value, label) {
+  if (!value) {
+    throw new Error(`${label} is required`);
+  }
+  const resolved = resolve(value);
+  if (!existsSync(resolved)) {
+    throw new Error(`${label} is missing: ${resolved}`);
+  }
+  return resolved;
+}
+
+function normalizeOptionalPath(value) {
+  if (!value) return null;
+  const resolved = resolve(String(value));
+  return existsSync(resolved) ? resolved : null;
+}
+
+function normalizeAndroidBuildTargets(value) {
+  const targets = Array.isArray(value) && value.length > 0 ? value : ['release', 'debug'];
+  const set = new Set(targets.map((entry) => String(entry || '').trim().toLowerCase()));
+  return {
+    release: set.has('release'),
+    debug: set.has('debug'),
+  };
+}
+
+function resolveNativeHostLibraryContract({ projectRoot, nativeHostLibraryPath, distRoot }) {
+  if (nativeHostLibraryPath) {
+    const explicitPath = resolve(nativeHostLibraryPath);
+    if (existsSync(explicitPath)) {
+      return {
+        exists: true,
+        sourceKind: 'explicit_input',
+        reasonCode: 'android_native_host_library_explicit',
+        sourcePath: explicitPath,
+      };
+    }
+
+    return {
+      exists: false,
+      sourceKind: 'explicit_missing',
+      reasonCode: 'android_native_host_library_missing',
+      sourcePath: explicitPath,
+    };
+  }
+
+  const normalizedDistRoot = resolve(distRoot || DIST_ROOT);
+  const distLibraryPath = join(
+    normalizedDistRoot,
+    ANDROID_ABI_FLOOR[0],
+    ANDROID_NATIVE_LIBRARY_NAME,
+  );
+  if (existsSync(distLibraryPath)) {
+    return {
+      exists: true,
+      sourceKind: 'platform_dist',
+      reasonCode: 'android_native_host_library_dist',
+      sourcePath: distLibraryPath,
+    };
+  }
+
+  return {
+    exists: false,
+    sourceKind: 'missing',
+    reasonCode: 'android_native_host_library_missing',
+    sourcePath: distLibraryPath,
+  };
+}
+
+function executeAndroidGradleTask({
+  outRoot,
+  gradle,
+  env,
+  spawnSyncImpl,
+  taskName,
+}) {
+  const result = spawnSyncImpl(gradle.executablePath, ['-p', outRoot, taskName], {
+    cwd: outRoot,
+    encoding: 'utf8',
+    env,
+  });
+  if (result?.error) {
+    throw new Error(`failed to launch Android Gradle task ${taskName}: ${result.error.message}`);
+  }
+  if (!result || result.status !== 0) {
+    const detail = [result?.stdout, result?.stderr].filter(Boolean).join('\n').trim();
+    throw new Error(
+      detail.length > 0
+        ? `Android Gradle task ${taskName} failed: ${detail}`
+        : `Android Gradle task ${taskName} failed with status ${result?.status ?? 'unknown'}`,
+    );
+  }
+}
+
+function copyBuildOutput(sourcePath, targetPath, label) {
+  const resolvedSource = resolveRequiredPath(sourcePath, label);
+  mkdirSync(dirname(targetPath), { recursive: true });
+  copyFileSync(resolvedSource, targetPath);
+}
+
+function writeAndroidLocalProperties(outRoot, sdkRoot) {
+  const localPropertiesPath = join(outRoot, 'local.properties');
+  const lines = [];
+  if (sdkRoot) {
+    lines.push(`sdk.dir=${escapeAndroidLocalPropertiesValue(sdkRoot)}`);
+  }
+  writeFileSync(localPropertiesPath, `${lines.join('\n')}\n`, 'utf8');
+  return localPropertiesPath;
+}
+
+function escapeAndroidLocalPropertiesValue(value) {
+  return String(value || '').replace(/\\/g, '\\\\').replace(/:/g, '\\:');
+}
+
+function toPosix(input) {
+  return String(input || '').replace(/\\/g, '/');
+}
+
+function relativeToRootOrAbsolute(root, targetPath) {
+  const rel = relative(root, targetPath).replace(/\\/g, '/');
+  if (!rel || (!rel.startsWith('../') && rel !== '..')) {
+    return rel || '.';
+  }
+  return targetPath;
+}
+
+function writeCanonicalJsonFile(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+export function readAndroidBuildManifest(path) {
+  return JSON.parse(readFileSync(resolveRequiredPath(path, 'manifestPath'), 'utf8'));
+}