@expo-harmony/cli 55.0.26-harmony.1 → 55.0.26-harmony.11

package/src/doctor/doctor.ts

@@ -5,17 +5,14 @@ import path from 'node:path';
 import { getConfig } from '@expo/config';
 import { normalizeHarmonyConfig } from '@expo-harmony/config-plugins';
 import { verifyModulesAsync } from '@expo-harmony/expo-modules-autolinking';
-import { isRnohAutolinkingDisabled } from '@expo-harmony/prebuild-config/native-project';
-import { validateHarmonySigningConfigFile } from '@expo-harmony/prebuild-config/signing';
+import { isRnohAutolinkingDisabled, validateHarmonySigningConfigFile } from '@expo-harmony/prebuild-config/internal';
 
 import { spawnAsync } from '../process';
 import { withHarmonyProjectLockAsync } from '../projectLock';
-import {
-  resolveHarmonyBuildPlanIfPresentAsync,
-  resolveHarmonyToolchain,
-  type HarmonyTool,
-} from '../tools';
+import { resolveHarmonyBuildPlanIfPresentAsync } from '../native/project';
+import { resolveHarmonyToolchain, type HarmonyTool } from '../native/toolchain';
 import { RequiredProjectPackages } from '../upstream';
+import { isBareHarmonyProject } from '../native/bare';
 
 export interface DoctorCheck {
   details?: unknown;
@@ -37,22 +34,23 @@ interface DoctorOptions {
   validateModules?: boolean;
 }
 
-function hasPlugin(plugins, packageName) {
-  return (plugins || []).some(plugin => (Array.isArray(plugin) ? plugin[0] : plugin) === packageName);
+function hasPlugin(plugins, name) {
+  return (plugins || []).some(plugin => (Array.isArray(plugin) ? plugin[0] : plugin) === name);
 }
 
 function check(id: string, status: DoctorCheck['status'], message: string, details?: unknown): DoctorCheck {
   return { id, status, message, ...(details ? { details } : {}) };
 }
 
-function canResolvePackage(projectRoot, packageName) {
-  const projectRequire = createRequire(path.join(projectRoot, 'package.json'));
+function canResolvePackage(root, name) {
+  const require = createRequire(path.join(root, 'package.json'));
+
   try {
-    projectRequire.resolve(`${packageName}/package.json`);
+    require.resolve(`${name}/package.json`);
     return true;
   } catch {
     try {
-      projectRequire.resolve(packageName);
+      require.resolve(name);
       return true;
     } catch {
       return false;
@@ -60,20 +58,20 @@ function canResolvePackage(projectRoot, packageName) {
   }
 }
 
-async function validateMetroConfigAsync(projectRoot) {
-  const projectRequire = createRequire(path.join(projectRoot, 'package.json'));
-  let metroConfig;
+async function validateMetroConfigAsync(root) {
+  const require = createRequire(path.join(root, 'package.json'));
+  let metro;
 
   try {
-    metroConfig = projectRequire('metro-config');
+    metro = require('metro-config');
   } catch (cause) {
     throw new Error('Cannot load the project-local metro-config package.', { cause });
   }
 
-  if (typeof metroConfig.resolveConfig !== 'function') {
+  if (typeof metro.resolveConfig !== 'function') {
     const version = (() => {
       try {
-        return projectRequire('metro-config/package.json').version;
+        return require('metro-config/package.json').version;
       } catch {
         return 'unknown';
       }
@@ -82,15 +80,15 @@ async function validateMetroConfigAsync(projectRoot) {
     throw new Error(`metro-config ${version} does not expose resolveConfig().`);
   }
 
-  const hadMetroTarget = Object.hasOwn(process.env, 'EXPO_METRO_TARGET');
-  const previousMetroTarget = process.env.EXPO_METRO_TARGET;
+  const present = Object.hasOwn(process.env, 'EXPO_METRO_TARGET');
+  const previous = process.env.EXPO_METRO_TARGET;
   let resolved;
 
   try {
     process.env.EXPO_METRO_TARGET = 'harmony';
-    resolved = await metroConfig.resolveConfig(undefined, projectRoot);
+    resolved = await metro.resolveConfig(undefined, root);
   } finally {
-    if (hadMetroTarget) process.env.EXPO_METRO_TARGET = previousMetroTarget;
+    if (present) process.env.EXPO_METRO_TARGET = previous;
     else delete process.env.EXPO_METRO_TARGET;
   }
 
@@ -105,33 +103,40 @@ async function validateMetroConfigAsync(projectRoot) {
   }
 }
 
-async function doctorUnlockedAsync(projectRoot: string, options: DoctorOptions = {}): Promise<DoctorResult> {
+async function doctorUnlockedAsync(root: string, options: DoctorOptions = {}): Promise<DoctorResult> {
   const checks: DoctorCheck[] = [];
-  const unavailableToolStatus = options.requireBuildTools ? 'error' : 'warn';
+  const unavailable = options.requireBuildTools ? 'error' : 'warn';
   let config;
+  const bare = isBareHarmonyProject(root);
 
   try {
-    config = getConfig(projectRoot, {
-      isModdedConfig: true,
-      skipSDKVersionRequirement: true,
-    }).exp;
-    normalizeHarmonyConfig(config);
-    checks.push(check('app-config', 'pass', 'Harmony app config is valid.'));
+    if (bare) {
+      const plan = await resolveHarmonyBuildPlanIfPresentAsync(root);
+      checks.push(check('native-config', 'pass', `Bare Harmony project: ${plan.bundleName} / ${plan.moduleName}. Native files own the configuration.`));
+    } else {
+      config = getConfig(root, {
+        isModdedConfig: true,
+        skipSDKVersionRequirement: true,
+      }).exp;
+      normalizeHarmonyConfig(config);
+      checks.push(check('app-config', 'pass', 'Harmony app config is valid.'));
+    }
   } catch (error) {
-    checks.push(check('app-config', 'error', error.message, { code: error.code || 'ERR_HARMONY_CONFIG_INVALID' }));
+    checks.push(check(bare ? 'native-config' : 'app-config', 'error', error.message, { code: error.code || 'ERR_HARMONY_CONFIG_INVALID' }));
   }
 
   if (config) {
     checks.push(hasPlugin(config.plugins, '@expo-harmony/prebuild-config')
       ? check('config-plugin', 'pass', '@expo-harmony/prebuild-config is registered.')
       : check('config-plugin', 'error', 'Add @expo-harmony/prebuild-config to expo.plugins.'));
+
     const harmony = (config as typeof config & {
       harmony?: { signingConfigFile?: string };
     }).harmony;
 
     if (harmony?.signingConfigFile) {
       try {
-        const signing = await validateHarmonySigningConfigFile(projectRoot, harmony.signingConfigFile);
+        const signing = await validateHarmonySigningConfigFile(root, harmony.signingConfigFile);
         checks.push(check('signing', 'pass', `Harmony signing config ${signing.name} is valid.`));
       } catch (error) {
         checks.push(check('signing', 'error', error.message, { code: error.code || 'ERR_HARMONY_SIGNING_INVALID' }));
@@ -142,23 +147,23 @@ async function doctorUnlockedAsync(projectRoot: string, options: DoctorOptions =
   }
 
   try {
-    await validateMetroConfigAsync(projectRoot);
+    await validateMetroConfigAsync(root);
     checks.push(check('metro', 'pass', 'The resolved Metro config enables Harmony.'));
   } catch (error) {
     checks.push(check('metro', 'error', `Cannot load a Harmony-enabled Metro config: ${error.message}`, { code: error.code || 'ERR_HARMONY_METRO_CONFIG' }));
   }
 
-  for (const packageName of RequiredProjectPackages) {
-    if (canResolvePackage(projectRoot, packageName)) {
-      checks.push(check(`package:${packageName}`, 'pass', `${packageName} is resolvable.`));
+  for (const name of RequiredProjectPackages) {
+    if (canResolvePackage(root, name)) {
+      checks.push(check(`package:${name}`, 'pass', `${name} is resolvable.`));
     } else {
-      checks.push(check(`package:${packageName}`, 'error', `${packageName} is not resolvable from the app.`));
+      checks.push(check(`package:${name}`, 'error', `${name} is not resolvable from the app.`));
     }
   }
 
   if (options.validateModules !== false) {
     try {
-      const result = await verifyModulesAsync({ platform: 'harmony', projectRoot });
+      const result = await verifyModulesAsync({ platform: 'harmony', projectRoot: root });
       const errors = result.diagnostics.filter(item => item.severity === 'error');
       const warnings = result.diagnostics.filter(item => item.severity === 'warning');
 
@@ -190,51 +195,55 @@ async function doctorUnlockedAsync(projectRoot: string, options: DoctorOptions =
   }
 
   const toolchain = resolveHarmonyToolchain();
-  let sdkCheck;
+  let sdk;
 
   if (toolchain.sdkHome) {
-    sdkCheck = check('harmony-sdk', 'pass', `Complete Harmony SDK root was resolved at ${toolchain.sdkHome}.`);
+    sdk = check('harmony-sdk', 'pass', `Complete Harmony SDK root was resolved at ${toolchain.sdkHome}.`);
   } else {
-    sdkCheck = check('harmony-sdk', unavailableToolStatus, 'No complete Harmony SDK root with HMS and OpenHarmony components was found; generation works but HAP build cannot be verified.');
+    sdk = check('harmony-sdk', unavailable, 'No complete Harmony SDK root with HMS and OpenHarmony components was found; generation works but HAP build cannot be verified.');
   }
 
-  checks.push(sdkCheck);
+  checks.push(sdk);
 
   const tools: Array<[string, HarmonyTool, string[], DoctorCheck['status']]> = [
-    ['ohpm', toolchain.ohpm, ['--version'], unavailableToolStatus],
-    ['hvigor-command', toolchain.hvigor, ['--version'], unavailableToolStatus],
+    ['ohpm', toolchain.ohpm, ['--version'], unavailable],
+    ['hvigor-command', toolchain.hvigor, ['--version'], unavailable],
   ];
   if (options.requireDeviceTools !== false) {
-    tools.unshift(['hdc', toolchain.hdc, ['-v'], unavailableToolStatus]);
+    tools.unshift(['hdc', toolchain.hdc, ['-v'], unavailable]);
   }
-  for (const [id, tool, versionArgs, unavailableStatus] of tools) {
+
+  for (const [id, tool, args, status] of tools) {
+    const command = [tool.command, ...tool.args].map(value => JSON.stringify(value)).join(' ');
+
     try {
-      const result = await spawnAsync(tool.command, [...tool.args, ...versionArgs], {
+      const result = await spawnAsync(tool.command, [...tool.args, ...args], {
         capture: true,
-        cwd: projectRoot,
+        cwd: root,
         operation: `doctor-${id}`,
         timeoutMs: 10_000,
       });
+
       checks.push(result.code === 0 && !result.timedOut
-        ? check(id, 'pass', `${tool.command} is available through ${tool.source}.`)
-        : check(id, unavailableStatus, `${tool.command} is unavailable or unhealthy; HAP build cannot be verified.`));
+        ? check(id, 'pass', `${command} is available through ${tool.source}.`)
+        : check(id, status, `${command} is unavailable or unhealthy; HAP build cannot be verified.`));
     } catch {
-      checks.push(check(id, unavailableStatus, `${tool.command} is unavailable; generation remains available.`));
+      checks.push(check(id, status, `${command} is unavailable; generation remains available.`));
     }
   }
 
   if (options.validateGeneratedProject !== false) {
     try {
-      const plan = await resolveHarmonyBuildPlanIfPresentAsync(projectRoot);
+      const plan = await resolveHarmonyBuildPlanIfPresentAsync(root);
       if (plan && fs.existsSync(plan.harmonyRoot)) {
         if (!fs.existsSync(plan.projectFiles.rootHvigor)
           || !fs.existsSync(plan.projectFiles.moduleHvigor)) {
-          checks.push(check('hvigor', 'error', 'Generated root and module Hvigor files are required.'));
+          checks.push(check('hvigor', 'error', 'Root and module Hvigor files are required.'));
         } else {
           const content = await fs.promises.readFile(plan.projectFiles.moduleHvigor, 'utf8');
           checks.push(isRnohAutolinkingDisabled(content)
             ? check('hvigor-autolinking', 'pass', 'RNOH duplicate autolinking is disabled.')
-            : check('hvigor-autolinking', 'error', 'The generated module Hvigor file must disable RNOH autolinking.'));
+            : check('hvigor-autolinking', 'error', 'The module Hvigor file must disable duplicate RNOH autolinking.'));
         }
       }
     } catch (error) {
@@ -245,16 +254,12 @@ async function doctorUnlockedAsync(projectRoot: string, options: DoctorOptions =
   return {
     checks,
     ok: checks.every(item => item.status !== 'error'),
-    projectRoot,
+    projectRoot: root,
   };
 }
 
-async function doctorAsync(projectRoot: string, options: DoctorOptions = {}): Promise<DoctorResult> {
-  return withHarmonyProjectLockAsync(
-    projectRoot,
-    'doctor',
-    () => doctorUnlockedAsync(projectRoot, options)
-  );
+async function doctorAsync(root: string, options: DoctorOptions = {}): Promise<DoctorResult> {
+  return withHarmonyProjectLockAsync(root, 'doctor', () => doctorUnlockedAsync(root, options));
 }
 
 function formatDoctor(result: DoctorResult): string {

package/src/doctor/index.ts

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

package/src/exportEmbed/export.ts

@@ -3,13 +3,14 @@ import { createRequire } from 'node:module';
 import os from 'node:os';
 import path from 'node:path';
 
-import { doctorAsync, type DoctorResult } from '../doctor/doctor';
+import { publishEmbeddedUpdateAsync } from '../updates/export';
+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 { resolveExpoHermesBuilder } from '../expo';
 import {
   assertHermesBundle, assertSourceMap, exportPaths,
   publishExportAsync, validatePublishedExportAsync,
@@ -18,6 +19,7 @@ import {
 
 export interface ExportOptions {
   check?: boolean;
+  outputDirectory?: string;
   resetCache?: boolean;
   skipDoctor?: boolean;
   timeoutMs?: number;
@@ -28,69 +30,56 @@ export interface ExportTemporary {
   bundle: string;
   javascript: string;
   metroSourceMap: string;
+  metadata: string;
   sourceMap: string;
 }
 
-function createExpoExportEmbedArgs(
-  projectRoot: string,
-  entryFile: string,
-  temporary: ExportTemporary,
-  options: ExportOptions = {}
-) {
-  return [
-    'export:embed',
-    '--platform', 'harmony',
-    '--entry-file', entryFile,
-    '--bundle-output', temporary.javascript,
-    '--assets-dest', temporary.assets,
-    '--dev', 'false',
-    '--minify', 'false',
-    '--sourcemap-output', temporary.metroSourceMap,
-    '--sourcemap-sources-root', '.',
-    '--unstable-transform-profile', 'hermes-stable',
-    ...(options.resetCache ? ['--reset-cache=true'] : []),
-    projectRoot,
-  ];
-}
-
-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 paths = exportPaths(plan);
+  const plan = await resolveHarmonyBuildPlanAsync(root, { buildMode: 'release' });
+  const paths = options.outputDirectory
+    ? {
+        rawfileRoot: path.join(options.outputDirectory, 'embedded'), bundle: path.join(options.outputDirectory, 'embedded/hermes_bundle.hbc'),
+        metadataRoot: options.outputDirectory, manifest: path.join(options.outputDirectory, 'export-manifest.json'),
+        sourceMap: path.join(options.outputDirectory, 'hermes_bundle.hbc.map'),
+      }
+    : 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'),
+    metadata: path.join(directory, 'assets.json'),
+    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 result = await spawnAsync(process.execPath, [
-      expo.cliPath,
-      ...createExpoExportEmbedArgs(projectRoot, entryFile, temporary, options),
+      path.resolve(__dirname, '../internal/export.js'), root,
+      JSON.stringify({ update: !!options.outputDirectory, platform: 'harmony', entryFile: entry, bundleOutput: temp.javascript, assetsDest: temp.assets,
+        dev: false, minify: false, sourcemapOutput: temp.metroSourceMap, sourcemapSourcesRoot: '.',
+        unstableTransformProfile: 'hermes-stable', resetCache: options.resetCache }), temp.metadata,
     ], {
       capture: true,
-      cwd: projectRoot,
+      cwd: root,
       env: {
         ...process.env,
         EXPO_METRO_TARGET: 'harmony',
@@ -104,6 +93,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 +105,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 +133,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 +152,27 @@ async function exportEmbedUnlockedAsync(
       );
     }
 
-    const bytecode = await assertHermesBundle(temporary.bundle);
-    await assertSourceMap(temporary.sourceMap);
+    const bytecode = await assertHermesBundle(temp.bundle);
+    await assertSourceMap(temp.sourceMap);
+
+    const manifest = await publishExportAsync(root, paths, temp, entry, bytecode);
+    await publishEmbeddedUpdateAsync(root, paths, JSON.parse(await fs.promises.readFile(temp.metadata, 'utf8')));
 
-    return await publishExportAsync(projectRoot, paths, temporary, entryFile, bytecode);
+    return manifest;
   } 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,41 @@
+export const Help = `Usage: expo-harmony <command> [project] [options]
+
+Commands:
+  start                 Start Expo Metro for Harmony development
+  runtime               Describe project requirements; --client file checks compatibility
+  runtime --publish     Embed capabilities from prepared native build inputs
+  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                Export an OTA update, assets, metadata, and source map
+  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)
+  --host <hostname>     Advertised HTTP LAN hostname (start)
+  --private-key-path <path>
+                        Sign development manifests using the configured Updates certificate
+  --port <number>       Metro and device reverse port (default: 8081)
+  --sync                Re-run prebuild before building
+  --output-dir <path>   OTA export directory (default: dist)
+  --asset-url <url>     HTTP(S) root hosting exported OTA assets
+  --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
+`;