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

package/build/{tools.js → native/toolchain.js}

@@ -4,16 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHarmonyToolchainEnv = createHarmonyToolchainEnv;
-exports.resolveHarmonyBuildPlanAsync = resolveHarmonyBuildPlanAsync;
-exports.resolveHarmonyBuildPlanIfPresentAsync = resolveHarmonyBuildPlanIfPresentAsync;
 exports.resolveHarmonyEmulator = resolveHarmonyEmulator;
 exports.resolveHarmonyToolchain = resolveHarmonyToolchain;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const tool_command_1 = require("@expo-harmony/expo-modules-autolinking/tool-command");
-const build_descriptor_1 = require("@expo-harmony/prebuild-config/build-descriptor");
-const check_1 = require("@expo-harmony/prebuild-config/check");
-const errors_1 = require("./errors");
 function existingFile(candidates) {
     return candidates.find(candidate => node_fs_1.default.existsSync(candidate)) || null;
 }
@@ -93,9 +88,7 @@ function devEcoNode(layout, platform, env) {
 function resolveHarmonyToolchain() {
     const env = process.env;
     const platform = process.platform;
-    // Hvigor expects the SDK root containing default/, not default/ itself.
-    // Reject metadata-only candidates so doctor cannot claim an SDK is
-    // buildable without its HMS, OpenHarmony, native, ETS, and toolchain parts.
+    // Hvigor needs the complete SDK root containing default/, not default/ itself.
     const sdkHome = resolveHarmonySdkRoot(env, platform);
     const layouts = sdkHome ? devEcoLayouts(sdkHome) : [];
     let ohpm;
@@ -177,52 +170,3 @@ function resolveHarmonyEmulator(toolchain) {
         ? { args: [], command, source: 'deveco' }
         : { args: [], command: executable, source: 'path' };
 }
-function createHarmonyBuildPlan(projectRoot, build, mode) {
-    const resolve = relative => (0, build_descriptor_1.resolveHarmonyBuildPath)(projectRoot, relative);
-    const variant = build.variants[mode];
-    return {
-        abilityName: build.identity.abilityName,
-        buildMode: mode,
-        bundleName: build.identity.bundleName,
-        expectedHap: resolve(variant.expectedHap),
-        exportPaths: Object.fromEntries(Object.entries(build.export).map(([name, relative]) => [name, resolve(relative)])),
-        harmonyRoot: resolve(build.harmonyRoot),
-        hvigorArgs: [...variant.hvigorArgs],
-        moduleName: build.identity.moduleName,
-        moduleRoot: resolve(build.moduleRoot),
-        nativeCache: {
-            invalidationRoots: build.nativeCache.invalidationRoots.map(resolve),
-            stateFile: resolve(build.nativeCache.stateFile),
-        },
-        nativeInputs: {
-            lockfile: resolve(build.nativeInputs.lockfile),
-            manifest: resolve(build.nativeInputs.manifest),
-        },
-        productName: build.identity.productName,
-        projectFiles: Object.fromEntries(Object.entries(build.projectFiles).map(([name, relative]) => [name, resolve(relative)])),
-        targetName: build.identity.targetName,
-    };
-}
-async function resolveHarmonyBuildPlanIfPresentAsync(projectRoot, options = {}) {
-    const mode = options.buildMode || 'debug';
-    if (!['debug', 'release'].includes(mode)) {
-        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Harmony buildMode must be debug or release, received: ${mode}`, { operation: 'resolve-build' });
-    }
-    let manifest;
-    try {
-        manifest = await (0, check_1.readManifestIfPresentAsync)(projectRoot);
-    }
-    catch (cause) {
-        throw new errors_1.HarmonyCliError(cause.code || 'ERR_HARMONY_TEMPLATE_INVALID', `Cannot read the generated Harmony build descriptor: ${cause.message}`, { cause, operation: 'resolve-build' });
-    }
-    if (!manifest)
-        return null;
-    return createHarmonyBuildPlan(projectRoot, manifest.build, mode);
-}
-async function resolveHarmonyBuildPlanAsync(projectRoot, options = {}) {
-    const plan = await resolveHarmonyBuildPlanIfPresentAsync(projectRoot, options);
-    if (!plan) {
-        throw new errors_1.HarmonyCliError('ERR_HARMONY_MANIFEST_DRIFT', 'Cannot read the generated Harmony build descriptor because the CNG manifest is missing.', { operation: 'resolve-build' });
-    }
-    return plan;
-}

package/build/native/types.d.ts

@@ -0,0 +1,47 @@
+export type HarmonyBuildMode = 'debug' | 'release';
+interface NativeBuildPlan {
+    abilityName: string;
+    buildMode: HarmonyBuildMode;
+    bundleName: string;
+    expectedHap: string;
+    exportPaths: {
+        bundle: string;
+        manifest: string;
+        metadataRoot: string;
+        rawfileRoot: string;
+        sourceMap: string;
+    };
+    harmonyRoot: string;
+    hvigorArgs: string[];
+    moduleName: string;
+    moduleRoot: string;
+    nativeCache: {
+        invalidationRoots: string[];
+        stateFile: string;
+    };
+    nativeInputs: {
+        lockfile: string;
+        manifest: string;
+    };
+    projectFiles: {
+        hvigorConfig: string;
+        moduleHvigor: string;
+        moduleJson: string;
+        projectBuildProfile: string;
+        rootHvigor: string;
+    };
+    productName: string;
+    targetName: string;
+}
+export interface BareHarmonyBuildPlan extends NativeBuildPlan {
+    workflow: 'bare';
+}
+export interface CngHarmonyBuildPlan extends NativeBuildPlan {
+    workflow: 'cng';
+    projectFiles: NativeBuildPlan['projectFiles'] & {
+        nativeInputsStamp: string;
+        templateMarker: string;
+    };
+}
+export type HarmonyBuildPlan = BareHarmonyBuildPlan | CngHarmonyBuildPlan;
+export {};

package/build/native/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/prebuild/check.d.ts

@@ -1,6 +1,10 @@
-export type { Change as CheckChange } from '@expo-harmony/prebuild-config/check';
+export type { Change as CheckChange } from '@expo-harmony/prebuild-config/internal';
 interface CheckOptions {
     buildType?: 'debug' | 'release';
 }
-declare function checkAsync(project: any, options?: CheckOptions): Promise<import("@expo-harmony/prebuild-config/check").Result>;
-export { checkAsync };
+declare function withGeneratedProjectAsync<T>(project: string, options: CheckOptions & {
+    clean?: boolean;
+    skipPatches?: boolean;
+}, action: (expected: string, checksum: string) => Promise<T>): Promise<T>;
+declare function checkAsync(project: any, options?: CheckOptions): Promise<import("@expo-harmony/prebuild-config/internal").Result>;
+export { checkAsync, withGeneratedProjectAsync };

package/build/prebuild/check.js

@@ -4,19 +4,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkAsync = checkAsync;
+exports.withGeneratedProjectAsync = withGeneratedProjectAsync;
+const node_crypto_1 = require("node:crypto");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
-const check_1 = require("@expo-harmony/prebuild-config/check");
+const internal_1 = require("@expo-harmony/prebuild-config/internal");
 const errors_1 = require("../errors");
 const path_1 = require("../path");
 const process_1 = require("../process");
 const projectLock_1 = require("../projectLock");
-const tools_1 = require("../tools");
+const toolchain_1 = require("../native/toolchain");
+const project_1 = require("../native/project");
 const expo_1 = require("../expo");
 const template_1 = require("./template");
-const IgnoredProjectDirectories = new Set(['.expo', '.git', '.hvigor', '.yarn', 'node_modules']);
-const IgnoredHarmonyGeneratedDirectories = new Set([
+const IgnoredDirectories = new Set(['.expo', '.git', '.hvigor', '.yarn', 'node_modules']);
+const GeneratedDirectories = new Set([
     '.cxx',
     '.git',
     '.hvigor',
@@ -68,16 +71,18 @@ function shouldCopyPrebuildCheckPath(project, source, plan) {
     if (!relative)
         return true;
     const segments = relative.split(node_path_1.default.sep);
-    if (IgnoredProjectDirectories.has(segments[0]))
+    if (IgnoredDirectories.has(segments[0]))
         return false;
-    const nativeRoot = (0, path_1.isInside)(plan.harmonyRoot, source)
+    const root = (0, path_1.isInside)(plan.harmonyRoot, source)
         ? plan.harmonyRoot
         : isAppLocalHarmonyPath(project, source)
             ? node_path_1.default.join(project, ...segments.slice(0, 3))
             : null;
-    if (nativeRoot) {
-        const native = node_path_1.default.relative(nativeRoot, source).split(node_path_1.default.sep);
-        if (native.some(segment => IgnoredHarmonyGeneratedDirectories.has(segment)))
+    if (root) {
+        const native = node_path_1.default.relative(root, source).split(node_path_1.default.sep);
+        if (GeneratedDirectories.has(native[0])
+            || (GeneratedDirectories.has(native[1])
+                && node_fs_1.default.existsSync(node_path_1.default.join(root, native[0], 'src/main/module.json5'))))
             return false;
     }
     return source !== plan.exportPaths.bundle;
@@ -85,6 +90,7 @@ function shouldCopyPrebuildCheckPath(project, source, plan) {
 async function copyAsync(project, target, plan, temp = node_path_1.default.dirname(target)) {
     await node_fs_1.default.promises.cp(project, target, {
         recursive: true,
+        verbatimSymlinks: true,
         filter: source => shouldCopyPrebuildCheckPath(project, source, plan),
     });
     const modules = node_path_1.default.join(project, 'node_modules');
@@ -93,22 +99,20 @@ async function copyAsync(project, target, plan, temp = node_path_1.default.dirna
             operation: 'check',
         });
     }
-    // Keep a real node_modules directory in the isolated project and link its
-    // entries. Dependency scanners then retain the isolated lexical package path
-    // (including scoped packages) instead of collapsing the entire node_modules
-    // root to the source project's realpath. Package directories stay linked;
-    // Windows copies loose files to avoid requiring file-symlink privileges.
+    // Link individual packages so dependency scanners retain paths inside the mirror.
     await linkModulesAsync(modules, node_path_1.default.join(target, 'node_modules'));
-    await (0, check_1.stageAsync)(project, target, temp);
+    await (0, internal_1.stageAsync)(project, target, temp);
 }
-async function checkUnlockedAsync(project, options) {
+async function withGeneratedProjectAsync(project, options, action) {
     project = node_path_1.default.resolve(project);
-    const plan = await (0, tools_1.resolveHarmonyBuildPlanAsync)(project);
+    const plan = await (0, project_1.resolveHarmonyBuildPlanAsync)(project);
     const temp = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'expo-harmony-check-'));
     const expected = mirrorRoot(temp, project);
     let packed;
     try {
         await copyAsync(project, expected, plan, temp);
+        if (options.clean)
+            await node_fs_1.default.promises.rm(node_path_1.default.join(expected, 'harmony'), { recursive: true, force: true });
         packed = await (0, template_1.packAsync)(project);
         const expo = (0, expo_1.resolveExpoCli)(project);
         const result = await (0, process_1.spawnAsync)(process.execPath, [
@@ -122,17 +126,19 @@ async function checkUnlockedAsync(project, options) {
             capture: true,
             cwd: expected,
             env: {
-                ...(0, tools_1.createHarmonyToolchainEnv)(),
+                ...(0, toolchain_1.createHarmonyToolchainEnv)(),
                 ...packed.env,
                 ...(options.buildType ? { EXPO_HARMONY_BUILD_TYPE: options.buildType } : {}),
                 EXPO_HARMONY_CHECK_MIRROR_ROOT: temp,
+                ...(options.skipPatches ? { EXPO_HARMONY_SKIP_PATCHES: '1' } : {}),
             },
             operation: 'check-prebuild',
         });
         if (result.code !== 0) {
             throw new errors_1.HarmonyCliError('ERR_HARMONY_MANIFEST_DRIFT', `Isolated Expo prebuild failed:\n${result.stderr || result.stdout}`, { exitCode: result.code, operation: 'check-prebuild' });
         }
-        return (0, check_1.compareAsync)(project, expected);
+        const checksum = (0, node_crypto_1.createHash)('md5').update(Uint8Array.from(await node_fs_1.default.promises.readFile(packed.tarball))).digest('hex');
+        return await action(expected, checksum);
     }
     finally {
         if (packed)
@@ -141,5 +147,5 @@ async function checkUnlockedAsync(project, options) {
     }
 }
 async function checkAsync(project, options = {}) {
-    return (0, projectLock_1.withHarmonyProjectLockAsync)(project, 'prebuild-check', () => checkUnlockedAsync(project, options));
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(project, 'prebuild-check', () => withGeneratedProjectAsync(project, options, expected => (0, internal_1.compareAsync)(project, expected)));
 }

package/build/prebuild/clean.js

@@ -6,14 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertSafeCleanTarget = assertSafeCleanTarget;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const build_descriptor_1 = require("@expo-harmony/prebuild-config/build-descriptor");
+const internal_1 = require("@expo-harmony/prebuild-config/internal");
 const errors_1 = require("../errors");
 const path_1 = require("../path");
-const tools_1 = require("../tools");
+const project_1 = require("../native/project");
 async function assertSafeCleanTarget(projectRoot) {
     const root = await node_fs_1.default.promises.realpath(projectRoot);
-    const plan = await (0, tools_1.resolveHarmonyBuildPlanIfPresentAsync)(root);
-    const target = plan?.harmonyRoot ?? node_path_1.default.join(root, build_descriptor_1.HarmonyPlatformDirectory);
+    const plan = await (0, project_1.resolveHarmonyBuildPlanIfPresentAsync)(root);
+    const target = plan?.harmonyRoot ?? node_path_1.default.join(root, internal_1.HarmonyPlatformDirectory);
     let stat;
     try {
         stat = await node_fs_1.default.promises.lstat(target);
@@ -23,7 +23,7 @@ async function assertSafeCleanTarget(projectRoot) {
             return target;
         throw new errors_1.HarmonyCliError(error.code || 'ERR_HARMONY_CLEAN_TARGET', error.message || `Cannot inspect the Harmony clean target: ${target}. Please delete it manually.`, { cause: error, exitCode: error.exitCode, operation: error.operation });
     }
-    if (!plan) {
+    if (!plan || plan.workflow !== 'cng') {
         throw new errors_1.HarmonyCliError('ERR_HARMONY_CLEAN_TARGET', `Refusing to clean ${target} because its CNG manifest is missing. Please delete it manually or run prebuild without --clean.`, { operation: 'clean' });
     }
     if (!stat.isDirectory() || stat.isSymbolicLink()) {

package/build/prebuild/index.d.ts

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

package/build/prebuild/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const errors_1 = require("../errors");
+const projectLock_1 = require("../projectLock");
+const options_1 = require("./options");
+const command = async (argv, io) => {
+    const args = (0, command_1.parseCommandArgs)(args => (0, options_1.parsePrebuildArgs)(args, { allowProject: true }), argv, io);
+    if (!args)
+        return 0;
+    const { projectRoot: root, options } = args;
+    const { check, clean, passthrough } = options;
+    if (check && passthrough.length) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--check cannot be combined with mutating prebuild options.');
+    }
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(root, check ? 'prebuild-check' : 'prebuild', async () => {
+        if (clean) {
+            const { assertSafeCleanTarget } = await import('./clean.js');
+            await assertSafeCleanTarget(root);
+        }
+        const { doctorAsync, formatDoctor } = await import('../doctor/doctor.js');
+        const doctor = await doctorAsync(root, {
+            requireBuildTools: false,
+            validateGeneratedProject: !clean,
+            validateModules: false,
+        });
+        if (!doctor.ok) {
+            io.error(formatDoctor(doctor));
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_DOCTOR_FAILED', 'Harmony doctor found blocking errors.', {
+                operation: 'doctor',
+            });
+        }
+        for (const item of doctor.checks.filter(item => item.status === 'warn'))
+            io.warn(`! ${item.message}`);
+        if (check) {
+            const { checkAsync } = await import('./check.js');
+            const result = await checkAsync(root);
+            if (result.clean)
+                io.log('Harmony CNG output is up to date.');
+            else
+                for (const change of result.changes)
+                    io.log(`${change.type}: ${change.path}`);
+            return result.clean ? 0 : 2;
+        }
+        const { prebuildParsedAsync } = await import('./prebuild.js');
+        await prebuildParsedAsync(root, passthrough);
+        return 0;
+    });
+};
+exports.command = command;

package/build/prebuild/prebuild.js

@@ -6,13 +6,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.prebuildParsedAsync = prebuildParsedAsync;
 const node_fs_1 = __importDefault(require("node:fs"));
 const errors_1 = require("../errors");
+const bare_1 = require("../native/bare");
 const process_1 = require("../process");
 const projectLock_1 = require("../projectLock");
 const expo_1 = require("../expo");
-const tools_1 = require("../tools");
+const toolchain_1 = require("../native/toolchain");
+const project_1 = require("../native/project");
 const clean_1 = require("./clean");
 const template_1 = require("./template");
 async function prebuildParsedUnlockedAsync(projectRoot, passthrough, options = {}) {
+    if ((0, bare_1.isBareHarmonyProject)(projectRoot)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_BARE_PREBUILD', 'This Harmony project is manually maintained. Build it directly; prebuild cannot overwrite a bare project.', { operation: 'prebuild' });
+    }
     if (passthrough.includes('--clean'))
         await (0, clean_1.assertSafeCleanTarget)(projectRoot);
     const expo = (0, expo_1.resolveExpoCli)(projectRoot);
@@ -28,7 +33,7 @@ async function prebuildParsedUnlockedAsync(projectRoot, passthrough, options = {
             capture: Boolean(options.capture),
             cwd: projectRoot,
             env: {
-                ...(0, tools_1.createHarmonyToolchainEnv)(),
+                ...(0, toolchain_1.createHarmonyToolchainEnv)(),
                 ...packed.env,
                 ...(options.buildType ? { EXPO_HARMONY_BUILD_TYPE: options.buildType } : {}),
             },
@@ -43,9 +48,12 @@ async function prebuildParsedUnlockedAsync(projectRoot, passthrough, options = {
             });
         }
         try {
-            const plan = await (0, tools_1.resolveHarmonyBuildPlanAsync)(projectRoot, {
+            const plan = await (0, project_1.resolveHarmonyBuildPlanAsync)(projectRoot, {
                 buildMode: options.buildType,
             });
+            if (plan.workflow !== 'cng') {
+                throw new errors_1.HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'Prebuild did not produce a CNG project.', { operation: 'prebuild' });
+            }
             await node_fs_1.default.promises.access(plan.projectFiles.templateMarker, node_fs_1.default.constants.R_OK);
         }
         catch (cause) {

package/build/prebuild/template.js

@@ -14,10 +14,10 @@ function resolve(project) {
     const load = (0, node_module_1.createRequire)(node_path_1.default.join(project, 'package.json'));
     let api;
     try {
-        api = load('@expo-harmony/prebuild-config/template');
+        api = load('@expo-harmony/prebuild-config/internal/template');
     }
     catch (cause) {
-        throw new errors_1.HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'Cannot load @expo-harmony/prebuild-config/template from the project. Update the project-local prebuild config to a compatible version.', { cause, operation: 'resolve-template' });
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'Cannot load @expo-harmony/prebuild-config/internal/template from the project. Update the project-local prebuild config to a compatible version.', { cause, operation: 'resolve-template' });
     }
     if (typeof api?.ROOT_ENV !== 'string' || typeof api.resolveBundled !== 'function') {
         throw new errors_1.HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'The project-local @expo-harmony/prebuild-config template API is invalid.', { operation: 'resolve-template' });

package/build/process.d.ts

@@ -18,6 +18,15 @@ export interface ProcessResult {
     stdout: string;
     timedOut: boolean;
 }
+interface CheckedProcessOptions {
+    code: string;
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    message: string;
+    operation: string;
+    outputLimit?: number;
+    timeoutMs?: number;
+}
 declare function formatDiagnostics(result: Pick<ProcessResult, 'stderr' | 'stdout'>, limit?: number): string;
 declare function spawnAsync(command: string, args: string[], options?: ProcessOptions): Promise<ProcessResult>;
 declare function startManagedProcess(command: string, args: string[], options?: ProcessOptions): {
@@ -28,4 +37,5 @@ declare function startManagedProcess(command: string, args: string[], options?:
     stop: (signal?: NodeJS.Signals, graceMs?: number) => Promise<ProcessResult>;
     wasStopped: () => boolean;
 };
-export { formatDiagnostics, spawnAsync, startManagedProcess };
+declare function runCheckedAsync(command: string, args: string[], options: CheckedProcessOptions): Promise<ProcessResult>;
+export { formatDiagnostics, runCheckedAsync, spawnAsync, startManagedProcess };

package/build/process.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatDiagnostics = formatDiagnostics;
+exports.runCheckedAsync = runCheckedAsync;
 exports.spawnAsync = spawnAsync;
 exports.startManagedProcess = startManagedProcess;
 const cross_spawn_1 = __importDefault(require("cross-spawn"));
@@ -306,3 +307,18 @@ function startManagedProcess(command, args, options = {}) {
         wasStopped: () => stopped,
     };
 }
+async function runCheckedAsync(command, args, options) {
+    const result = await spawnAsync(command, args, {
+        capture: true,
+        cwd: options.cwd,
+        env: options.env,
+        operation: options.operation,
+        outputLimit: options.outputLimit || 2 * 1024 * 1024,
+        timeoutMs: options.timeoutMs,
+    });
+    if (result.code !== 0 || result.timedOut) {
+        const diagnostics = formatDiagnostics(result);
+        throw new errors_1.HarmonyCliError(options.code, `${options.message} exited with code ${result.code}${result.timedOut ? ' after timing out' : ''}.${diagnostics ? `\n${diagnostics}` : ''}`, { exitCode: result.code || 1, operation: options.operation });
+    }
+    return result;
+}

package/build/profile.d.ts

@@ -0,0 +1 @@
+export declare function timedAsync<T>(steps: Record<string, number>, name: string, operation: () => Promise<T> | T): Promise<T>;

package/build/profile.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timedAsync = timedAsync;
+async function timedAsync(steps, name, operation) {
+    const started = performance.now();
+    try {
+        return await operation();
+    }
+    finally {
+        steps[name] = Math.max(0, Math.round(performance.now() - started));
+    }
+}

package/build/projectLock.js

@@ -147,8 +147,13 @@ async function acquireHarmonyProjectLockAsync(projectRoot, operation) {
             };
         }
         catch (cause) {
-            if (cause instanceof errors_1.HarmonyCliError)
-                throw cause;
+            if (cause instanceof errors_1.HarmonyCliError) {
+                throw new errors_1.HarmonyCliError(cause.code, cause.message, {
+                    cause,
+                    exitCode: cause.exitCode,
+                    operation: cause.operation,
+                });
+            }
             if (cause?.code !== 'EEXIST') {
                 throw new errors_1.HarmonyCliError('ERR_HARMONY_PROJECT_LOCK', 'Cannot acquire the Harmony native operation lock.', { cause, operation: 'project-lock' });
             }

package/build/run/devices.d.ts

@@ -1,4 +1,4 @@
-import type { HarmonyTool } from '../tools';
+import { type HarmonyTool } from '../native/toolchain';
 interface Device {
     aliases: string[];
     connectTool: string | null;

package/build/run/devices.js

@@ -18,8 +18,6 @@ function parseHdcTargets(output) {
             throw new errors_1.HarmonyCliError('ERR_HARMONY_DEVICE_OUTPUT', 'HDC returned an unsupported target-list format.', { operation: 'list-devices' });
         }
         return {
-            // Only the first HDC column is a selectable target name. The remaining
-            // verbose columns describe transport, state, location and connect tool.
             aliases: [fields[0]],
             connectTool: fields[4] || null,
             id: fields[0],
@@ -32,10 +30,7 @@ function parseHdcTargets(output) {
 function hasCommandFailure(result) {
     const output = `${result.stdout || ''}\n${result.stderr || ''}`;
     return result.code !== 0 || result.timedOut
-        // HDC occasionally reports transport and package-manager failures on
-        // stdout while still returning exit code 0 (for example,
-        // "Connect server failed"). Treat its documented failure vocabulary as
-        // authoritative regardless of where it appears on the line.
+        // HDC can print failures to stdout while returning exit code 0.
         || /\[(?:Fail|Error)\]|\b(?:Failure|failed)\b|(?:失败|错误)/iu.test(output);
 }
 async function runHdcAsync(hdc, args, options = {}) {
@@ -93,7 +88,6 @@ async function selectDeviceAsync(hdc, requested, options = {}) {
         throw new errors_1.HarmonyCliError('ERR_HARMONY_DEVICE_NOT_FOUND', 'No connected Harmony device was reported by HDC.', { operation: 'select-device' });
     }
     const instances = await (0, emulators_1.listEmulatorsAsync)(options.emulator, { cwd: options.cwd });
-    // Prefer an instance that is already booting when HDC is not connected yet.
     const running = instances.filter(instance => instance.running);
     const candidates = requested
         ? instances.filter(instance => instance.name === requested)
@@ -167,12 +161,23 @@ async function installHapAsync(hdc, device, hap, options = {}) {
 async function configureMetroPortAsync(hdc, device, port, options = {}) {
     const deviceEndpoint = `tcp:${options.devicePort || 8081}`;
     const hostEndpoint = `tcp:${port}`;
-    await runHdcAsync(hdc, ['-t', device.id, 'fport', 'rm', deviceEndpoint, hostEndpoint], {
-        allowFailure: true,
+    const forwards = await runHdcAsync(hdc, ['-t', device.id, 'fport', 'ls'], {
         cwd: options.cwd,
-        operation: 'remove-metro-port',
+        operation: 'list-metro-ports',
         timeoutMs: 15_000,
     });
+    for (const line of forwards.stdout.split(/\r?\n/u)) {
+        const [target, remote, local, direction] = line.trim().split(/\s+/u);
+        if (target !== device.id || remote !== deviceEndpoint || direction !== '[Reverse]')
+            continue;
+        if (local === hostEndpoint)
+            return;
+        await runHdcAsync(hdc, ['-t', device.id, 'fport', 'rm', remote, local], {
+            cwd: options.cwd,
+            operation: 'remove-metro-port',
+            timeoutMs: 15_000,
+        });
+    }
     await runHdcAsync(hdc, ['-t', device.id, 'rport', deviceEndpoint, hostEndpoint], {
         code: 'ERR_HARMONY_METRO_FORWARD',
         cwd: options.cwd,

package/build/run/emulators.d.ts

@@ -1,4 +1,4 @@
-import type { HarmonyTool } from '../tools';
+import { type HarmonyTool } from '../native/toolchain';
 interface HarmonyEmulator {
     name: string;
     running: boolean;

package/build/run/emulators.js

@@ -51,9 +51,7 @@ function startEmulator(tool, name, logFile, cwd) {
     const log = node_fs_1.default.openSync(logFile, 'w', 0o600);
     let failure = null;
     try {
-        // Emulator may remain alive for the whole GUI session. Give it its own
-        // process group and file-backed output so it survives the CLI/Metro exit.
-        // Default instance/image paths match the ones used by -list -details.
+        // A detached process with file output lets the emulator survive CLI exit.
         const child = (0, cross_spawn_1.default)(tool.command, [...tool.args, '-start', name], {
             cwd,
             detached: true,
@@ -65,8 +63,7 @@ function startEmulator(tool, name, logFile, cwd) {
             failure = cause.message;
         });
         child.once('exit', (code, signal) => {
-            // Some versions use a short-lived launcher. A zero exit alone does not
-            // prove readiness; the caller still checks the guest's name and boot state.
+            // Some launchers exit before the guest boots; HDC still has to confirm readiness.
             if (code !== 0)
                 failure = signal ? `terminated by ${signal}` : `exited with code ${code}`;
         });

package/build/run/index.d.ts

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

package/build/run/index.js

@@ -0,0 +1,25 @@
+"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.parseRunArgs, argv, io);
+    if (!args)
+        return 0;
+    const { projectRoot: root, options } = args;
+    const { runHarmonySessionAsync } = await import('./run.js');
+    const session = await runHarmonySessionAsync(root, {
+        ...options,
+        interactiveBundler: true,
+        io,
+    });
+    const { result } = session;
+    io.log(`Launched ${result.bundleName} on ${result.device.id} (${result.variant}).`);
+    if (session.metro.owner === 'started') {
+        io.log('\n› Logs for your project will appear below. Press Ctrl+C to exit.');
+        await session.metro.waitAsync();
+    }
+    return 0;
+};
+exports.command = command;

package/build/run/metro.js

@@ -102,7 +102,7 @@ async function startExpoMetroAsync(projectRoot, options) {
         exitError = error;
     });
     const startedAt = Date.now();
-    const timeoutMs = options.readyTimeoutMs || 60_000;
+    const timeoutMs = options.readyTimeoutMs || 1800000;
     try {
         while (Date.now() - startedAt < timeoutMs) {
             if (exitError instanceof errors_1.HarmonyCliError) {