@expo-harmony/cli 55.0.26-harmony.8 → 55.0.26-harmony.9

package/src/exportEmbed/export.ts

@@ -3,11 +3,11 @@ import { createRequire } from 'node:module';
 import os from 'node:os';
 import path from 'node:path';
 
-import { doctorAsync, type DoctorResult } from '../doctor/doctor';
+import { doctorAsync } from '../doctor/doctor';
 import { resolveHarmonyEntryPoint } from '../entry';
 import { HarmonyCliError } from '../errors';
 import { withHarmonyProjectLockAsync } from '../projectLock';
-import { resolveHarmonyBuildPlanAsync } from '../tools';
+import { resolveHarmonyBuildPlanAsync } from '../native/project';
 import { formatDiagnostics, spawnAsync } from '../process';
 import { resolveExpoCli, resolveExpoHermesBuilder } from '../expo';
 import {
@@ -32,65 +32,65 @@ export interface ExportTemporary {
 }
 
 function createExpoExportEmbedArgs(
-  projectRoot: string,
-  entryFile: string,
-  temporary: ExportTemporary,
+  root: string,
+  entry: string,
+  temp: ExportTemporary,
   options: ExportOptions = {}
 ) {
   return [
     'export:embed',
     '--platform', 'harmony',
-    '--entry-file', entryFile,
-    '--bundle-output', temporary.javascript,
-    '--assets-dest', temporary.assets,
+    '--entry-file', entry,
+    '--bundle-output', temp.javascript,
+    '--assets-dest', temp.assets,
     '--dev', 'false',
     '--minify', 'false',
-    '--sourcemap-output', temporary.metroSourceMap,
+    '--sourcemap-output', temp.metroSourceMap,
     '--sourcemap-sources-root', '.',
     '--unstable-transform-profile', 'hermes-stable',
     ...(options.resetCache ? ['--reset-cache=true'] : []),
-    projectRoot,
+    root,
   ];
 }
 
-function assertDoctor(result: DoctorResult) {
-  if (result.ok) return;
-
-  const failing = result.checks.filter(check => check.status === 'error').map(check => check.id);
-  throw new HarmonyCliError('ERR_HARMONY_EXPORT_DOCTOR', `Harmony doctor found blocking checks: ${failing.join(', ') || 'unknown'}.`, { operation: 'doctor' });
-}
-
 async function exportEmbedUnlockedAsync(
-  projectRoot: string,
+  root: string,
   options: ExportOptions = {}
 ): Promise<HarmonyExportManifest> {
-  if (!options.skipDoctor) assertDoctor(await doctorAsync(projectRoot));
+  if (!options.skipDoctor) {
+    const doctor = await doctorAsync(root);
+    if (!doctor.ok) {
+      const checks = doctor.checks.filter(check => check.status === 'error').map(check => check.id);
+
+      throw new HarmonyCliError('ERR_HARMONY_EXPORT_DOCTOR', `Harmony doctor found blocking checks: ${checks.join(', ') || 'unknown'}.`, { operation: 'doctor' });
+    }
+  }
 
-  const plan = await resolveHarmonyBuildPlanAsync(projectRoot, { buildMode: 'release' });
+  const plan = await resolveHarmonyBuildPlanAsync(root, { buildMode: 'release' });
   const paths = exportPaths(plan);
 
   if (options.check) return await validatePublishedExportAsync(paths);
 
-  const entryFile = resolveHarmonyEntryPoint(projectRoot);
-  const temporaryRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'expo-harmony-export-'));
-  const temporary: ExportTemporary = {
-    assets: path.join(temporaryRoot, 'assets'),
-    bundle: path.join(temporaryRoot, 'hermes_bundle.hbc'),
-    javascript: path.join(temporaryRoot, 'index.js'),
-    metroSourceMap: path.join(temporaryRoot, 'index.js.map'),
-    sourceMap: path.join(temporaryRoot, 'hermes_bundle.hbc.map'),
+  const entry = resolveHarmonyEntryPoint(root);
+  const directory = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'expo-harmony-export-'));
+  const temp: ExportTemporary = {
+    assets: path.join(directory, 'assets'),
+    bundle: path.join(directory, 'hermes_bundle.hbc'),
+    javascript: path.join(directory, 'index.js'),
+    metroSourceMap: path.join(directory, 'index.js.map'),
+    sourceMap: path.join(directory, 'hermes_bundle.hbc.map'),
   };
 
   try {
-    await fs.promises.mkdir(temporary.assets, { recursive: true });
+    await fs.promises.mkdir(temp.assets, { recursive: true });
 
-    const expo = resolveExpoCli(projectRoot);
+    const expo = resolveExpoCli(root);
     const result = await spawnAsync(process.execPath, [
       expo.cliPath,
-      ...createExpoExportEmbedArgs(projectRoot, entryFile, temporary, options),
+      ...createExpoExportEmbedArgs(root, entry, temp, options),
     ], {
       capture: true,
-      cwd: projectRoot,
+      cwd: root,
       env: {
         ...process.env,
         EXPO_METRO_TARGET: 'harmony',
@@ -104,6 +104,7 @@ async function exportEmbedUnlockedAsync(
 
     if (result.code !== 0 || result.timedOut) {
       const diagnostics = formatDiagnostics(result);
+
       throw new HarmonyCliError(
         'ERR_HARMONY_EXPORT_FAILED',
         `Expo export:embed exited with code ${result.code}${result.timedOut ? ' after timing out' : ''}.${diagnostics ? `\n${diagnostics}` : ''}`,
@@ -115,24 +116,27 @@ async function exportEmbedUnlockedAsync(
     // then explicitly hand its JS and source map to Expo's own Hermes exporter.
     try {
       const [code, map] = await Promise.all([
-        fs.promises.readFile(temporary.javascript, 'utf8'),
-        fs.promises.readFile(temporary.metroSourceMap, 'utf8'),
+        fs.promises.readFile(temp.javascript, 'utf8'),
+        fs.promises.readFile(temp.metroSourceMap, 'utf8'),
       ]);
-      const buildHermesBundleAsync = resolveExpoHermesBuilder(projectRoot);
+      const buildHermesBundleAsync = resolveExpoHermesBuilder(root);
+
       // Expo resolves hermes-compiler from react-native. For Harmony, resolve it
       // from RNOH instead of the app's Android/iOS React Native installation.
-      const projectRequire = createRequire(path.join(projectRoot, 'package.json'));
-      const harmonyRuntime = path.dirname(projectRequire.resolve('@react-native-oh/react-native-harmony/package.json'));
-      const compilerModules = path.join(temporaryRoot, 'node_modules');
-      await fs.promises.mkdir(compilerModules);
-      await fs.promises.symlink(harmonyRuntime, path.join(compilerModules, 'react-native'),
+      const require = createRequire(path.join(root, 'package.json'));
+      const runtime = path.dirname(require.resolve('@react-native-oh/react-native-harmony/package.json'));
+      const modules = path.join(directory, 'node_modules');
+
+      await fs.promises.mkdir(modules);
+      await fs.promises.symlink(runtime, path.join(modules, 'react-native'),
         process.platform === 'win32' ? 'junction' : 'dir');
+
       const output = await buildHermesBundleAsync({
         code,
-        filename: entryFile,
+        filename: entry,
         map,
         minify: true,
-        projectRoot: temporaryRoot,
+        projectRoot: directory,
       });
 
       if (!(output?.hbc instanceof Uint8Array) || typeof output.sourcemap !== 'string') {
@@ -140,11 +144,18 @@ async function exportEmbedUnlockedAsync(
       }
 
       await Promise.all([
-        fs.promises.writeFile(temporary.bundle, output.hbc),
-        fs.promises.writeFile(temporary.sourceMap, output.sourcemap),
+        fs.promises.writeFile(temp.bundle, output.hbc),
+        fs.promises.writeFile(temp.sourceMap, output.sourcemap),
       ]);
     } catch (cause) {
-      if (cause instanceof HarmonyCliError) throw cause;
+      if (cause instanceof HarmonyCliError) {
+        throw new HarmonyCliError(cause.code, cause.message, {
+          cause,
+          exitCode: cause.exitCode,
+          operation: cause.operation,
+        });
+      }
+
       throw new HarmonyCliError(
         'ERR_HARMONY_EXPORT_HERMES',
         'Expo failed to compile the Harmony bundle to Hermes bytecode.',
@@ -152,26 +163,24 @@ async function exportEmbedUnlockedAsync(
       );
     }
 
-    const bytecode = await assertHermesBundle(temporary.bundle);
-    await assertSourceMap(temporary.sourceMap);
+    const bytecode = await assertHermesBundle(temp.bundle);
+    await assertSourceMap(temp.sourceMap);
 
-    return await publishExportAsync(projectRoot, paths, temporary, entryFile, bytecode);
+    return await publishExportAsync(root, paths, temp, entry, bytecode);
   } finally {
-    await fs.promises.rm(temporaryRoot, { force: true, recursive: true });
+    await fs.promises.rm(directory, { force: true, recursive: true });
   }
 }
 
 async function exportEmbedAsync(
-  projectRoot: string,
+  root: string,
   options: ExportOptions = {}
 ): Promise<HarmonyExportManifest> {
   return withHarmonyProjectLockAsync(
-    projectRoot,
+    root,
     'export:embed',
-    () => exportEmbedUnlockedAsync(projectRoot, options)
+    () => exportEmbedUnlockedAsync(root, options)
   );
 }
 
-export {
-  exportEmbedAsync,
-};
+export { exportEmbedAsync };

package/src/exportEmbed/index.ts

@@ -0,0 +1,17 @@
+import { parseCommandArgs, type Command } from '../command';
+import { parseExportEmbedArgs } from './options';
+
+export const command: Command = async (argv, io) => {
+  const args = parseCommandArgs(parseExportEmbedArgs, argv, io);
+  if (!args) return 0;
+
+  const { projectRoot: root, options } = args;
+  const { exportEmbedAsync } = await import('./export.js');
+
+  const result = await exportEmbedAsync(root, options);
+
+  if (options.check) io.log('Harmony export bundle, assets, and source map are valid.');
+  else io.log(`Exported Hermes bytecode ${result.bundle.path} with ${result.assets.length} asset file(s).`);
+
+  return 0;
+};

package/src/file.ts

@@ -1,4 +1,4 @@
-import nodeCrypto from 'node:crypto';
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 
@@ -6,7 +6,7 @@ import { isInside } from './path';
 
 async function sha256File(file: string): Promise<string> {
   return await new Promise<string>((resolve, reject) => {
-    const hash = nodeCrypto.createHash('sha256');
+    const hash = crypto.createHash('sha256');
     const input = fs.createReadStream(file);
 
     input.on('error', reject);
@@ -70,26 +70,26 @@ async function ensureSafeParent(root: string, destination: string): Promise<void
 async function atomicCopy(source: string, destination: string, root: string): Promise<void> {
   await ensureSafeParent(root, destination);
 
-  const temporary = path.join(path.dirname(destination), `.${path.basename(destination)}.expo-${nodeCrypto.randomUUID()}.tmp`);
+  const temp = path.join(path.dirname(destination), `.${path.basename(destination)}.expo-${crypto.randomUUID()}.tmp`);
 
   try {
-    await fs.promises.copyFile(source, temporary, fs.constants.COPYFILE_EXCL);
-    await fs.promises.rename(temporary, destination);
+    await fs.promises.copyFile(source, temp, fs.constants.COPYFILE_EXCL);
+    await fs.promises.rename(temp, destination);
   } finally {
-    await fs.promises.rm(temporary, { force: true });
+    await fs.promises.rm(temp, { force: true });
   }
 }
 
 async function atomicWriteJson(value: unknown, destination: string, root: string): Promise<void> {
   await ensureSafeParent(root, destination);
 
-  const temporary = path.join(path.dirname(destination), `.${path.basename(destination)}.expo-${nodeCrypto.randomUUID()}.tmp`);
+  const temp = path.join(path.dirname(destination), `.${path.basename(destination)}.expo-${crypto.randomUUID()}.tmp`);
 
   try {
-    await fs.promises.writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx' });
-    await fs.promises.rename(temporary, destination);
+    await fs.promises.writeFile(temp, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx' });
+    await fs.promises.rename(temp, destination);
   } finally {
-    await fs.promises.rm(temporary, { force: true });
+    await fs.promises.rm(temp, { force: true });
   }
 }
 
@@ -107,4 +107,13 @@ async function removeEmptyParents(file: string, stop: string): Promise<void> {
   }
 }
 
-export { atomicCopy, atomicWriteJson, describeFile, listFiles, removeEmptyParents };
+function isNonEmptyRegularFile(file: string): boolean {
+  try {
+    const stat = fs.lstatSync(file);
+    return !stat.isSymbolicLink() && stat.isFile() && stat.size > 0;
+  } catch {
+    return false;
+  }
+}
+
+export { atomicCopy, atomicWriteJson, describeFile, isNonEmptyRegularFile, listFiles, removeEmptyParents };

package/src/help.ts

@@ -0,0 +1,33 @@
+export const Help = `Usage: expo-harmony <command> [project] [options]
+
+Commands:
+  start                 Start Expo Metro for Harmony development
+  prebuild              Generate the Harmony native project with Expo CNG
+  prebuild --clean      Safely recreate the managed Harmony directory
+  prebuild --check      Compare generated desired state without project writes
+  build                 Build a HAP without selecting or contacting a device
+  doctor                Validate config, versions, Metro, RNOH, SDK, and signing
+  modules list          List native module candidates and their discovery source
+  modules inspect       Resolve Harmony metadata (--package narrows the result)
+  modules verify        Validate module config, registration conflicts and safe paths
+  export:embed          Export validated Hermes bytecode, assets, and a source map
+  run                   Build, install, and launch the Harmony app
+
+Options:
+  --no-install          Skip dependency install (prebuild) or HAP install (run)
+  --npm|--yarn|--pnpm|--bun
+                        Select the package manager used by prebuild dependency install
+  --skip-dependency-update <packages>
+                        Preserve comma-separated dependency versions
+  --device <id-or-name> Select an HDC target or start a local emulator by name
+  --variant <mode>      Build debug or release (default: debug)
+  --no-bundler          Use an already-running Expo Metro server
+  --app-id <bundleName>
+                        Launch another installed app (requires --no-install when different)
+  --port <number>       Metro and device reverse port (default: 8081)
+  --sync                Re-run prebuild before building
+  --check               Validate an existing export without writing
+  --reset-cache         Reset Metro while exporting or starting
+  -c, --clear           Alias for --reset-cache (start)
+  -h, --help            Show this help
+`;

package/src/index.ts

@@ -2,11 +2,13 @@ export { runAsync } from './cli';
 export { buildHarmonyAsync } from './buildHap/build';
 export type { HarmonyBuildOptions, HarmonyBuildResult } from './buildHap/build';
 export { exportEmbedAsync } from './exportEmbed/export';
-export { resolveHarmonyBuildPlanAsync, resolveHarmonyToolchain } from './tools';
-export { installHarmonyDependenciesAsync } from './run/install';
+export { resolveHarmonyBuildPlanAsync } from './native/project';
+export type { HarmonyBuildPlan, HarmonyBuildMode } from './native/types';
+export { resolveHarmonyToolchain } from './native/toolchain';
+export { installHarmonyDependenciesAsync } from './native/install';
 export { formatModulesResult, runModulesCommandAsync } from './modules/modules';
 export type { ModulesCommandResult } from './modules/modules';
-export { commitHarmonyNativeBuildCacheAsync, prepareHarmonyNativeBuildCacheAsync } from './run/cache';
+export { commitHarmonyNativeBuildCacheAsync, prepareHarmonyNativeBuildCacheAsync } from './native/cache';
 export { runHarmonyAsync } from './run/run';
 export type { HarmonyExportManifest } from './exportEmbed/manifest';
 export type { HarmonyRunOptions, HarmonyRunResult } from './run/run';

package/src/internal/prebuild.ts

@@ -0,0 +1,3 @@
+export { withGeneratedProjectAsync } from '../prebuild/check';
+export { assertSafeCleanTarget } from '../prebuild/clean';
+export { withHarmonyProjectLockAsync } from '../projectLock';

package/src/log.ts

@@ -0,0 +1,5 @@
+export type Log = Pick<Console, 'error' | 'log' | 'warn'>;
+
+export function progress(options: { io?: Log }, message: string): void {
+  options.io?.log(`› ${message}`);
+}

package/src/modules/index.ts

@@ -0,0 +1,16 @@
+import { parseCommandArgs, type Command } from '../command';
+import { parseModulesArgs } from './options';
+
+export const command: Command = async (argv, io) => {
+  const args = parseCommandArgs(parseModulesArgs, argv, io);
+  if (!args) return 0;
+
+  const { projectRoot: root, options } = args;
+  const { formatModulesResult, runModulesCommandAsync } = await import('./modules.js');
+
+  const result = await runModulesCommandAsync(root, options);
+
+  io.log(formatModulesResult(result));
+
+  return result.ok ? 0 : 1;
+};

package/src/native/bare.ts

@@ -0,0 +1,145 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import JSON5 from 'json5';
+
+import { HarmonyCliError } from '../errors';
+import type { BareHarmonyBuildPlan } from './types';
+
+function isBareHarmonyProject(root: string): boolean {
+  return fs.existsSync(path.join(root, 'harmony'))
+    && !fs.existsSync(path.join(root, 'harmony/.expo-harmony-template'))
+    && !fs.existsSync(path.join(root, '.expo/harmony/cng-manifest.json'));
+}
+
+function record(value: unknown, field: string): Record<string, unknown> {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw new HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Native ${field} must be an object.`, { operation: 'resolve-build' });
+  }
+
+  return value as Record<string, unknown>;
+}
+
+function records(value: unknown, field: string): Record<string, unknown>[] {
+  if (!Array.isArray(value)) {
+    throw new HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Native ${field} must be an array.`, { operation: 'resolve-build' });
+  }
+
+  return value.map(item => record(item, field));
+}
+
+function readJson(file: string): Record<string, unknown> {
+  try {
+    return record(JSON5.parse(fs.readFileSync(file, 'utf8')), file);
+  } catch (cause) {
+    throw new HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Cannot read native project file ${file}: ${cause.message}`, { cause, operation: 'resolve-build' });
+  }
+}
+
+function identifier(value: unknown, field: string): string {
+  if (typeof value !== 'string' || !/^[A-Za-z_][A-Za-z0-9_.]*$/.test(value)) {
+    throw new HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `The native project must specify a valid ${field}.`, { operation: 'resolve-build' });
+  }
+
+  return value;
+}
+
+function selectDefault(items: Record<string, unknown>[], field: string): Record<string, unknown> {
+  if (items.length === 0) {
+    throw new HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `No ${field} is defined in harmony/build-profile.json5.`, { operation: 'resolve-build' });
+  }
+
+  const defaults = items.filter(item => item.name === 'default');
+
+  if (defaults.length === 1) return defaults[0];
+  if (items.length === 1) return items[0];
+
+  throw new HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Multiple ${field} are defined; name the intended default "default" in harmony/build-profile.json5.`, { operation: 'resolve-build' });
+}
+
+function resolveBareHarmonyBuildPlan(root: string, mode: 'debug' | 'release'): BareHarmonyBuildPlan {
+  const harmony = path.join(root, 'harmony');
+  const entry = path.join(harmony, 'entry');
+
+  for (const directory of [harmony, entry]) {
+    if (!fs.existsSync(directory)
+      || !fs.lstatSync(directory).isDirectory() || fs.lstatSync(directory).isSymbolicLink()) {
+      throw new HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Bare Harmony projects require a regular directory at ${directory}.`, { operation: 'resolve-build' });
+    }
+  }
+
+  const profile = readJson(path.join(harmony, 'build-profile.json5'));
+  const app = record(readJson(path.join(harmony, 'AppScope/app.json5')).app, 'app');
+  const module = record(readJson(path.join(entry, 'src/main/module.json5')).module, 'module');
+
+  const name = identifier(module.name, 'module.name');
+  const registration = records(profile.modules, 'modules').find(item => item.name === name);
+  if (!registration || typeof registration.srcPath !== 'string'
+    || path.resolve(harmony, registration.srcPath) !== entry || module.type !== 'entry') {
+    throw new HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', 'Bare Harmony autolinking requires an entry module at harmony/entry, registered in build-profile.json5.', { operation: 'resolve-build' });
+  }
+
+  const config = record(profile.app, 'build-profile.app');
+  const selected = selectDefault(records(config.products, 'products'), 'products');
+  const product = identifier(selected.name, 'product name');
+  const targets = records(registration.targets, 'module targets').filter((item) => {
+    if (item.applyToProducts === undefined) return true;
+    if (!Array.isArray(item.applyToProducts) || item.applyToProducts.some(value => typeof value !== 'string')) {
+      throw new HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', 'Native target.applyToProducts must be an array of product names.', { operation: 'resolve-build' });
+    }
+
+    return item.applyToProducts.includes(product);
+  });
+  const target = identifier(selectDefault(targets, 'module targets').name, 'target name');
+
+  const ability = identifier(module.mainElement, 'module.mainElement');
+  if (!records(module.abilities, 'abilities').some(item => item.name === ability)) {
+    throw new HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Ability ${ability} is missing from module.json5.`, { operation: 'resolve-build' });
+  }
+
+  const bundle = identifier(app.bundleName, 'app.bundleName');
+  const signed = Boolean(selected.signingConfig);
+  if (signed && !records(config.signingConfigs, 'signingConfigs').some(item => item.name === selected.signingConfig)) {
+    throw new HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Signing config ${selected.signingConfig} is referenced by the product but is not defined.`, { operation: 'resolve-build' });
+  }
+
+  const rawfile = path.join(entry, 'src/main/resources/rawfile');
+  const metadata = path.join(root, '.expo/harmony/export');
+
+  return {
+    workflow: 'bare',
+    abilityName: ability,
+    buildMode: mode,
+    bundleName: bundle,
+    harmonyRoot: harmony,
+    moduleName: name,
+    moduleRoot: entry,
+    productName: product,
+    targetName: target,
+    expectedHap: path.join(entry, `build/${target}/outputs/${target}/${name}-${target}-${signed ? 'signed' : 'unsigned'}.hap`),
+    hvigorArgs: ['--mode', 'module', '-p', `module=${name}@${target}`, '-p', `product=${product}`, '-p', `buildMode=${mode}`, '--no-daemon', 'assembleHap'],
+    exportPaths: {
+      bundle: path.join(rawfile, 'hermes_bundle.hbc'),
+      manifest: path.join(root, '.expo/harmony/export-manifest.json'),
+      metadataRoot: metadata,
+      rawfileRoot: rawfile,
+      sourceMap: path.join(metadata, 'hermes_bundle.hbc.map'),
+    },
+    nativeCache: {
+      invalidationRoots: [path.join(entry, '.cxx'), path.join(entry, 'build')],
+      stateFile: path.join(entry, '.cxx/.expo-harmony-native-dependencies.json'),
+    },
+    nativeInputs: {
+      lockfile: path.join(harmony, 'oh-package-lock.json5'),
+      manifest: path.join(harmony, 'oh-package.json5'),
+    },
+    projectFiles: {
+      hvigorConfig: path.join(harmony, 'hvigor/hvigor-config.json5'),
+      moduleHvigor: path.join(entry, 'hvigorfile.ts'),
+      moduleJson: path.join(entry, 'src/main/module.json5'),
+      projectBuildProfile: path.join(harmony, 'build-profile.json5'),
+      rootHvigor: path.join(harmony, 'hvigorfile.ts'),
+    },
+  };
+}
+
+export { isBareHarmonyProject, resolveBareHarmonyBuildPlan };

package/src/native/build.ts

@@ -0,0 +1,81 @@
+import path from 'node:path';
+
+import { commitHarmonyNativeBuildCacheAsync, prepareHarmonyNativeBuildCacheAsync } from './cache';
+import { installHarmonyDependenciesAsync } from './install';
+import type { HarmonyToolchain } from './toolchain';
+import type { HarmonyBuildPlan } from './types';
+import { HarmonyCliError } from '../errors';
+import { exportEmbedAsync } from '../exportEmbed/export';
+import { isNonEmptyRegularFile } from '../file';
+import { progress, type Log } from '../log';
+import { toPosixPath } from '../path';
+import { runCheckedAsync } from '../process';
+import { timedAsync } from '../profile';
+
+export interface NativeBuildResult {
+  export: null | { assetCount: number; bundleSha256: string; sourceMapSha256: string };
+  hapPath: string;
+}
+
+export async function buildNativeAsync(
+  root: string,
+  plan: HarmonyBuildPlan,
+  tools: HarmonyToolchain,
+  options: { io?: Log; resetCache?: boolean },
+  steps: Record<string, number>
+): Promise<NativeBuildResult> {
+  let exported: NativeBuildResult['export'] = null;
+  if (plan.buildMode === 'release') {
+    progress(options, 'Exporting the release Hermes bundle');
+    const manifest = await timedAsync(steps, 'export', () => exportEmbedAsync(root, {
+      resetCache: options.resetCache,
+      skipDoctor: true,
+    }));
+
+    exported = {
+      assetCount: manifest.assets.length,
+      bundleSha256: manifest.bundle.sha256,
+      sourceMapSha256: manifest.sourceMap.sha256,
+    };
+  } else {
+    steps.export = 0;
+  }
+
+  progress(options, 'Installing Harmony project dependencies');
+  await timedAsync(steps, 'ohpm', () => installHarmonyDependenciesAsync(plan, tools));
+
+  progress(options, 'Checking Harmony native dependency cache');
+  const cache = await timedAsync(steps, 'nativeCache', () => prepareHarmonyNativeBuildCacheAsync(root, plan));
+  if (cache.changed) progress(options, 'Invalidated stale Harmony native build objects');
+
+  progress(options, `Building the ${plan.buildMode} HAP`);
+  await timedAsync(steps, 'build', () => runCheckedAsync(tools.hvigor.command, [
+    ...tools.hvigor.args,
+    ...plan.hvigorArgs,
+  ], {
+    code: 'ERR_HARMONY_BUILD_FAILED',
+    cwd: plan.harmonyRoot,
+    env: {
+      ...process.env,
+      EXPO_HARMONY_NODE: process.env.EXPO_HARMONY_NODE || process.execPath,
+      EXPO_METRO_TARGET: 'harmony',
+      HERMES_V1_ENABLED: 'true',
+      ...(plan.workflow === 'bare' ? { EXPO_HARMONY_NATIVE_PREPARED: '1' } : {}),
+      ...(plan.buildMode === 'release' ? { EXPO_HARMONY_BUNDLE_PREBUILT: '1' } : {}),
+      ...(tools.sdkHome && !process.env.DEVECO_SDK_HOME
+        ? { DEVECO_SDK_HOME: tools.sdkHome }
+        : {}),
+    },
+    message: 'Hvigor build',
+    operation: 'hvigor-build',
+    timeoutMs: 15 * 60_000,
+  }));
+
+  if (!isNonEmptyRegularFile(plan.expectedHap)) {
+    throw new HarmonyCliError('ERR_HARMONY_HAP_MISSING', 'Hvigor completed without producing the expected non-empty regular HAP.', { operation: 'verify-hap' });
+  }
+
+  await timedAsync(steps, 'nativeCacheCommit', () => commitHarmonyNativeBuildCacheAsync(cache));
+
+  return { export: exported, hapPath: toPosixPath(path.relative(root, plan.expectedHap)) };
+}