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

package/build/run/run.d.ts

@@ -1,4 +1,5 @@
 import { type MetroSession } from './metro';
+import { type NativeBuildResult } from '../native/build';
 export interface HarmonyRunOptions {
     appId?: string;
     device?: string;
@@ -10,18 +11,12 @@ export interface HarmonyRunOptions {
     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: {
@@ -34,7 +29,6 @@ export interface HarmonyRunResult {
     variant: 'debug' | 'release';
 }
 interface HarmonyRunSessionOptions extends HarmonyRunOptions {
-    /** Give a CLI-started Metro process ownership of the current terminal. */
     interactiveBundler?: boolean;
 }
 interface HarmonyRunSession {
@@ -46,6 +40,6 @@ interface HarmonyRunSession {
     };
     result: HarmonyRunResult;
 }
-declare function runHarmonySessionAsync(projectRoot: string, options?: HarmonyRunSessionOptions): Promise<HarmonyRunSession>;
-declare function runHarmonyAsync(projectRoot: string, options?: HarmonyRunOptions): Promise<HarmonyRunResult>;
+declare function runHarmonySessionAsync(root: string, options?: HarmonyRunSessionOptions): Promise<HarmonyRunSession>;
+declare function runHarmonyAsync(root: string, options?: HarmonyRunOptions): Promise<HarmonyRunResult>;
 export { runHarmonyAsync, runHarmonySessionAsync };

package/build/run/run.js

@@ -8,14 +8,13 @@ exports.runHarmonySessionAsync = runHarmonySessionAsync;
 const node_path_1 = __importDefault(require("node:path"));
 const devices_1 = require("./devices");
 const errors_1 = require("../errors");
-const export_1 = require("../exportEmbed/export");
-const tools_1 = require("../tools");
-const install_1 = require("./install");
+const toolchain_1 = require("../native/toolchain");
 const metro_1 = require("./metro");
-const cache_1 = require("./cache");
-const path_1 = require("../path");
 const projectLock_1 = require("../projectLock");
-const common_1 = require("../buildHap/common");
+const build_1 = require("../native/build");
+const prepareProject_1 = require("../native/prepareProject");
+const log_1 = require("../log");
+const profile_1 = require("../profile");
 const BundleName = /^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*){2,}$/u;
 function resolveRunIdentity(plan, options) {
     if (options.appId && !BundleName.test(options.appId)) {
@@ -29,8 +28,8 @@ function resolveRunIdentity(plan, options) {
         bundleName: options.appId || plan.bundleName,
     };
 }
-async function runHarmonyUnlockedAsync(projectRoot, options = {}) {
-    const normalizedOptions = {
+async function runHarmonyUnlockedAsync(root, options = {}) {
+    const settings = {
         appId: options.appId,
         device: options.device,
         interactiveBundler: Boolean(options.interactiveBundler),
@@ -43,109 +42,61 @@ async function runHarmonyUnlockedAsync(projectRoot, options = {}) {
         variant: options.variant || 'debug',
     };
     const steps = {};
-    await (0, common_1.ensureGeneratedProjectAsync)(projectRoot, {
-        ...normalizedOptions,
-        skipGeneratedProjectCheck: true,
+    const plan = await (0, prepareProject_1.prepareNativeProjectAsync)(root, {
+        ...settings,
+        check: false,
     }, steps);
-    const plan = await (0, common_1.timed)(steps, 'buildPlan', () => (0, tools_1.resolveHarmonyBuildPlanAsync)(projectRoot, { buildMode: normalizedOptions.variant }));
-    const identity = resolveRunIdentity(plan, normalizedOptions);
-    const toolchain = (0, tools_1.resolveHarmonyToolchain)();
-    (0, common_1.progress)(normalizedOptions, 'Selecting a Harmony device or emulator');
-    const device = await (0, common_1.timed)(steps, 'device', () => (0, devices_1.selectDeviceAsync)(toolchain.hdc, normalizedOptions.device, {
+    const identity = resolveRunIdentity(plan, settings);
+    const tools = (0, toolchain_1.resolveHarmonyToolchain)();
+    (0, log_1.progress)(settings, 'Selecting a Harmony device or emulator');
+    const device = await (0, profile_1.timedAsync)(steps, 'device', () => (0, devices_1.selectDeviceAsync)(tools.hdc, settings.device, {
         cwd: plan.harmonyRoot,
-        emulator: (0, tools_1.resolveHarmonyEmulator)(toolchain),
-        emulatorLogFile: node_path_1.default.join(projectRoot, '.expo', 'harmony', 'emulator.log'),
-        onProgress: message => (0, common_1.progress)(normalizedOptions, message),
+        emulator: (0, toolchain_1.resolveHarmonyEmulator)(tools),
+        emulatorLogFile: node_path_1.default.join(root, '.expo', 'harmony', 'emulator.log'),
+        onProgress: message => (0, log_1.progress)(settings, message),
     }));
-    let exportManifest = null;
-    if (normalizedOptions.variant === 'release') {
-        (0, common_1.progress)(normalizedOptions, 'Exporting the release Hermes bundle');
-        exportManifest = await (0, common_1.timed)(steps, 'export', () => (0, export_1.exportEmbedAsync)(projectRoot, { resetCache: normalizedOptions.resetCache, skipDoctor: true }));
-    }
-    else {
-        steps.export = 0;
-    }
-    (0, common_1.progress)(normalizedOptions, 'Installing Harmony project dependencies');
-    await (0, common_1.timed)(steps, 'ohpm', () => (0, install_1.installHarmonyDependenciesAsync)(plan, toolchain));
+    const built = await (0, build_1.buildNativeAsync)(root, plan, tools, settings, steps);
     let metro = {
         owner: 'disabled',
-        port: normalizedOptions.port,
+        port: settings.port,
         stop: async () => { },
         waitAsync: async () => { },
     };
     try {
-        (0, common_1.progress)(normalizedOptions, 'Checking Harmony native dependency cache');
-        const nativeBuildCache = await (0, common_1.timed)(steps, 'nativeCache', () => ((0, cache_1.prepareHarmonyNativeBuildCacheAsync)(projectRoot, plan)));
-        if (nativeBuildCache.changed) {
-            (0, common_1.progress)(normalizedOptions, 'Invalidated stale Harmony native build objects');
-        }
-        (0, common_1.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 (0, common_1.timed)(steps, 'build', () => (0, common_1.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 (!(0, common_1.isNonEmptyRegularFile)(plan.expectedHap)) {
-            throw new errors_1.HarmonyCliError('ERR_HARMONY_HAP_MISSING', 'Hvigor completed without producing the expected non-empty regular HAP.', { operation: 'verify-hap' });
-        }
-        await (0, common_1.timed)(steps, 'nativeCacheCommit', () => (0, cache_1.commitHarmonyNativeBuildCacheAsync)(nativeBuildCache));
-        if (normalizedOptions.variant === 'debug') {
-            (0, common_1.progress)(normalizedOptions, normalizedOptions.noBundler
+        if (settings.variant === 'debug') {
+            (0, log_1.progress)(settings, settings.noBundler
                 ? 'Connecting to the existing Expo Metro server'
                 : 'Starting Expo Metro');
-            metro = await (0, common_1.timed)(steps, 'metro', () => normalizedOptions.noBundler
-                ? (0, metro_1.requireExistingMetroAsync)(normalizedOptions.port)
-                : (0, metro_1.startExpoMetroAsync)(projectRoot, {
-                    interactive: normalizedOptions.interactiveBundler,
-                    port: normalizedOptions.port,
-                    resetCache: normalizedOptions.resetCache,
+            metro = await (0, profile_1.timedAsync)(steps, 'metro', () => settings.noBundler
+                ? (0, metro_1.requireExistingMetroAsync)(settings.port)
+                : (0, metro_1.startExpoMetroAsync)(root, {
+                    interactive: settings.interactiveBundler,
+                    port: settings.port,
+                    resetCache: settings.resetCache,
                 }));
-            await (0, common_1.timed)(steps, 'metroPort', () => (0, devices_1.configureMetroPortAsync)(toolchain.hdc, device, normalizedOptions.port, { cwd: plan.harmonyRoot }));
+            await (0, profile_1.timedAsync)(steps, 'metroPort', () => (0, devices_1.configureMetroPortAsync)(tools.hdc, device, settings.port, { cwd: plan.harmonyRoot }));
         }
         else {
             steps.metro = 0;
             steps.metroPort = 0;
         }
-        if (normalizedOptions.noInstall) {
+        if (settings.noInstall) {
             steps.install = 0;
         }
         else {
-            (0, common_1.progress)(normalizedOptions, `Installing the HAP on ${device.id}`);
-            await (0, common_1.timed)(steps, 'install', () => (0, devices_1.installHapAsync)(toolchain.hdc, device, plan.expectedHap, { cwd: plan.harmonyRoot }));
+            (0, log_1.progress)(settings, `Installing the HAP on ${device.id}`);
+            await (0, profile_1.timedAsync)(steps, 'install', () => (0, devices_1.installHapAsync)(tools.hdc, device, plan.expectedHap, { cwd: plan.harmonyRoot }));
         }
-        (0, common_1.progress)(normalizedOptions, `Launching ${identity.bundleName}`);
-        await (0, common_1.timed)(steps, 'launch', () => (0, devices_1.launchAppAsync)(toolchain.hdc, device, identity.bundleName, identity.abilityName, { cwd: plan.harmonyRoot }));
+        (0, log_1.progress)(settings, `Launching ${identity.bundleName}`);
+        await (0, profile_1.timedAsync)(steps, 'launch', () => (0, devices_1.launchAppAsync)(tools.hdc, device, identity.bundleName, identity.abilityName, { cwd: plan.harmonyRoot }));
         const result = {
             bundleName: identity.bundleName,
             device: {
                 id: device.id,
                 transport: device.transport,
             },
-            export: exportManifest
-                ? {
-                    assetCount: exportManifest.assets.length,
-                    bundleSha256: exportManifest.bundle.sha256,
-                    sourceMapSha256: exportManifest.sourceMap.sha256,
-                }
-                : null,
-            hapPath: (0, path_1.toPosixPath)(node_path_1.default.relative(projectRoot, plan.expectedHap)),
-            installed: !normalizedOptions.noInstall,
+            ...built,
+            installed: !settings.noInstall,
             launched: true,
             metro: {
                 owner: metro.owner,
@@ -154,20 +105,24 @@ async function runHarmonyUnlockedAsync(projectRoot, options = {}) {
             ok: true,
             schemaVersion: 1,
             steps,
-            variant: normalizedOptions.variant,
+            variant: settings.variant,
         };
         return { metro, result };
     }
     catch (error) {
         await metro.stop();
-        throw error;
+        throw new errors_1.HarmonyCliError(error?.code || 'ERR_HARMONY_UNKNOWN', error?.message || 'Harmony run failed.', {
+            cause: error,
+            exitCode: error?.exitCode,
+            operation: error?.operation,
+        });
     }
 }
-async function runHarmonySessionAsync(projectRoot, options = {}) {
-    return (0, projectLock_1.withHarmonyProjectLockAsync)(projectRoot, 'run', () => runHarmonyUnlockedAsync(projectRoot, options));
+async function runHarmonySessionAsync(root, options = {}) {
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(root, 'run', () => runHarmonyUnlockedAsync(root, options));
 }
-async function runHarmonyAsync(projectRoot, options = {}) {
-    const session = await runHarmonySessionAsync(projectRoot, options);
+async function runHarmonyAsync(root, options = {}) {
+    const session = await runHarmonySessionAsync(root, options);
     try {
         return session.result;
     }

package/build/start/index.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from '../command';
+export declare const command: Command;

package/build/start/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const options_1 = require("./options");
+const command = async (argv, io) => {
+    const args = (0, command_1.parseCommandArgs)(options_1.parseStartArgs, argv, io);
+    if (!args)
+        return 0;
+    const { projectRoot: root, options } = args;
+    const { startExpoMetroAsync } = await import('../run/metro.js');
+    const metro = await startExpoMetroAsync(root, {
+        ...options,
+        interactive: true,
+    });
+    try {
+        if (metro.owner === 'existing') {
+            io.log(`Expo Metro is already running on port ${metro.port}.`);
+            if (options.resetCache) {
+                io.warn('Stop the existing Metro server and run this command again to reset its cache.');
+            }
+        }
+        else {
+            io.log('\n› Logs for your project will appear below. Press Ctrl+C to exit.');
+            await metro.waitAsync();
+        }
+        return 0;
+    }
+    finally {
+        await metro.stop();
+    }
+};
+exports.command = command;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo-harmony/cli",
-  "version": "55.0.26-harmony.8",
+  "version": "55.0.26-harmony.9",
   "keywords": [
     "react-native",
     "expo",
@@ -30,15 +30,25 @@
       "require": "./build/index.js",
       "default": "./build/index.js"
     },
-    "./bin/expo-harmony": "./build/bin/expo-harmony.js"
+    "./bin/expo-harmony": "./build/bin/expo-harmony.js",
+    "./native-build": {
+      "types": "./build/native/hvigor.d.ts",
+      "require": "./build/native/hvigor.js",
+      "default": "./build/native/hvigor.js"
+    },
+    "./internal/prebuild": {
+      "types": "./build/internal/prebuild.d.ts",
+      "require": "./build/internal/prebuild.js",
+      "default": "./build/internal/prebuild.js"
+    }
   },
   "bin": {
     "expo-harmony": "build/bin/expo-harmony.js"
   },
   "dependencies": {
-    "@expo-harmony/config-plugins": "55.0.10-harmony.2",
+    "@expo-harmony/config-plugins": "55.0.10-harmony.3",
     "@expo-harmony/expo-modules-autolinking": "55.0.25-harmony.3",
-    "@expo-harmony/prebuild-config": "55.0.0-harmony.6",
+    "@expo-harmony/prebuild-config": "55.0.0-harmony.7",
     "@expo/config": "55.0.17",
     "cross-spawn": "^7.0.6",
     "json5": "2.2.3"

package/src/bin/expo-harmony.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
 
-import { main } from '../cli';
+import { mainAsync } from '../cli';
 
-main();
+mainAsync();

package/src/buildHap/build.ts

@@ -1,39 +1,16 @@
-import path from 'node:path';
-
-import { HarmonyCliError } from '../errors';
-import { exportEmbedAsync } from '../exportEmbed/export';
-import type { HarmonyExportManifest } from '../exportEmbed/manifest';
-import { toPosixPath } from '../path';
 import { withHarmonyProjectLockAsync } from '../projectLock';
-import {
-  commitHarmonyNativeBuildCacheAsync,
-  prepareHarmonyNativeBuildCacheAsync,
-} from '../run/cache';
-import { installHarmonyDependenciesAsync } from '../run/install';
-import {
-  resolveHarmonyBuildPlanAsync,
-  resolveHarmonyToolchain,
-} from '../tools';
-import {
-  ensureGeneratedProjectAsync,
-  isNonEmptyRegularFile,
-  progress,
-  runCheckedAsync,
-  timed,
-} from './common';
+import { buildNativeAsync, type NativeBuildResult } from '../native/build';
+import { prepareNativeProjectAsync } from '../native/prepareProject';
+import { resolveHarmonyToolchain } from '../native/toolchain';
 
 export interface HarmonyBuildOptions {
   io?: Pick<Console, 'error' | 'log' | 'warn'>;
-  /** @internal For release verification after a successful isolated prebuild check. */
-  skipGeneratedProjectCheck?: boolean;
   sync?: boolean;
   variant?: 'debug' | 'release';
 }
 
-export interface HarmonyBuildResult {
+export interface HarmonyBuildResult extends NativeBuildResult {
   bundleName: string;
-  export: null | { assetCount: number; bundleSha256: string; sourceMapSha256: string };
-  hapPath: string;
   headless: true;
   installed: false;
   launched: false;
@@ -48,13 +25,12 @@ type NormalizedBuildOptions = Required<HarmonyBuildOptions> & {
 };
 
 async function buildHarmonyUnlockedAsync(
-  projectRoot: string,
+  root: string,
   options: HarmonyBuildOptions = {}
 ): Promise<HarmonyBuildResult> {
-  const normalizedOptions: NormalizedBuildOptions = {
+  const settings: NormalizedBuildOptions = {
     io: options.io || console,
     requireDeviceTools: false,
-    skipGeneratedProjectCheck: Boolean(options.skipGeneratedProjectCheck),
     sync: Boolean(options.sync),
     variant: options.variant || 'debug',
   };
@@ -66,98 +42,30 @@ async function buildHarmonyUnlockedAsync(
     metroPort: 0,
   };
 
-  await ensureGeneratedProjectAsync(projectRoot, normalizedOptions, steps);
-
-  const plan = await timed(steps, 'buildPlan', () => resolveHarmonyBuildPlanAsync(
-    projectRoot,
-    { buildMode: normalizedOptions.variant }
-  ));
-  const toolchain = resolveHarmonyToolchain();
-
-  let exportManifest: HarmonyExportManifest | null = null;
-  if (normalizedOptions.variant === 'release') {
-    progress(normalizedOptions, 'Exporting the release Hermes bundle');
-    exportManifest = await timed(steps, 'export', () => exportEmbedAsync(
-      projectRoot,
-      { skipDoctor: true }
-    ));
-  } else {
-    steps.export = 0;
-  }
-
-  progress(normalizedOptions, 'Installing Harmony project dependencies');
-  await timed(steps, 'ohpm', () => installHarmonyDependenciesAsync(plan, toolchain));
-
-  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 without a device`);
-  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));
+  const plan = await prepareNativeProjectAsync(root, settings, steps);
+  const built = await buildNativeAsync(root, plan, resolveHarmonyToolchain(), settings, steps);
 
   return {
     bundleName: plan.bundleName,
-    export: exportManifest
-      ? {
-          assetCount: exportManifest.assets.length,
-          bundleSha256: exportManifest.bundle.sha256,
-          sourceMapSha256: exportManifest.sourceMap.sha256,
-        }
-      : null,
-    hapPath: toPosixPath(path.relative(projectRoot, plan.expectedHap)),
+    ...built,
     headless: true,
     installed: false,
     launched: false,
     ok: true,
     schemaVersion: 1,
     steps,
-    variant: normalizedOptions.variant,
+    variant: settings.variant,
   };
 }
 
 async function buildHarmonyAsync(
-  projectRoot: string,
+  root: string,
   options: HarmonyBuildOptions = {}
 ): Promise<HarmonyBuildResult> {
   return withHarmonyProjectLockAsync(
-    projectRoot,
+    root,
     'build',
-    () => buildHarmonyUnlockedAsync(projectRoot, options)
+    () => buildHarmonyUnlockedAsync(root, options)
   );
 }
 

package/src/buildHap/index.ts

@@ -0,0 +1,19 @@
+import { parseCommandArgs, type Command } from '../command';
+import { parseBuildArgs } from './options';
+
+export const command: Command = async (argv, io) => {
+  const args = parseCommandArgs(parseBuildArgs, argv, io);
+  if (!args) return 0;
+
+  const { projectRoot: root, options } = args;
+  const { buildHarmonyAsync } = await import('./build.js');
+
+  const result = await buildHarmonyAsync(root, {
+    ...options,
+    io,
+  });
+
+  io.log(`Built ${result.variant} HAP at ${result.hapPath}; no device actions were performed.`);
+
+  return 0;
+};