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

package/src/run/metro.ts

@@ -1,5 +1,6 @@
 import http from 'node:http';
 
+import { readDevelopmentSessionAsync } from '../development/session';
 import { HarmonyCliError } from '../errors';
 import { formatDiagnostics, startManagedProcess, type ProcessResult } from '../process';
 import { resolveExpoCli } from '../expo';
@@ -8,13 +9,16 @@ type MetroStatus = 'free' | 'metro' | 'occupied';
 
 interface MetroOptions {
   interactive?: boolean;
+  host?: string;
   port: number;
+  privateKeyPath?: string;
   readyTimeoutMs?: number;
   resetCache?: boolean;
 }
 
 export interface MetroSession {
   owner: 'existing' | 'started';
+  development?: Awaited<ReturnType<typeof readDevelopmentSessionAsync>>;
   port: number;
   process?: ReturnType<typeof startManagedProcess>;
   stop(): Promise<unknown>;
@@ -101,6 +105,7 @@ async function startExpoMetroAsync(
 
   if (before === 'metro') {
     return {
+      development: await readDevelopmentSessionAsync(projectRoot, options.port, options.host),
       owner: 'existing',
       port: options.port,
       stop: async () => {},
@@ -118,17 +123,20 @@ async function startExpoMetroAsync(
 
   const expo = resolveExpoCli(projectRoot);
   const managed = startManagedProcess(process.execPath, [
+    require.resolve('../internal/development'),
     expo.cliPath,
     'start',
     projectRoot,
     '--dev-client',
     '--port', String(options.port),
+    ...(options.privateKeyPath ? ['--private-key-path', options.privateKeyPath] : []),
     ...(options.resetCache ? ['--clear'] : []),
   ], {
     cwd: projectRoot,
     env: {
       ...process.env,
       EXPO_METRO_TARGET: 'harmony',
+      ...(options.host ? { REACT_NATIVE_PACKAGER_HOSTNAME: options.host } : {}),
     },
     operation: 'expo-metro',
     outputLimit: 1024 * 1024,
@@ -147,7 +155,7 @@ async function startExpoMetroAsync(
   );
 
   const startedAt = Date.now();
-  const timeoutMs = options.readyTimeoutMs || 60_000;
+  const timeoutMs = options.readyTimeoutMs || 1800000;
 
   try {
     while (Date.now() - startedAt < timeoutMs) {
@@ -184,6 +192,7 @@ async function startExpoMetroAsync(
 
       if (await probeMetroAsync(options.port) === 'metro') {
         return {
+          development: await readDevelopmentSessionAsync(projectRoot, options.port, options.host),
           owner: 'started',
           port: options.port,
           process: managed,

package/src/run/options.ts

@@ -8,6 +8,7 @@ const RunOptions = {
   'no-bundler': { type: 'boolean' },
   'no-install': { type: 'boolean' },
   'port': { type: 'string' },
+  'private-key-path': { type: 'string' },
   'reset-cache': { type: 'boolean' },
   'sync': { type: 'boolean' },
   'variant': { type: 'string' },
@@ -61,6 +62,7 @@ function parseRunArgs(argv: string[]) {
     noBundler: Boolean(values['no-bundler']),
     noInstall: Boolean(values['no-install']),
     port,
+    privateKeyPath: values['private-key-path'],
     project: positionals[0],
     resetCache: Boolean(values['reset-cache']),
     sync: Boolean(values.sync),

package/src/run/run.ts

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { getConfig } from '@expo/config';
 
 import {
   configureMetroPortAsync,
@@ -7,33 +8,18 @@ import {
   selectDeviceAsync,
 } from './devices';
 import { HarmonyCliError } from '../errors';
-import { exportEmbedAsync } from '../exportEmbed/export';
-import type { HarmonyExportManifest } from '../exportEmbed/manifest';
-import {
-  resolveHarmonyBuildPlanAsync,
-  resolveHarmonyEmulator,
-  resolveHarmonyToolchain,
-  type HarmonyBuildPlan,
-} from '../tools';
-import { installHarmonyDependenciesAsync } from './install';
+import { resolveHarmonyEmulator, resolveHarmonyToolchain } from '../native/toolchain';
+import { type HarmonyBuildPlan } from '../native/types';
 import {
   requireExistingMetroAsync,
   startExpoMetroAsync,
   type MetroSession,
 } from './metro';
-import {
-  commitHarmonyNativeBuildCacheAsync,
-  prepareHarmonyNativeBuildCacheAsync,
-} from './cache';
-import { toPosixPath } from '../path';
 import { withHarmonyProjectLockAsync } from '../projectLock';
-import {
-  ensureGeneratedProjectAsync,
-  isNonEmptyRegularFile,
-  progress,
-  runCheckedAsync,
-  timed,
-} from '../buildHap/common';
+import { buildNativeAsync, type NativeBuildResult } from '../native/build';
+import { prepareNativeProjectAsync } from '../native/prepareProject';
+import { progress } from '../log';
+import { timedAsync } from '../profile';
 
 export interface HarmonyRunOptions {
   appId?: string;
@@ -42,16 +28,15 @@ export interface HarmonyRunOptions {
   noBundler?: boolean;
   noInstall?: boolean;
   port?: number;
+  privateKeyPath?: string;
   resetCache?: boolean;
   sync?: boolean;
   variant?: 'debug' | 'release';
 }
 
-export interface HarmonyRunResult {
+export interface HarmonyRunResult extends NativeBuildResult {
   bundleName: string;
   device: { id: string; transport: string };
-  export: null | { assetCount: number; bundleSha256: string; sourceMapSha256: string };
-  hapPath: string;
   installed: boolean;
   launched: true;
   metro: { owner: 'disabled' | 'existing' | 'started'; port: number };
@@ -62,7 +47,6 @@ export interface HarmonyRunResult {
 }
 
 interface HarmonyRunSessionOptions extends HarmonyRunOptions {
-  /** Give a CLI-started Metro process ownership of the current terminal. */
   interactiveBundler?: boolean;
 }
 
@@ -76,8 +60,8 @@ interface HarmonyRunSession {
   result: HarmonyRunResult;
 }
 
-type NormalizedRunOptions = Required<Omit<HarmonyRunSessionOptions, 'appId' | 'device'>>
-  & Pick<HarmonyRunSessionOptions, 'appId' | 'device'>;
+type NormalizedRunOptions = Required<Omit<HarmonyRunSessionOptions, 'appId' | 'device' | 'privateKeyPath'>>
+  & Pick<HarmonyRunSessionOptions, 'appId' | 'device' | 'privateKeyPath'>;
 
 const BundleName = /^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*){2,}$/u;
 
@@ -101,10 +85,10 @@ function resolveRunIdentity(plan: HarmonyBuildPlan, options: NormalizedRunOption
 }
 
 async function runHarmonyUnlockedAsync(
-  projectRoot: string,
+  root: string,
   options: HarmonyRunSessionOptions = {}
 ): Promise<HarmonyRunSession> {
-  const normalizedOptions: NormalizedRunOptions = {
+  const settings: NormalizedRunOptions = {
     appId: options.appId,
     device: options.device,
     interactiveBundler: Boolean(options.interactiveBundler),
@@ -112,108 +96,60 @@ async function runHarmonyUnlockedAsync(
     noBundler: Boolean(options.noBundler),
     noInstall: Boolean(options.noInstall),
     port: options.port || 8081,
+    privateKeyPath: options.privateKeyPath,
     resetCache: Boolean(options.resetCache),
     sync: Boolean(options.sync),
     variant: options.variant || 'debug',
   };
   const steps: Record<string, number> = {};
 
-  await ensureGeneratedProjectAsync(projectRoot, normalizedOptions, steps);
+  const plan = await prepareNativeProjectAsync(root, {
+    ...settings,
+    check: false,
+  }, steps);
 
-  const plan = await timed(steps, 'buildPlan', () => resolveHarmonyBuildPlanAsync(
-    projectRoot,
-    { buildMode: normalizedOptions.variant }
-  ));
-  const identity = resolveRunIdentity(plan, normalizedOptions);
-  const toolchain = resolveHarmonyToolchain();
+  const identity = resolveRunIdentity(plan, settings);
+  const tools = resolveHarmonyToolchain();
 
-  progress(normalizedOptions, 'Selecting a Harmony device or emulator');
-  const device = await timed(steps, 'device', () => selectDeviceAsync(
-    toolchain.hdc,
-    normalizedOptions.device,
+  progress(settings, 'Selecting a Harmony device or emulator');
+  const device = await timedAsync(steps, 'device', () => selectDeviceAsync(
+    tools.hdc,
+    settings.device,
     {
       cwd: plan.harmonyRoot,
-      emulator: resolveHarmonyEmulator(toolchain),
-      emulatorLogFile: path.join(projectRoot, '.expo', 'harmony', 'emulator.log'),
-      onProgress: message => progress(normalizedOptions, message),
+      emulator: resolveHarmonyEmulator(tools),
+      emulatorLogFile: path.join(root, '.expo', 'harmony', 'emulator.log'),
+      onProgress: message => progress(settings, message),
     }
   ));
 
-  let exportManifest: HarmonyExportManifest | null = null;
-  if (normalizedOptions.variant === 'release') {
-    progress(normalizedOptions, 'Exporting the release Hermes bundle');
-    exportManifest = await timed(steps, 'export', () => exportEmbedAsync(
-      projectRoot,
-      { resetCache: normalizedOptions.resetCache, skipDoctor: true }
-    ));
-  } else {
-    steps.export = 0;
-  }
-
-  progress(normalizedOptions, 'Installing Harmony project dependencies');
-  await timed(steps, 'ohpm', () => installHarmonyDependenciesAsync(plan, toolchain));
+  const built = await buildNativeAsync(root, plan, tools, settings, steps);
 
   let metro: HarmonyRunSession['metro'] = {
     owner: 'disabled',
-    port: normalizedOptions.port,
+    port: settings.port,
     stop: async () => {},
     waitAsync: async () => {},
   };
-  try {
-    progress(normalizedOptions, 'Checking Harmony native dependency cache');
-    const nativeBuildCache = await timed(steps, 'nativeCache', () => (
-      prepareHarmonyNativeBuildCacheAsync(projectRoot, plan)
-    ));
 
-    if (nativeBuildCache.changed) {
-      progress(normalizedOptions, 'Invalidated stale Harmony native build objects');
-    }
-
-    progress(normalizedOptions, `Building the ${normalizedOptions.variant} HAP`);
-    const buildEnv = {
-      ...process.env,
-      EXPO_HARMONY_NODE: process.env.EXPO_HARMONY_NODE || process.execPath,
-      EXPO_METRO_TARGET: 'harmony',
-      HERMES_V1_ENABLED: 'true',
-      ...(normalizedOptions.variant === 'release' ? { EXPO_HARMONY_BUNDLE_PREBUILT: '1' } : {}),
-      ...(toolchain.sdkHome && !process.env.DEVECO_SDK_HOME
-        ? { DEVECO_SDK_HOME: toolchain.sdkHome }
-        : {}),
-    };
-    await timed(steps, 'build', () => runCheckedAsync(toolchain.hvigor.command, [
-      ...toolchain.hvigor.args,
-      ...plan.hvigorArgs,
-    ], {
-      code: 'ERR_HARMONY_BUILD_FAILED',
-      cwd: plan.harmonyRoot,
-      env: buildEnv,
-      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 timed(steps, 'nativeCacheCommit', () => commitHarmonyNativeBuildCacheAsync(nativeBuildCache));
-
-    if (normalizedOptions.variant === 'debug') {
-      progress(normalizedOptions, normalizedOptions.noBundler
+  try {
+    if (settings.variant === 'debug' && getConfig(root).exp.updates?.useNativeDebug !== true) {
+      progress(settings, settings.noBundler
         ? 'Connecting to the existing Expo Metro server'
         : 'Starting Expo Metro');
-      metro = await timed(steps, 'metro', () => normalizedOptions.noBundler
-        ? requireExistingMetroAsync(normalizedOptions.port)
-        : startExpoMetroAsync(projectRoot, {
-            interactive: normalizedOptions.interactiveBundler,
-            port: normalizedOptions.port,
-            resetCache: normalizedOptions.resetCache,
+      metro = await timedAsync(steps, 'metro', () => settings.noBundler
+        ? requireExistingMetroAsync(settings.port)
+        : startExpoMetroAsync(root, {
+            interactive: settings.interactiveBundler,
+            port: settings.port,
+            privateKeyPath: settings.privateKeyPath,
+            resetCache: settings.resetCache,
           }));
 
-      await timed(steps, 'metroPort', () => configureMetroPortAsync(
-        toolchain.hdc,
+      await timedAsync(steps, 'metroPort', () => configureMetroPortAsync(
+        tools.hdc,
         device,
-        normalizedOptions.port,
+        settings.port,
         { cwd: plan.harmonyRoot }
       ));
     } else {
@@ -221,21 +157,21 @@ async function runHarmonyUnlockedAsync(
       steps.metroPort = 0;
     }
 
-    if (normalizedOptions.noInstall) {
+    if (settings.noInstall) {
       steps.install = 0;
     } else {
-      progress(normalizedOptions, `Installing the HAP on ${device.id}`);
-      await timed(steps, 'install', () => installHapAsync(
-        toolchain.hdc,
+      progress(settings, `Installing the HAP on ${device.id}`);
+      await timedAsync(steps, 'install', () => installHapAsync(
+        tools.hdc,
         device,
         plan.expectedHap,
         { cwd: plan.harmonyRoot }
       ));
     }
 
-    progress(normalizedOptions, `Launching ${identity.bundleName}`);
-    await timed(steps, 'launch', () => launchAppAsync(
-      toolchain.hdc,
+    progress(settings, `Launching ${identity.bundleName}`);
+    await timedAsync(steps, 'launch', () => launchAppAsync(
+      tools.hdc,
       device,
       identity.bundleName,
       identity.abilityName,
@@ -248,15 +184,8 @@ async function runHarmonyUnlockedAsync(
         id: device.id,
         transport: device.transport,
       },
-      export: exportManifest
-        ? {
-            assetCount: exportManifest.assets.length,
-            bundleSha256: exportManifest.bundle.sha256,
-            sourceMapSha256: exportManifest.sourceMap.sha256,
-          }
-        : null,
-      hapPath: toPosixPath(path.relative(projectRoot, plan.expectedHap)),
-      installed: !normalizedOptions.noInstall,
+      ...built,
+      installed: !settings.noInstall,
       launched: true,
       metro: {
         owner: metro.owner,
@@ -265,32 +194,37 @@ async function runHarmonyUnlockedAsync(
       ok: true,
       schemaVersion: 1,
       steps,
-      variant: normalizedOptions.variant,
+      variant: settings.variant,
     };
 
     return { metro, result };
   } catch (error) {
     await metro.stop();
-    throw error;
+
+    throw new HarmonyCliError(error?.code || 'ERR_HARMONY_UNKNOWN', error?.message || 'Harmony run failed.', {
+      cause: error,
+      exitCode: error?.exitCode,
+      operation: error?.operation,
+    });
   }
 }
 
 async function runHarmonySessionAsync(
-  projectRoot: string,
+  root: string,
   options: HarmonyRunSessionOptions = {}
 ): Promise<HarmonyRunSession> {
   return withHarmonyProjectLockAsync(
-    projectRoot,
+    root,
     'run',
-    () => runHarmonyUnlockedAsync(projectRoot, options)
+    () => runHarmonyUnlockedAsync(root, options)
   );
 }
 
 async function runHarmonyAsync(
-  projectRoot: string,
+  root: string,
   options: HarmonyRunOptions = {}
 ): Promise<HarmonyRunResult> {
-  const session = await runHarmonySessionAsync(projectRoot, options);
+  const session = await runHarmonySessionAsync(root, options);
 
   try {
     return session.result;

package/src/runtime/config.ts

@@ -0,0 +1,150 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+import { getConfig } from '@expo/config';
+import { compileHarmonyModsAsync, normalizeHarmonyConfig, type ExpoConfigWithHarmony } from '@expo-harmony/config-plugins';
+import { withHarmonyPrebuildConfig } from '@expo-harmony/prebuild-config';
+import type { HarmonyRuntimeContract } from '@expo-harmony/expo-modules-autolinking/runtime';
+import JSON5 from 'json5';
+
+import { fingerprintHarmonyAsync } from './fingerprint';
+import { HarmonyCliError } from '../errors';
+import { resolveHarmonyBuildPlanAsync } from '../native/project';
+import type { HarmonyBuildPlan } from '../native/types';
+
+export interface HarmonyMetroRuntime {
+  reactPackage: string;
+  harmonyPackage: string;
+  fixedRuntime: boolean;
+}
+
+export async function resolveRuntimeVersionAsync(root: string, config: ExpoConfigWithHarmony, app): Promise<string> {
+  if (typeof config.runtimeVersion === 'object' && config.runtimeVersion?.policy === 'nativeVersion') {
+    if (typeof app?.versionName !== 'string' || !app.versionName
+      || !Number.isSafeInteger(app.versionCode) || app.versionCode < 1) {
+      throw new HarmonyCliError(
+        'ERR_HARMONY_RUNTIME_CONFIG',
+        'The nativeVersion policy requires a Harmony versionName and a positive versionCode.',
+        { operation: 'runtime-contract' }
+      );
+    }
+
+    return `${app.versionName}(${app.versionCode})`;
+  }
+
+  if (typeof config.runtimeVersion === 'object' && config.runtimeVersion?.policy === 'fingerprint') {
+    return (await fingerprintHarmonyAsync(root)).hash;
+  }
+
+  const require = createRequire(path.join(root, 'package.json'));
+  const expo = createRequire(require.resolve('expo/package.json'));
+  const { getRuntimeVersionAsync } = expo('@expo/config-plugins/build/utils/Updates');
+  const version = await getRuntimeVersionAsync(root, {
+    ...config,
+    runtimeVersion: config.runtimeVersion ?? { policy: 'sdkVersion' },
+  }, 'harmony');
+
+  if (typeof version !== 'string' || !version) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_RUNTIME_CONFIG',
+      'Cannot resolve expo.runtimeVersion for Harmony.',
+      { operation: 'runtime-contract' }
+    );
+  }
+
+  return version;
+}
+
+export async function readMetroRuntimeAsync(root: string): Promise<HarmonyMetroRuntime | undefined> {
+  const require = createRequire(path.join(root, 'package.json'));
+  const previous = process.env.EXPO_METRO_TARGET;
+  let config;
+
+  try {
+    process.env.EXPO_METRO_TARGET = 'harmony';
+    config = (await require('metro-config').resolveConfig(undefined, root)).config;
+  } finally {
+    if (previous === undefined) delete process.env.EXPO_METRO_TARGET;
+    else process.env.EXPO_METRO_TARGET = previous;
+  }
+
+  return config?.resolver?.resolveRequest?.harmonyRuntime;
+}
+
+function nativeConfig(profile, module, build, product: string, ability: string): HarmonyRuntimeContract['config'] {
+  const selected = profile?.app?.products?.find(item => item.name === product);
+  const entry = module?.abilities?.find(item => item.name === ability);
+  if (!selected || !entry || !build
+    || /(?:USE_HERMES|HERMES_V1_ENABLED)(?::BOOL)?=(?:OFF|FALSE|0)/i.test(build.buildOption?.externalNativeOptions?.arguments || '')
+    || Object.keys(selected.buildOption || {}).some(key => key !== 'nativeCompiler')
+    || profile.app.buildModeSet?.some(mode => mode.buildOption)
+    || build.buildOptionSet?.length || build.targets?.some(target => target.buildOption)) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_RUNTIME_CONFIG',
+      'Runtime contracts require an existing Harmony product and ability, Hermes v1, and native options without per-target or per-mode overrides.',
+      { operation: 'runtime-contract' }
+    );
+  }
+
+  const api = (value: unknown) => typeof value === 'number' ? value : Number(/\((\d+)\)$/.exec(String(value))?.[1] ?? value);
+
+  return {
+    nativeCompiler: selected.buildOption?.nativeCompiler,
+    targetApiVersion: api(selected.targetSdkVersion),
+    compatibleApiVersion: api(selected.compatibleSdkVersion),
+    permissions: [...new Set<string>((module.requestPermissions || []).map(item => item.name))].sort(),
+    querySchemes: [...new Set<string>(module.querySchemes || [])].sort(),
+    backgroundModes: [...new Set<string>(entry.backgroundModes || [])].sort(),
+    abiFilters: [...(build.buildOption?.externalNativeOptions?.abiFilters || [])].sort(),
+  };
+}
+
+export function readNativeRuntime(plan: HarmonyBuildPlan) {
+  const read = (file: string) => JSON5.parse(fs.readFileSync(file, 'utf8'));
+  const app = read(path.join(plan.harmonyRoot, 'AppScope/app.json5')).app;
+  const profile = read(plan.projectFiles.projectBuildProfile);
+  const module = read(plan.projectFiles.moduleJson).module;
+  const build = read(path.join(plan.moduleRoot, 'build-profile.json5'));
+
+  return { app, config: nativeConfig(profile, module, build, plan.productName, plan.abilityName) };
+}
+
+export async function readProjectRuntimeAsync(root: string) {
+  const { exp } = getConfig(root, { skipSDKVersionRequirement: true, isModdedConfig: true });
+  const config = exp as ExpoConfigWithHarmony;
+  let native: ReturnType<typeof readNativeRuntime>;
+  let bundle: string;
+
+  if (config.harmony) {
+    const settings = normalizeHarmonyConfig(config);
+    const evaluated = await compileHarmonyModsAsync(withHarmonyPrebuildConfig(config), {
+      projectRoot: root,
+      introspect: true,
+      ignoreExistingNativeFiles: true,
+    });
+    const results = evaluated._internal?.modResults?.harmony;
+    native = {
+      app: results?.appJson?.app,
+      config: nativeConfig(
+        results?.projectBuildProfile,
+        results?.moduleJson?.module,
+        results?.entryBuildProfile,
+        settings.productName,
+        settings.abilityName
+      ),
+    };
+    bundle = settings.bundleName;
+  } else {
+    const plan = await resolveHarmonyBuildPlanAsync(root);
+    native = readNativeRuntime(plan);
+    bundle = plan.bundleName;
+  }
+
+  return {
+    config,
+    bundleName: bundle,
+    native: native.config,
+    runtimeVersion: await resolveRuntimeVersionAsync(root, config, native.app),
+  };
+}