k3s-deployer 0.1.0

package/src/mobile/index.cjs

@@ -0,0 +1,1093 @@
+const { hashText, shellQuote } = require('../shared/utils.cjs');
+
+const MOBILE_BUILDER_IMAGE = 'ghcr.io/cirruslabs/flutter:stable';
+const MOBILE_ANDROID_SDK_BUILDER_IMAGE = 'ghcr.io/cirruslabs/android-sdk:35';
+const MOBILE_ANDROID_SDK_ARM64_BUILDER_IMAGE = 'eclipse-temurin:17-jdk-jammy';
+const DEFAULT_MOBILE_BUILD_TIMEOUT_MS = 5 * 60 * 60 * 1000;
+const MOBILE_BUILD_CACHE_FILE = '.k3s-deployer/mobile-build.json';
+const FLUTTER_DOCKER_TARGET_PLATFORM = 'android-arm64';
+const FLUTTER_DOCKER_BUILD_SCRIPT =
+  `echo '[mobile] Preparing Flutter builder environment (5%)'
+format_duration() {
+  total="$1"
+  hours=$((total / 3600))
+  minutes=$(((total % 3600) / 60))
+  seconds=$((total % 60))
+  if [ "$hours" -gt 0 ]; then
+    printf '%dh %02dm' "$hours" "$minutes"
+  elif [ "$minutes" -gt 0 ]; then
+    printf '%dm %02ds' "$minutes" "$seconds"
+  else
+    printf '%ds' "$seconds"
+  fi
+}
+run_with_heartbeat() {
+  label="$1"
+  start_percent="$2"
+  end_percent="$3"
+  expected_seconds="$4"
+  shift 4
+  start_ts=$(date +%s)
+  (
+    while true; do
+      sleep 30
+      now_ts=$(date +%s)
+      elapsed=$((now_ts - start_ts))
+      bounded_elapsed=$elapsed
+      if [ "$bounded_elapsed" -gt "$expected_seconds" ]; then
+        bounded_elapsed=$expected_seconds
+      fi
+      progress=$((start_percent + (bounded_elapsed * (end_percent - start_percent)) / expected_seconds))
+      if [ "$progress" -ge "$end_percent" ]; then
+        progress=$((end_percent - 1))
+      fi
+      echo "[mobile] \${label} is still running (estimated \${progress}%, elapsed \$(format_duration "$elapsed"))"
+    done
+  ) &
+  heartbeat_pid=$!
+  "$@"
+  status=$?
+  kill "$heartbeat_pid" >/dev/null 2>&1 || true
+  wait "$heartbeat_pid" 2>/dev/null || true
+  return $status
+}
+mkdir -p "$GRADLE_USER_HOME" && cat > "$GRADLE_USER_HOME/gradle.properties" <<'EOF'
+org.gradle.daemon=false
+org.gradle.workers.max=2
+kotlin.compiler.execution.strategy=out-of-process
+org.gradle.jvmargs=-Xmx2g -Djdk.tls.client.protocols=TLSv1.2 -Dhttps.protocols=TLSv1.2
+EOF
+export JAVA_TOOL_OPTIONS="-Djdk.tls.client.protocols=TLSv1.2 -Dhttps.protocols=TLSv1.2"
+export HOME=/workspace/.k3s-deployer/home
+export XDG_CONFIG_HOME=$HOME/.config
+export XDG_CACHE_HOME=$HOME/.cache
+export FLUTTER_SKIP_UPDATE_CHECK=true
+export PUB_ENVIRONMENT=bot.cli
+mkdir -p "$HOME" "$XDG_CONFIG_HOME" "$XDG_CACHE_HOME"
+if [ ! -e /lib64/ld-linux-x86-64.so.2 ] && [ -e /lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 ]; then
+  mkdir -p /lib64
+  ln -sf /lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 /lib64/ld-linux-x86-64.so.2
+fi
+export CI=true
+echo '[mobile] Pre-caching Android artifacts (20%)'
+run_with_heartbeat 'flutter precache' 20 30 1200 flutter precache --android --no-universal
+echo '[mobile] Running flutter pub get (30%)'
+run_with_heartbeat 'flutter pub get' 30 55 1200 flutter pub get
+echo '[mobile] Building release APK for android-arm64 (55%)'
+run_with_heartbeat 'Building release APK for android-arm64' 55 95 5400 flutter build apk --release --no-pub --target-platform ${FLUTTER_DOCKER_TARGET_PLATFORM}`;
+const FLUTTER_ANDROID_SDK_BUILD_SCRIPT =
+  `echo '[mobile] Preparing Android SDK builder environment (5%)'
+format_duration() {
+  total="$1"
+  hours=$((total / 3600))
+  minutes=$(((total % 3600) / 60))
+  seconds=$((total % 60))
+  if [ "$hours" -gt 0 ]; then
+    printf '%dh %02dm' "$hours" "$minutes"
+  elif [ "$minutes" -gt 0 ]; then
+    printf '%dm %02ds' "$minutes" "$seconds"
+  else
+    printf '%ds' "$seconds"
+  fi
+}
+run_with_heartbeat() {
+  label="$1"
+  start_percent="$2"
+  end_percent="$3"
+  expected_seconds="$4"
+  shift 4
+  start_ts=$(date +%s)
+  (
+    while true; do
+      sleep 30
+      now_ts=$(date +%s)
+      elapsed=$((now_ts - start_ts))
+      bounded_elapsed=$elapsed
+      if [ "$bounded_elapsed" -gt "$expected_seconds" ]; then
+        bounded_elapsed=$expected_seconds
+      fi
+      progress=$((start_percent + (bounded_elapsed * (end_percent - start_percent)) / expected_seconds))
+      if [ "$progress" -ge "$end_percent" ]; then
+        progress=$((end_percent - 1))
+      fi
+      echo "[mobile] \${label} is still running (estimated \${progress}%, elapsed \$(format_duration "$elapsed"))"
+    done
+  ) &
+  heartbeat_pid=$!
+  "$@"
+  status=$?
+  kill "$heartbeat_pid" >/dev/null 2>&1 || true
+  wait "$heartbeat_pid" 2>/dev/null || true
+  return $status
+}
+resolve_sdkmanager_bin() {
+  if command -v sdkmanager >/dev/null 2>&1; then
+    command -v sdkmanager
+    return 0
+  fi
+  for candidate in \
+    /opt/android-sdk-linux/cmdline-tools/latest/bin/sdkmanager \
+    /opt/android-sdk-linux/cmdline-tools/bin/sdkmanager \
+    /opt/android-sdk-linux/tools/bin/sdkmanager \
+    /opt/android-sdk-linux/latest/bin/sdkmanager
+  do
+    if [ -x "$candidate" ]; then
+      printf '%s\n' "$candidate"
+      return 0
+    fi
+  done
+  find /opt/android-sdk-linux -path '*/bin/sdkmanager' -type f 2>/dev/null | head -n 1
+}
+extract_ndk_version_from_file() {
+  file_path="$1"
+  if [ ! -f "$file_path" ]; then
+    return 0
+  fi
+  sed -nE "s/.*ndkVersion[[:space:]]*(=)?[[:space:]]*['\\\"]?([0-9]+(\\.[0-9]+)+)['\\\"]?.*/\\2/p" "$file_path" | head -n 1
+}
+uses_flutter_ndk_version() {
+  file_path="$1"
+  [ -f "$file_path" ] || return 1
+  grep -Eq 'ndkVersion[[:space:]]*(=)?[[:space:]]*flutter\\.ndkVersion' "$file_path"
+}
+resolve_flutter_ndk_version() {
+  for search_root in /opt/flutter/packages/flutter_tools/gradle /opt/flutter/packages/flutter_tools; do
+    if [ ! -d "$search_root" ]; then
+      continue
+    fi
+    version="$(grep -RhoE 'ndkVersion[^0-9]*[0-9]+(\\.[0-9]+)+' "$search_root" 2>/dev/null | grep -oE '[0-9]+(\\.[0-9]+)+' | head -n 1)"
+    if [ -n "$version" ]; then
+      printf '%s\n' "$version"
+      return 0
+    fi
+  done
+}
+resolve_required_ndk_version() {
+  flutter_managed_ndk=false
+  for gradle_file in /workspace/android/app/build.gradle.kts /workspace/android/app/build.gradle /workspace/app/build.gradle.kts /workspace/app/build.gradle; do
+    version="$(extract_ndk_version_from_file "$gradle_file")"
+    if [ -n "$version" ]; then
+      printf '%s\n' "$version"
+      return 0
+    fi
+    if uses_flutter_ndk_version "$gradle_file"; then
+      flutter_managed_ndk=true
+    fi
+  done
+  if [ "$flutter_managed_ndk" = true ]; then
+    resolve_flutter_ndk_version
+  fi
+}
+mkdir -p "$GRADLE_USER_HOME" && cat > "$GRADLE_USER_HOME/gradle.properties" <<'EOF'
+org.gradle.daemon=false
+org.gradle.workers.max=2
+kotlin.compiler.execution.strategy=out-of-process
+org.gradle.jvmargs=-Xmx2g -Djdk.tls.client.protocols=TLSv1.2 -Dhttps.protocols=TLSv1.2
+android.builder.sdkDownload=false
+EOF
+export JAVA_TOOL_OPTIONS="-Djdk.tls.client.protocols=TLSv1.2 -Dhttps.protocols=TLSv1.2"
+export PATH=/opt/flutter/bin:$PATH
+export FLUTTER_ROOT=/opt/flutter
+export ANDROID_HOME=/opt/android-sdk-linux
+export ANDROID_SDK_ROOT=/opt/android-sdk-linux
+export HOME=/workspace/.k3s-deployer/home
+export XDG_CONFIG_HOME=$HOME/.config
+export XDG_CACHE_HOME=$HOME/.cache
+export FLUTTER_SKIP_UPDATE_CHECK=true
+export PUB_ENVIRONMENT=bot.cli
+export CI=true
+mkdir -p "$HOME" "$XDG_CONFIG_HOME" "$XDG_CACHE_HOME"
+if ! command -v git >/dev/null 2>&1; then
+  echo '[mobile] Installing git and basic tooling into Android SDK builder'
+  _need_apt_update=true
+  _newest_list=$(find /var/lib/apt/lists -maxdepth 1 -name '*.InRelease' -printf '%T@\n' 2>/dev/null | sort -n | tail -1)
+  if [ -n "$_newest_list" ] && [ "$(( $(date +%s) - \${_newest_list%.*} ))" -lt 86400 ]; then
+    _need_apt_update=false
+  fi
+  if [ "$_need_apt_update" = true ]; then
+    apt-get update
+  fi
+  apt-get install -y --no-install-recommends git ca-certificates curl unzip xz-utils zip
+fi
+if [ ! -f /opt/android-sdk-linux/cmdline-tools/latest/bin/sdkmanager ]; then
+  echo '[mobile] Downloading Android SDK command-line tools (5%)'
+  mkdir -p /opt/android-sdk-linux/cmdline-tools/latest
+  curl -fsSL https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip -o /tmp/cmdline-tools.zip
+  unzip -q /tmp/cmdline-tools.zip -d /tmp/cmdline-tools
+  mv /tmp/cmdline-tools/cmdline-tools/* /opt/android-sdk-linux/cmdline-tools/latest/
+  rm -rf /tmp/cmdline-tools.zip /tmp/cmdline-tools
+fi
+if [ -d /opt/flutter/.git ]; then
+  echo '[mobile] Reusing cached Flutter SDK (10%)'
+elif [ ! -x /opt/flutter/bin/flutter ]; then
+  echo '[mobile] Cloning Flutter SDK into cache volume (10%)'
+  find /opt/flutter -mindepth 1 -maxdepth 1 -exec rm -rf {} +
+  git clone --depth 1 -b stable https://github.com/flutter/flutter.git /opt/flutter
+fi
+echo '[mobile] Flutter SDK ready (20%)'
+flutter config --no-analytics >/dev/null 2>&1
+if [ ! -e /lib64/ld-linux-x86-64.so.2 ]; then
+  echo '[mobile] Installing x86_64 glibc so NDK toolchain runs via QEMU binfmt'
+  dpkg --add-architecture amd64 2>/dev/null || true
+  sed -i 's|^deb http|deb [arch=arm64] http|g' /etc/apt/sources.list 2>/dev/null || true
+  for _sl in /etc/apt/sources.list.d/*.list; do
+    [ -f "$_sl" ] && sed -i 's|^deb http|deb [arch=arm64] http|g' "$_sl" 2>/dev/null || true
+  done
+  cat > /etc/apt/sources.list.d/ubuntu-amd64.list << 'AMDEOF'
+deb [arch=amd64] http://archive.ubuntu.com/ubuntu jammy main restricted universe
+deb [arch=amd64] http://archive.ubuntu.com/ubuntu jammy-updates main restricted universe
+deb [arch=amd64] http://security.ubuntu.com/ubuntu jammy-security main restricted universe
+AMDEOF
+  apt-get update -qq
+  apt-get install -y --no-install-recommends libc6:amd64 libstdc++6:amd64 zlib1g:amd64 libncurses6:amd64 libtinfo6:amd64
+  if [ -e /lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 ]; then
+    mkdir -p /lib64
+    ln -sf /lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 /lib64/ld-linux-x86-64.so.2
+    echo '[mobile] x86_64 dynamic linker ready at /lib64/'
+  fi
+fi
+_cmake_sdk=/opt/android-sdk-linux/cmake/3.22.1/bin/cmake
+_ninja_sdk=/opt/android-sdk-linux/cmake/3.22.1/bin/ninja
+if [ -f "$_cmake_sdk" ] && ! "$_cmake_sdk" --version >/dev/null 2>&1; then
+  echo '[mobile] SDK cmake cannot execute natively; installing ARM64 cmake/ninja'
+  apt-get install -y --no-install-recommends cmake ninja-build
+  _native_cmake=$(command -v cmake 2>/dev/null || true)
+  _native_ninja=$(command -v ninja 2>/dev/null || true)
+  if [ -n "$_native_cmake" ]; then
+    cp -f "$_native_cmake" "$_cmake_sdk"
+    echo "[mobile] Replaced SDK cmake with ARM64 binary"
+  fi
+  if [ -n "$_native_ninja" ]; then
+    cp -f "$_native_ninja" "$_ninja_sdk"
+    echo "[mobile] Replaced SDK ninja with ARM64 binary"
+  fi
+fi
+sdkmanager_bin="$(resolve_sdkmanager_bin)"
+if [ -n "$sdkmanager_bin" ]; then
+  echo '[mobile] Accepting Android SDK licenses (22%)'
+  yes | "$sdkmanager_bin" --sdk_root="$ANDROID_SDK_ROOT" --licenses >/dev/null 2>&1 || true
+  required_ndk_version="$(resolve_required_ndk_version)"
+  if [ -n "$required_ndk_version" ]; then
+    ndk_dir="$ANDROID_SDK_ROOT/ndk/$required_ndk_version"
+    if [ ! -f "$ndk_dir/source.properties" ]; then
+      ndk_major="$(echo "$required_ndk_version" | cut -d. -f1)"
+      ndk_minor="$(echo "$required_ndk_version" | cut -d. -f2)"
+      case "$ndk_minor" in
+        0) ndk_release="r\${ndk_major}" ;;
+        1) ndk_release="r\${ndk_major}b" ;;
+        2) ndk_release="r\${ndk_major}c" ;;
+        3) ndk_release="r\${ndk_major}d" ;;
+        4) ndk_release="r\${ndk_major}e" ;;
+        5) ndk_release="r\${ndk_major}f" ;;
+        *) ndk_release="r\${ndk_major}" ;;
+      esac
+      ndk_url="https://dl.google.com/android/repository/android-ndk-\${ndk_release}-linux.zip"
+      ndk_zip="$ANDROID_SDK_ROOT/ndk-downloads/ndk-$required_ndk_version.zip"
+      echo "[mobile] Downloading Android NDK \$required_ndk_version via curl (resumable) (24%)"
+      download_ndk() {
+        curl -C - -fL --retry 3 --retry-delay 30 --connect-timeout 120 -o "$ndk_zip" "$ndk_url"
+      }
+      run_with_heartbeat 'Downloading Android NDK' 24 25 28800 download_ndk || true
+      if [ -f "$ndk_zip" ]; then
+        echo "[mobile] Extracting NDK \$required_ndk_version"
+        ndk_tmp="/tmp/ndk-extract-$$"
+        mkdir -p "$ndk_tmp"
+        if unzip -q "$ndk_zip" -d "$ndk_tmp" 2>/dev/null; then
+          ndk_src="$(find "$ndk_tmp" -maxdepth 1 -name 'android-ndk-*' -type d | head -n 1)"
+          if [ -n "$ndk_src" ] && [ -f "$ndk_src/source.properties" ]; then
+            mkdir -p "$ndk_dir"
+            cp -a "$ndk_src/." "$ndk_dir/"
+            rm -f "$ndk_zip"
+            echo "[mobile] NDK \$required_ndk_version installed"
+          else
+            echo "[mobile] NDK extraction incomplete, will retry next build" >&2
+            rm -rf "$ndk_dir" "$ndk_zip"
+          fi
+        else
+          echo "[mobile] NDK zip corrupt, deleting for fresh download next build" >&2
+          rm -f "$ndk_zip"
+          rm -rf "$ndk_dir"
+        fi
+        rm -rf "$ndk_tmp"
+      fi
+    fi
+    if [ ! -f "$ndk_dir/source.properties" ]; then
+      echo "[mobile] ERROR: Android NDK \$required_ndk_version could not be installed" >&2
+      exit 1
+    fi
+  fi
+else
+  echo '[mobile] Android SDK manager not found, continuing without explicit license acceptance'
+fi
+if [ -n "$sdkmanager_bin" ]; then
+  _sdk_pkgs=""
+  for _plat in android-34 android-35; do
+    [ ! -f "$ANDROID_SDK_ROOT/platforms/$_plat/android.jar" ] && _sdk_pkgs="$_sdk_pkgs platforms;$_plat"
+  done
+  for _bt in 34.0.0 35.0.0; do
+    [ ! -f "$ANDROID_SDK_ROOT/build-tools/$_bt/aapt" ] && _sdk_pkgs="$_sdk_pkgs build-tools;$_bt"
+  done
+  [ ! -f "$ANDROID_SDK_ROOT/cmake/3.22.1/bin/cmake" ] && _sdk_pkgs="$_sdk_pkgs cmake;3.22.1"
+  _sdk_pkgs="\${_sdk_pkgs# }"
+  if [ -n "$_sdk_pkgs" ]; then
+    echo "[mobile] Installing Android SDK packages: $_sdk_pkgs (23%)"
+    _do_install_sdk() { yes | "$sdkmanager_bin" --sdk_root="$ANDROID_SDK_ROOT" $_sdk_pkgs; }
+    run_with_heartbeat 'Installing Android SDK packages' 23 25 1800 _do_install_sdk || echo '[mobile] WARNING: SDK install failed' >&2
+  fi
+fi
+echo '[mobile] Pre-caching Android artifacts (25%)'
+run_with_heartbeat 'flutter precache' 25 30 1200 flutter precache --android --no-universal
+echo '[mobile] Running flutter pub get (30%)'
+run_with_heartbeat 'flutter pub get' 30 55 1200 flutter pub get
+echo '[mobile] Building release APK for android-arm64 (55%)'
+run_with_heartbeat 'Building release APK for android-arm64' 55 95 5400 flutter build apk --release --no-pub --target-platform ${FLUTTER_DOCKER_TARGET_PLATFORM}`;
+
+async function readTextFile(runner, filePath, options = {}) {
+  const result = await runner.run(`cat ${shellQuote(filePath)}`, {
+    cwd: options.cwd,
+    dryRun: options.dryRun,
+    allowFailure: true,
+    timeoutMs: options.timeoutMs,
+  });
+  if (result.code !== 0) {
+    return null;
+  }
+  return result.stdout;
+}
+
+async function readJsonFile(runner, filePath, options = {}) {
+  const text = await readTextFile(runner, filePath, options);
+  if (!text) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+async function findFirstFile(runner, searchRoot, pattern, options = {}) {
+  const result = await runner.run(
+    `find ${shellQuote(searchRoot)} -type f -name ${shellQuote(pattern)} | head -n 1`,
+    {
+      cwd: options.cwd,
+      dryRun: options.dryRun,
+      allowFailure: true,
+      timeoutMs: options.timeoutMs,
+    },
+  );
+  const filePath = String(result.stdout || '').trim();
+  return filePath || null;
+}
+
+async function findLatestFlutterArtifact(runner, unitPath, options = {}) {
+  const result = await runner.run(
+    `find ${shellQuote(`${unitPath}/build/app/outputs/flutter-apk`)} -maxdepth 1 -type f -name '*.apk' | sort | tail -n 1`,
+    {
+      cwd: options.cwd,
+      dryRun: options.dryRun,
+      allowFailure: true,
+      timeoutMs: options.timeoutMs,
+    },
+  );
+  const filePath = String(result.stdout || '').trim();
+  return filePath || null;
+}
+
+async function resolveFlutterArtifactPath(runner, unitPath, options = {}) {
+  return (
+    (await findLatestFlutterArtifact(runner, unitPath, options)) ||
+    `${unitPath}/build/app/outputs/flutter-apk/app-release.apk`
+  );
+}
+
+function normalizeArchitecture(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (normalized === 'aarch64' || normalized === 'arm64') {
+    return 'arm64';
+  }
+  if (normalized === 'x86_64' || normalized === 'amd64') {
+    return 'amd64';
+  }
+  return normalized || 'unknown';
+}
+
+async function detectHostArchitecture(runner, unitPath, options = {}) {
+  const result = await runner.run('uname -m', {
+    cwd: unitPath,
+    dryRun: options.dryRun,
+    allowFailure: true,
+    timeoutMs: options.timeoutMs,
+  });
+  return normalizeArchitecture(result.stdout);
+}
+
+async function resolveGitRevision(runner, workspacePath, options = {}) {
+  const result = await runner.run('git rev-parse HEAD', {
+    cwd: workspacePath,
+    dryRun: options.dryRun,
+    allowFailure: true,
+    timeoutMs: options.timeoutMs,
+  });
+  const revision = String(result.stdout || '').trim();
+  return revision || null;
+}
+
+function createFirebaseOptionsFile(androidConfig) {
+  const projectInfo = androidConfig.project_info || {};
+  const client = Array.isArray(androidConfig.client) ? androidConfig.client[0] || {} : {};
+  const clientInfo = client.client_info || {};
+  const apiKey = Array.isArray(client.api_key) ? client.api_key[0] || {} : {};
+
+  const values = {
+    apiKey: apiKey.current_key || '',
+    appId: clientInfo.mobilesdk_app_id || '',
+    messagingSenderId: projectInfo.project_number || '',
+    projectId: projectInfo.project_id || '',
+    storageBucket: projectInfo.storage_bucket || '',
+  };
+
+  return `import 'package:firebase_core/firebase_core.dart' show FirebaseOptions;
+import 'package:flutter/foundation.dart' show TargetPlatform, defaultTargetPlatform, kIsWeb;
+
+class DefaultFirebaseOptions {
+  static FirebaseOptions get currentPlatform {
+    if (kIsWeb) {
+      throw UnsupportedError('DefaultFirebaseOptions are not configured for web.');
+    }
+    switch (defaultTargetPlatform) {
+      case TargetPlatform.android:
+        return android;
+      case TargetPlatform.iOS:
+        throw UnsupportedError('DefaultFirebaseOptions are not configured for ios.');
+      case TargetPlatform.macOS:
+        throw UnsupportedError('DefaultFirebaseOptions are not configured for macos.');
+      case TargetPlatform.windows:
+        throw UnsupportedError('DefaultFirebaseOptions are not configured for windows.');
+      case TargetPlatform.linux:
+        throw UnsupportedError('DefaultFirebaseOptions are not configured for linux.');
+      default:
+        throw UnsupportedError('DefaultFirebaseOptions are not supported for this platform.');
+    }
+  }
+
+  static const FirebaseOptions android = FirebaseOptions(
+    apiKey: ${JSON.stringify(values.apiKey)},
+    appId: ${JSON.stringify(values.appId)},
+    messagingSenderId: ${JSON.stringify(values.messagingSenderId)},
+    projectId: ${JSON.stringify(values.projectId)},
+    storageBucket: ${JSON.stringify(values.storageBucket)},
+  );
+}
+`;
+}
+
+async function ensureFirebaseOptions(runner, unitPath, options = {}) {
+  const firebaseOptionsPath = `${unitPath}/lib/firebase_options.dart`;
+  const mainPath = `${unitPath}/lib/main.dart`;
+  const hasFirebaseOptions = await runner.exists(firebaseOptionsPath);
+  if (hasFirebaseOptions) {
+    return false;
+  }
+
+  const mainSource = await readTextFile(runner, mainPath, options);
+  if (!mainSource || !mainSource.includes('firebase_options.dart')) {
+    return false;
+  }
+
+  const googleServicesPath = await findFirstFile(
+    runner,
+    `${unitPath}/android`,
+    'google-services.json',
+    options,
+  );
+
+  if (!googleServicesPath) {
+    throw new Error(
+      'Flutter app imports lib/firebase_options.dart but no google-services.json was found to generate it',
+    );
+  }
+
+  const googleServicesText = await readTextFile(
+    runner,
+    googleServicesPath,
+    options,
+  );
+
+  if (!googleServicesText) {
+    throw new Error(
+      `Could not read ${googleServicesPath} to generate lib/firebase_options.dart`,
+    );
+  }
+
+  const androidConfig = JSON.parse(googleServicesText);
+  const firebaseOptionsContent = createFirebaseOptionsFile(androidConfig);
+  await runner.writeFile(firebaseOptionsPath, firebaseOptionsContent);
+  if (options.onLog) {
+    await options.onLog(
+      `Generated lib/firebase_options.dart from ${googleServicesPath.replace(`${unitPath}/`, '')}`,
+    );
+  }
+  return true;
+}
+
+async function commandSucceeds(runner, command, options = {}) {
+  try {
+    await runner.run(command, { ...options, allowFailure: false });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function findAndroidApplicationId(runner, unitPath, options = {}) {
+  for (const relativePath of [
+    'android/app/build.gradle.kts',
+    'android/app/build.gradle',
+    'app/build.gradle.kts',
+    'app/build.gradle',
+  ]) {
+    const source = await readTextFile(
+      runner,
+      `${unitPath}/${relativePath}`,
+      options,
+    );
+    if (!source) {
+      continue;
+    }
+    const match = source.match(
+      /applicationId\s*(?:=)?\s*["']([^"']+)["']/,
+    );
+    if (match) {
+      return match[1];
+    }
+  }
+  return null;
+}
+
+async function readMobileBuildCache(runner, workspacePath, options = {}) {
+  return readJsonFile(runner, `${workspacePath}/${MOBILE_BUILD_CACHE_FILE}`, options);
+}
+
+async function writeMobileBuildCache(
+  runner,
+  workspacePath,
+  payload,
+) {
+  await runner.writeFile(
+    `${workspacePath}/${MOBILE_BUILD_CACHE_FILE}`,
+    JSON.stringify(payload, null, 2),
+  );
+}
+
+function isGenSnapshotArtifactError(error) {
+  const message =
+    error instanceof Error ? error.message : String(error || '');
+  return (
+    message.includes('gen_snapshot') ||
+    message.includes('android_aot_release_') ||
+    message.includes('linux-arm64')
+  );
+}
+
+function isExecFormatError(error) {
+  const message =
+    error instanceof Error ? error.message : String(error || '');
+  return message.includes('exec format error');
+}
+
+function isAapt2LoaderError(error) {
+  const message =
+    error instanceof Error ? error.message : String(error || '');
+  return (
+    message.includes('AAPT2') ||
+    message.includes('ld-linux-x86-64.so.2') ||
+    message.includes('qemu-x86_64')
+  );
+}
+
+function isMissingImageManifestError(error) {
+  const message =
+    error instanceof Error ? error.message : String(error || '');
+  return message.includes('no matching manifest for linux/arm64');
+}
+
+async function runFlutterDockerBuild(
+  runner,
+  unitPath,
+  options = {},
+  platform,
+) {
+  const platformFlag = platform ? `--platform ${platform} ` : '';
+  const platformLabel = String(platform || 'native').replace(/[^a-z0-9]+/gi, '-');
+  const containerName = `k3s-mobile-flutter-${hashText(`${unitPath}-${platformLabel}`).slice(0, 12)}`;
+  const gradleHome = `/workspace/.gradle/mobile-flutter-${platformLabel}`;
+  await runner.run(`docker rm -f ${shellQuote(containerName)}`, {
+    cwd: unitPath,
+    dryRun: options.dryRun,
+    allowFailure: true,
+    timeoutMs: options.timeoutMs || DEFAULT_MOBILE_BUILD_TIMEOUT_MS,
+  });
+  try {
+    await runner.run(
+      `docker run ${platformFlag}--name ${shellQuote(containerName)} --rm -v "$PWD":/workspace -w /workspace -e PUB_CACHE=/workspace/.pub-cache -e GRADLE_USER_HOME=${shellQuote(gradleHome)} ${shellQuote(MOBILE_BUILDER_IMAGE)} sh -lc ${shellQuote(FLUTTER_DOCKER_BUILD_SCRIPT)}`,
+      {
+        cwd: unitPath,
+        dryRun: options.dryRun,
+        timeoutMs: options.timeoutMs || DEFAULT_MOBILE_BUILD_TIMEOUT_MS,
+        onStdout: options.onLog,
+        onStderr: options.onLog,
+      },
+    );
+  } finally {
+    await runner.run(`docker rm -f ${shellQuote(containerName)}`, {
+      cwd: unitPath,
+      dryRun: options.dryRun,
+      allowFailure: true,
+      timeoutMs: options.timeoutMs || DEFAULT_MOBILE_BUILD_TIMEOUT_MS,
+    });
+  }
+}
+
+function ndkVersionToRelease(version) {
+  const parts = version.split('.');
+  const major = parseInt(parts[0], 10);
+  const minor = parseInt(parts[1] || '0', 10);
+  if (minor === 0) return `r${major}`;
+  return `r${major}${String.fromCharCode(97 + minor)}`;
+}
+
+async function readNdkVersionFromGradle(runner, unitPath, options = {}) {
+  for (const rel of ['android/app/build.gradle.kts', 'android/app/build.gradle', 'app/build.gradle.kts', 'app/build.gradle']) {
+    const src = await readTextFile(runner, `${unitPath}/${rel}`, options);
+    if (!src) continue;
+    const m = src.match(/ndkVersion\s*(?:=)?\s*["']([0-9]+\.[0-9]+\.[0-9]+)["']/);
+    if (m) return m[1];
+  }
+  return null;
+}
+
+async function ensureNdkOnHost(runner, unitPath, androidSdkCacheDir, flutterSdkCacheDir, options = {}) {
+  const ndkVersion = await readNdkVersionFromGradle(runner, unitPath, options);
+  if (!ndkVersion) {
+    const result = await runner.run(
+      `grep -RhoE 'ndkVersion[^0-9]*[0-9]+\\.[0-9]+\\.[0-9]+' ${shellQuote(`${unitPath}/${flutterSdkCacheDir}/packages/flutter_tools`)} 2>/dev/null | grep -oE '[0-9]+\\.[0-9]+\\.[0-9]+' | head -n 1`,
+      { cwd: unitPath, allowFailure: true },
+    );
+    const fromFlutter = String(result.stdout || '').trim();
+    if (!fromFlutter) return;
+    await ensureNdkOnHost(runner, unitPath, androidSdkCacheDir, flutterSdkCacheDir, { ...options, _resolvedNdkVersion: fromFlutter });
+    return;
+  }
+
+  const resolvedVersion = options._resolvedNdkVersion || ndkVersion;
+  const ndkPropertiesPath = `${unitPath}/${androidSdkCacheDir}/ndk/${resolvedVersion}/source.properties`;
+  const hasNdk = await runner.exists(ndkPropertiesPath);
+  if (hasNdk) return;
+
+  const release = ndkVersionToRelease(resolvedVersion);
+  const ndkUrl = `https://dl.google.com/android/repository/android-ndk-${release}-linux.zip`;
+  const zipPath = `${unitPath}/${androidSdkCacheDir}/ndk-downloads/ndk-${resolvedVersion}.zip`;
+  const ndkDir = `${unitPath}/${androidSdkCacheDir}/ndk/${resolvedVersion}`;
+
+  if (options.onLog) {
+    await options.onLog(`[mobile] Pre-downloading Android NDK ${resolvedVersion} on host (native, no QEMU)`);
+  }
+
+  await runner.run(
+    `curl -C - -fL --retry 3 --retry-delay 30 --connect-timeout 120 -o ${shellQuote(zipPath)} ${shellQuote(ndkUrl)}`,
+    {
+      cwd: unitPath,
+      dryRun: options.dryRun,
+      allowFailure: true,
+      timeoutMs: options.timeoutMs || DEFAULT_MOBILE_BUILD_TIMEOUT_MS,
+      onStdout: options.onLog,
+      onStderr: options.onLog,
+    },
+  );
+
+  await runner.run(
+    `if [ -f ${shellQuote(zipPath)} ]; then` +
+    `  tmp=$(mktemp -d);` +
+    `  if unzip -q ${shellQuote(zipPath)} -d "$tmp" 2>/dev/null; then` +
+    `    src=$(find "$tmp" -maxdepth 1 -name 'android-ndk-*' -type d | head -n 1);` +
+    `    if [ -n "$src" ] && [ -f "$src/source.properties" ]; then` +
+    `      mkdir -p ${shellQuote(ndkDir)} && cp -a "$src/." ${shellQuote(ndkDir)}/ && rm -f ${shellQuote(zipPath)};` +
+    `    else rm -rf ${shellQuote(ndkDir)} ${shellQuote(zipPath)}; fi;` +
+    `  else rm -f ${shellQuote(zipPath)}; fi;` +
+    `  rm -rf "$tmp"; fi`,
+    { cwd: unitPath, dryRun: options.dryRun, allowFailure: true, timeoutMs: 30 * 60 * 1000 },
+  );
+}
+
+async function ensureAndroidSdkCacheDirs(runner, unitPath, androidSdkCacheDir, aptCacheDir, options = {}) {
+  const cacheRoot = `${unitPath}/${androidSdkCacheDir}`;
+  const aptRoot = `${unitPath}/${aptCacheDir}`;
+  await runner.run(
+    `mkdir -p ${shellQuote(`${cacheRoot}/licenses`)} ${shellQuote(`${cacheRoot}/ndk`)} ${shellQuote(`${cacheRoot}/ndk-downloads`)} ${shellQuote(`${cacheRoot}/platforms`)} ${shellQuote(`${cacheRoot}/build-tools`)} ${shellQuote(`${cacheRoot}/cmdline-tools`)} ${shellQuote(`${cacheRoot}/platform-tools`)} ${shellQuote(`${cacheRoot}/cmake`)} ${shellQuote(`${aptRoot}/archives`)} ${shellQuote(`${aptRoot}/lists`)}`,
+    {
+      cwd: unitPath,
+      dryRun: options.dryRun,
+      timeoutMs: options.timeoutMs || DEFAULT_MOBILE_BUILD_TIMEOUT_MS,
+    },
+  );
+}
+
+async function runFlutterAndroidSdkDockerBuild(
+  runner,
+  unitPath,
+  options = {},
+  platform,
+) {
+  const hostArchitecture = await detectHostArchitecture(runner, unitPath, options);
+  const isArm64 = hostArchitecture === 'arm64';
+  const builderImage = isArm64 ? MOBILE_ANDROID_SDK_ARM64_BUILDER_IMAGE : MOBILE_ANDROID_SDK_BUILDER_IMAGE;
+  const platformFlag = platform ? `--platform ${platform} ` : '';
+  const platformLabel = String(platform || (isArm64 ? 'arm64' : 'native')).replace(/[^a-z0-9]+/gi, '-');
+  const containerName = `k3s-mobile-android-sdk-${hashText(`${unitPath}-${platformLabel}`).slice(0, 12)}`;
+  const gradleHome = `/workspace/.gradle/mobile-android-sdk-${platformLabel}`;
+  const flutterSdkCacheDir = `.k3s-deployer/flutter-sdk-${platformLabel}`;
+  const androidSdkCacheDir = `.k3s-deployer/android-sdk-${platformLabel}`;
+  const aptCacheDir = `.k3s-deployer/apt-cache-${platformLabel}`;
+  await ensureAndroidSdkCacheDirs(runner, unitPath, androidSdkCacheDir, aptCacheDir, options);
+  await ensureNdkOnHost(runner, unitPath, androidSdkCacheDir, flutterSdkCacheDir, options);
+  await runner.run(`docker rm -f ${shellQuote(containerName)}`, {
+    cwd: unitPath,
+    dryRun: options.dryRun,
+    allowFailure: true,
+    timeoutMs: options.timeoutMs || DEFAULT_MOBILE_BUILD_TIMEOUT_MS,
+  });
+  try {
+    await runner.run(
+      `docker run ${platformFlag}--name ${shellQuote(containerName)} --rm -v "$PWD":/workspace -v "$PWD/${flutterSdkCacheDir}:/opt/flutter" -v "$PWD/${androidSdkCacheDir}/licenses:/opt/android-sdk-linux/licenses" -v "$PWD/${androidSdkCacheDir}/ndk:/opt/android-sdk-linux/ndk" -v "$PWD/${androidSdkCacheDir}/ndk-downloads:/opt/android-sdk-linux/ndk-downloads" -v "$PWD/${androidSdkCacheDir}/platforms:/opt/android-sdk-linux/platforms" -v "$PWD/${androidSdkCacheDir}/build-tools:/opt/android-sdk-linux/build-tools" -v "$PWD/${androidSdkCacheDir}/cmdline-tools:/opt/android-sdk-linux/cmdline-tools" -v "$PWD/${androidSdkCacheDir}/platform-tools:/opt/android-sdk-linux/platform-tools" -v "$PWD/${androidSdkCacheDir}/cmake:/opt/android-sdk-linux/cmake" -v "$PWD/${aptCacheDir}/archives:/var/cache/apt/archives" -v "$PWD/${aptCacheDir}/lists:/var/lib/apt/lists" -w /workspace -e PUB_CACHE=/workspace/.pub-cache -e GRADLE_USER_HOME=${shellQuote(gradleHome)} -e JAVA_TOOL_OPTIONS="-Djdk.tls.client.protocols=TLSv1.2 -Dhttps.protocols=TLSv1.2" ${shellQuote(builderImage)} sh -lc ${shellQuote(FLUTTER_ANDROID_SDK_BUILD_SCRIPT)}`,
+      {
+        cwd: unitPath,
+        dryRun: options.dryRun,
+        timeoutMs: options.timeoutMs || DEFAULT_MOBILE_BUILD_TIMEOUT_MS,
+        onStdout: options.onLog,
+        onStderr: options.onLog,
+      },
+    );
+  } finally {
+    await runner.run(`docker rm -f ${shellQuote(containerName)}`, {
+      cwd: unitPath,
+      dryRun: options.dryRun,
+      allowFailure: true,
+      timeoutMs: options.timeoutMs || DEFAULT_MOBILE_BUILD_TIMEOUT_MS,
+    });
+  }
+}
+
+async function runFlutterAndroidSdkDockerBuildWithAmd64Fallback(
+  runner,
+  unitPath,
+  options = {},
+) {
+  try {
+    await runFlutterAndroidSdkDockerBuild(
+      runner,
+      unitPath,
+      options,
+      'linux/amd64',
+    );
+  } catch (androidSdkError) {
+    if (!isExecFormatError(androidSdkError)) {
+      throw androidSdkError;
+    }
+
+    if (options.onLog) {
+      await options.onLog(
+        'Android SDK builder needs amd64 emulation, installing amd64 support in Docker',
+      );
+    }
+
+    await ensureDockerAmd64Emulation(runner, unitPath, options);
+    await runFlutterAndroidSdkDockerBuild(
+      runner,
+      unitPath,
+      options,
+      'linux/amd64',
+    );
+  }
+}
+
+async function buildFlutterWithAndroidSdkBuilder(runner, unitPath, options = {}) {
+  const hostArchitecture = await detectHostArchitecture(runner, unitPath, options);
+  if (hostArchitecture === 'arm64') {
+    if (options.onLog) {
+      await options.onLog(
+        'ARM64 host: running Android SDK builder natively (ARM64 JVM + binfmt for x86 tools)',
+      );
+    }
+    // Ensure binfmt_misc is registered so x86_64 build-tool binaries (aapt2, etc.)
+    // can execute transparently without forcing the whole JVM under emulation.
+    await ensureDockerAmd64Emulation(runner, unitPath, options);
+    try {
+      await runFlutterAndroidSdkDockerBuild(runner, unitPath, options);
+    } catch (nativeErr) {
+      if (isExecFormatError(nativeErr)) {
+        // Native arm64 image unavailable — fall back to full amd64 emulation.
+        if (options.onLog) {
+          await options.onLog(
+            'ARM64 native build failed (exec format), falling back to linux/amd64 emulation',
+          );
+        }
+        await runFlutterAndroidSdkDockerBuild(runner, unitPath, options, 'linux/amd64');
+      } else {
+        throw nativeErr;
+      }
+    }
+    return;
+  }
+
+  try {
+    await runFlutterAndroidSdkDockerBuild(runner, unitPath, options);
+  } catch (androidSdkError) {
+    if (isExecFormatError(androidSdkError)) {
+      if (options.onLog) {
+        await options.onLog(
+          'Android SDK builder needs amd64 emulation, installing amd64 support in Docker',
+        );
+      }
+
+      await ensureDockerAmd64Emulation(runner, unitPath, options);
+      await runFlutterAndroidSdkDockerBuild(runner, unitPath, options);
+      return;
+    }
+
+    if (
+      !(
+        isGenSnapshotArtifactError(androidSdkError) ||
+        isAapt2LoaderError(androidSdkError) ||
+        isMissingImageManifestError(androidSdkError)
+      )
+    ) {
+      throw androidSdkError;
+    }
+
+    if (options.onLog) {
+      await options.onLog(
+        'Native Android SDK builder is incompatible with this host, retrying with linux/amd64 emulation',
+      );
+    }
+    await runFlutterAndroidSdkDockerBuildWithAmd64Fallback(
+      runner,
+      unitPath,
+      options,
+    );
+  }
+}
+
+async function ensureDockerAmd64Emulation(runner, unitPath, options = {}) {
+  await runner.run(
+    `docker run --privileged --rm tonistiigi/binfmt --install amd64`,
+    {
+      cwd: unitPath,
+      dryRun: options.dryRun,
+      timeoutMs: options.timeoutMs || DEFAULT_MOBILE_BUILD_TIMEOUT_MS,
+      onStdout: options.onLog,
+      onStderr: options.onLog,
+    },
+  );
+}
+
+async function buildFlutterWithDocker(runner, unitPath, options = {}) {
+  const hostArchitecture = await detectHostArchitecture(runner, unitPath, options);
+  if (hostArchitecture === 'arm64') {
+    if (options.onLog) {
+      await options.onLog(
+        'ARM64 host detected, skipping the default Flutter builder image and using the Android SDK builder directly',
+      );
+    }
+    await buildFlutterWithAndroidSdkBuilder(runner, unitPath, options);
+    return resolveFlutterArtifactPath(runner, unitPath, options);
+  }
+
+  try {
+    try {
+      await runFlutterDockerBuild(runner, unitPath, options);
+    } catch (error) {
+      if (!isGenSnapshotArtifactError(error)) {
+        throw error;
+      }
+
+      if (options.onLog) {
+        await options.onLog(
+          'Containerized Flutter build is missing host gen_snapshot artifacts, retrying with linux/amd64 platform',
+        );
+      }
+
+      try {
+        await runFlutterDockerBuild(runner, unitPath, options, 'linux/amd64');
+      } catch (amd64Error) {
+        if (!isExecFormatError(amd64Error)) {
+          throw amd64Error;
+        }
+
+        if (options.onLog) {
+          await options.onLog(
+            'linux/amd64 Flutter container needs binfmt emulation, installing amd64 support in Docker',
+          );
+        }
+
+        await ensureDockerAmd64Emulation(runner, unitPath, options);
+        await runFlutterDockerBuild(runner, unitPath, options, 'linux/amd64');
+      }
+    }
+  } catch (error) {
+    if (!isAapt2LoaderError(error)) {
+      throw error;
+    }
+
+    if (options.onLog) {
+      await options.onLog(
+        'Current Flutter builder image is incompatible with Android build tools on this host, retrying with Android SDK builder',
+      );
+    }
+    await buildFlutterWithAndroidSdkBuilder(runner, unitPath, options);
+  }
+
+  return resolveFlutterArtifactPath(runner, unitPath, options);
+}
+
+async function buildAndroidWithDocker(runner, unitPath, options = {}) {
+  await runner.run(
+    `docker run --rm -v "$PWD":/workspace -w /workspace -e GRADLE_USER_HOME=/workspace/.gradle ${shellQuote(MOBILE_BUILDER_IMAGE)} sh -lc 'chmod +x ./gradlew && ./gradlew assembleRelease'`,
+    {
+      cwd: unitPath,
+      dryRun: options.dryRun,
+      timeoutMs: options.timeoutMs || DEFAULT_MOBILE_BUILD_TIMEOUT_MS,
+      onStdout: options.onLog,
+      onStderr: options.onLog,
+    },
+  );
+}
+
+async function buildMobileUnit(plan, unit, runner, workspacePath, options = {}) {
+  const unitPath = unit.root === '.' ? workspacePath : `${workspacePath}/${unit.root}`;
+  const dryRun = options.dryRun || false;
+  const log = options.onLog || (() => {});
+  const timeoutMs = options.timeoutMs || DEFAULT_MOBILE_BUILD_TIMEOUT_MS;
+  const hostArchitecture = await detectHostArchitecture(runner, unitPath, {
+    dryRun,
+    timeoutMs,
+  });
+  if (unit.framework === 'android') {
+    await log(`Building Android app from ${unit.root}`);
+    try {
+      await runner.run('./gradlew assembleRelease', {
+        cwd: unitPath,
+        dryRun,
+        timeoutMs,
+        onStdout: log,
+        onStderr: log,
+      });
+    } catch (error) {
+      await log('Native Android build failed, retrying with containerized builder');
+      await buildAndroidWithDocker(runner, unitPath, options);
+    }
+    return `${unitPath}/app/build/outputs/apk/release/app-release.apk`;
+  }
+  await log(`Building Flutter app from ${unit.root}`);
+  await ensureFirebaseOptions(runner, unitPath, {
+    dryRun,
+    onLog: log,
+    timeoutMs,
+  });
+  const applicationId = await findAndroidApplicationId(runner, unitPath, {
+    dryRun,
+    timeoutMs,
+  });
+  if (applicationId && plan.mobile) {
+    plan.mobile.applicationId = applicationId;
+  }
+  const gitRevision = await resolveGitRevision(runner, workspacePath, {
+    dryRun,
+    timeoutMs,
+  });
+  const cachedBuild = await readMobileBuildCache(runner, workspacePath, {
+    dryRun,
+    timeoutMs,
+  });
+  if (
+    cachedBuild &&
+    cachedBuild.framework === 'flutter' &&
+    cachedBuild.hostArchitecture === hostArchitecture &&
+    cachedBuild.gitRevision &&
+    gitRevision &&
+    cachedBuild.gitRevision === gitRevision &&
+    (!applicationId || cachedBuild.applicationId === applicationId) &&
+    cachedBuild.artifactPath &&
+    (await runner.exists(cachedBuild.artifactPath))
+  ) {
+    await log(`Reusing cached mobile build from ${cachedBuild.gitRevision.slice(0, 12)}`);
+    return cachedBuild.artifactPath;
+  }
+  const hasFlutter = await commandSucceeds(
+    runner,
+    'command -v flutter >/dev/null 2>&1',
+    { cwd: unitPath, dryRun },
+  );
+  if (hasFlutter) {
+    await runner.run('flutter pub get', {
+      cwd: unitPath,
+      dryRun,
+      timeoutMs,
+      onStdout: log,
+      onStderr: log,
+    });
+    await runner.run('flutter build apk --release', {
+      cwd: unitPath,
+      dryRun,
+      timeoutMs,
+      onStdout: log,
+      onStderr: log,
+    });
+    return (
+      (await findLatestFlutterArtifact(runner, unitPath, {
+        dryRun,
+        timeoutMs,
+      })) ||
+      `${unitPath}/build/app/outputs/flutter-apk/app-release.apk`
+    );
+  } else {
+    await log('Flutter is not installed on the target host, using containerized builder');
+    const artifactPath = await buildFlutterWithDocker(runner, unitPath, options);
+    await writeMobileBuildCache(runner, workspacePath, {
+      framework: 'flutter',
+      artifactPath,
+      applicationId: applicationId || null,
+      hostArchitecture,
+      gitRevision,
+      updatedAt: new Date().toISOString(),
+    });
+    return artifactPath;
+  }
+}
+
+async function startMobilePreview(plan, config = {}, options = {}) {
+  if (!plan.mobile) {
+    throw new Error('No mobile artifact available for this plan');
+  }
+  if (!config.mobilePreviewAdapter) {
+    throw new Error('No mobile preview adapter is configured');
+  }
+  return config.mobilePreviewAdapter.start({
+    projectSlug: plan.inspection.projectSlug,
+    framework: plan.mobile.framework,
+    artifactPath: options.artifactPath,
+    applicationId: plan.mobile.applicationId,
+    runner: options.runner,
+    onLog: options.onLog,
+    workspacePath: options.workspacePath,
+    plan,
+    domain: options.overrides?.domain || null,
+    cloudflareDns: options.cloudflareDns || null,
+  });
+}
+
+module.exports = {
+  buildMobileUnit,
+  startMobilePreview,
+};