@auraindustry/aurajs 0.1.1 → 0.1.5

package/src/mobile/android/host-artifact.mjs

@@ -0,0 +1,280 @@
+import { spawnSync } from 'node:child_process';
+import { copyFileSync, existsSync, mkdirSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const ANDROID_HOST_ARTIFACT_ABI = 'arm64-v8a';
+export const ANDROID_HOST_ARTIFACT_TARGET_TRIPLE = 'aarch64-linux-android';
+export const ANDROID_HOST_LIBRARY_NAME = 'libaurajs_host.so';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_DIST_ROOT = resolve(here, '../../../../platform/dist/android');
+const DEFAULT_RUST_HOST_ROOT = resolve(here, '../../../../rust-host');
+
+export function produceAndroidHostArtifact(options = {}) {
+  const env = options.env && typeof options.env === 'object' ? options.env : process.env;
+  const spawnSyncImpl = options.spawnSyncImpl || spawnSync;
+  const abi = String(options.abi || ANDROID_HOST_ARTIFACT_ABI);
+  const distRoot = resolve(options.distRoot || DEFAULT_DIST_ROOT);
+  const distArtifactPath = join(distRoot, abi, ANDROID_HOST_LIBRARY_NAME);
+  const explicitSourcePath = options.sourceLibraryPath ? resolve(options.sourceLibraryPath) : null;
+
+  if (existsSync(distArtifactPath)) {
+    return buildSuccess({
+      reasonCode: 'android_host_artifact_existing_dist',
+      sourceKind: 'existing_dist',
+      abi,
+      distRoot,
+      distArtifactPath,
+      sourceLibraryPath: distArtifactPath,
+    });
+  }
+
+  if (explicitSourcePath) {
+    if (!existsSync(explicitSourcePath)) {
+      return buildFailure({
+        reasonCode: 'android_host_artifact_explicit_missing',
+        sourceKind: 'explicit_missing',
+        abi,
+        distRoot,
+        distArtifactPath,
+        sourceLibraryPath: explicitSourcePath,
+        detail: `explicit Android host library input is missing: ${explicitSourcePath}`,
+      });
+    }
+
+    stageHostArtifact(explicitSourcePath, distArtifactPath);
+    return buildSuccess({
+      reasonCode: 'android_host_artifact_explicit_copied',
+      sourceKind: 'explicit_input',
+      abi,
+      distRoot,
+      distArtifactPath,
+      sourceLibraryPath: explicitSourcePath,
+    });
+  }
+
+  const rustHostRoot = resolve(options.rustHostRoot || DEFAULT_RUST_HOST_ROOT);
+  const cargoManifestPath = join(rustHostRoot, 'Cargo.toml');
+  if (!existsSync(cargoManifestPath)) {
+    return buildFailure({
+      reasonCode: 'android_rust_host_crate_missing',
+      sourceKind: 'missing_prereq',
+      abi,
+      distRoot,
+      distArtifactPath,
+      rustHostRoot,
+      cargoManifestPath,
+      detail: `AuraJS Rust host crate is missing: ${cargoManifestPath}`,
+    });
+  }
+
+  const ndkRoot = normalizeExistingPath(env.ANDROID_NDK_ROOT || env.ANDROID_NDK_HOME || null);
+  if (!ndkRoot) {
+    return buildFailure({
+      reasonCode: 'android_ndk_missing',
+      sourceKind: 'missing_prereq',
+      abi,
+      distRoot,
+      distArtifactPath,
+      rustHostRoot,
+      cargoManifestPath,
+      detail: 'ANDROID_NDK_ROOT or ANDROID_NDK_HOME must point at a valid Android NDK install.',
+    });
+  }
+
+  const cargoExecutable = normalizeCommand(options.cargoExecutable || env.CARGO || 'cargo');
+  const cargoProbe = probeCommand({
+    spawnSyncImpl,
+    executable: cargoExecutable,
+    args: ['--version'],
+    cwd: rustHostRoot,
+    env,
+  });
+  if (!cargoProbe.ok) {
+    return buildFailure({
+      reasonCode: 'android_rust_cargo_missing',
+      sourceKind: 'missing_prereq',
+      abi,
+      distRoot,
+      distArtifactPath,
+      rustHostRoot,
+      cargoManifestPath,
+      cargoExecutable,
+      detail: cargoProbe.detail || `failed to run ${cargoExecutable} --version`,
+    });
+  }
+
+  const cargoNdkProbe = probeCommand({
+    spawnSyncImpl,
+    executable: cargoExecutable,
+    args: ['ndk', '--version'],
+    cwd: rustHostRoot,
+    env: {
+      ...env,
+      ANDROID_NDK_ROOT: ndkRoot,
+      ANDROID_NDK_HOME: ndkRoot,
+    },
+  });
+  if (!cargoNdkProbe.ok) {
+    return buildFailure({
+      reasonCode: 'android_cargo_ndk_missing',
+      sourceKind: 'missing_prereq',
+      abi,
+      distRoot,
+      distArtifactPath,
+      rustHostRoot,
+      cargoManifestPath,
+      cargoExecutable,
+      ndkRoot,
+      detail: cargoNdkProbe.detail || `failed to run ${cargoExecutable} ndk --version`,
+    });
+  }
+
+  const buildArgs = [
+    'ndk',
+    '-t',
+    abi,
+    '-o',
+    distRoot,
+    'build',
+    '--manifest-path',
+    cargoManifestPath,
+    '--release',
+    '--lib',
+  ];
+  const buildEnv = {
+    ...env,
+    ANDROID_NDK_ROOT: ndkRoot,
+    ANDROID_NDK_HOME: ndkRoot,
+  };
+  const buildResult = spawnSyncImpl(cargoExecutable, buildArgs, {
+    cwd: rustHostRoot,
+    encoding: 'utf8',
+    env: buildEnv,
+  });
+  if (buildResult?.error) {
+    return buildFailure({
+      reasonCode: 'android_host_artifact_build_failed',
+      sourceKind: 'cargo_ndk',
+      abi,
+      distRoot,
+      distArtifactPath,
+      rustHostRoot,
+      cargoManifestPath,
+      cargoExecutable,
+      ndkRoot,
+      command: [cargoExecutable, ...buildArgs],
+      detail: `failed to launch Android host build: ${buildResult.error.message}`,
+    });
+  }
+  if (!buildResult || buildResult.status !== 0) {
+    return buildFailure({
+      reasonCode: 'android_host_artifact_build_failed',
+      sourceKind: 'cargo_ndk',
+      abi,
+      distRoot,
+      distArtifactPath,
+      rustHostRoot,
+      cargoManifestPath,
+      cargoExecutable,
+      ndkRoot,
+      command: [cargoExecutable, ...buildArgs],
+      detail: formatProcessFailure(buildResult, `${cargoExecutable} ${buildArgs.join(' ')}`),
+    });
+  }
+
+  if (!existsSync(distArtifactPath)) {
+    return buildFailure({
+      reasonCode: 'android_host_artifact_output_missing',
+      sourceKind: 'cargo_ndk',
+      abi,
+      distRoot,
+      distArtifactPath,
+      rustHostRoot,
+      cargoManifestPath,
+      cargoExecutable,
+      ndkRoot,
+      command: [cargoExecutable, ...buildArgs],
+      detail: `Android host build reported success but did not produce ${distArtifactPath}`,
+    });
+  }
+
+  return buildSuccess({
+    reasonCode: 'android_host_artifact_built',
+    sourceKind: 'cargo_ndk',
+    abi,
+    distRoot,
+    distArtifactPath,
+    rustHostRoot,
+    cargoManifestPath,
+    cargoExecutable,
+    ndkRoot,
+    command: [cargoExecutable, ...buildArgs],
+  });
+}
+
+function stageHostArtifact(sourcePath, distArtifactPath) {
+  mkdirSync(dirname(distArtifactPath), { recursive: true });
+  if (resolve(sourcePath) !== resolve(distArtifactPath)) {
+    copyFileSync(sourcePath, distArtifactPath);
+  }
+}
+
+function buildSuccess(result) {
+  return {
+    ok: true,
+    ...result,
+    artifactSizeBytes: statSync(result.distArtifactPath).size,
+  };
+}
+
+function buildFailure(result) {
+  return {
+    ok: false,
+    ...result,
+  };
+}
+
+function normalizeExistingPath(value) {
+  if (!value) return null;
+  const resolved = resolve(String(value));
+  return existsSync(resolved) ? resolved : null;
+}
+
+function normalizeCommand(value) {
+  const text = String(value || '').trim();
+  return text || 'cargo';
+}
+
+function probeCommand({ spawnSyncImpl, executable, args, cwd, env }) {
+  const result = spawnSyncImpl(executable, args, {
+    cwd,
+    encoding: 'utf8',
+    env,
+  });
+  if (result?.error) {
+    return {
+      ok: false,
+      detail: `failed to launch ${executable} ${args.join(' ')}: ${result.error.message}`,
+    };
+  }
+  if (!result || result.status !== 0) {
+    return {
+      ok: false,
+      detail: formatProcessFailure(result, `${executable} ${args.join(' ')}`),
+    };
+  }
+  return { ok: true };
+}
+
+function formatProcessFailure(result, label) {
+  const detail = [result?.stdout, result?.stderr]
+    .filter((value) => typeof value === 'string' && value.trim().length > 0)
+    .map((value) => value.trim())
+    .join('\n');
+  if (detail.length > 0) {
+    return `${label} failed: ${detail}`;
+  }
+  return `${label} failed with status ${result?.status ?? 'unknown'}`;
+}