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

package/build/run/run.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHarmonyAsync = runHarmonyAsync;
+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 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 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)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--app-id must contain at least three valid dot-separated segments.', { operation: 'resolve-run' });
+    }
+    if (options.appId && !options.noInstall && options.appId !== plan.bundleName) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_APP_ID_MISMATCH', `--app-id can differ from the generated bundle name only with --no-install; expected ${plan.bundleName}.`, { operation: 'resolve-run' });
+    }
+    return {
+        abilityName: plan.abilityName,
+        bundleName: options.appId || plan.bundleName,
+    };
+}
+async function runHarmonyUnlockedAsync(projectRoot, options = {}) {
+    const normalizedOptions = {
+        appId: options.appId,
+        device: options.device,
+        interactiveBundler: Boolean(options.interactiveBundler),
+        io: options.io || console,
+        noBundler: Boolean(options.noBundler),
+        noInstall: Boolean(options.noInstall),
+        port: options.port || 8081,
+        resetCache: Boolean(options.resetCache),
+        sync: Boolean(options.sync),
+        variant: options.variant || 'debug',
+    };
+    const steps = {};
+    await (0, common_1.ensureGeneratedProjectAsync)(projectRoot, normalizedOptions, 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, {
+        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),
+    }));
+    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));
+    let metro = {
+        owner: 'disabled',
+        port: normalizedOptions.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
+                ? '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,
+                }));
+            await (0, common_1.timed)(steps, 'metroPort', () => (0, devices_1.configureMetroPortAsync)(toolchain.hdc, device, normalizedOptions.port, { cwd: plan.harmonyRoot }));
+        }
+        else {
+            steps.metro = 0;
+            steps.metroPort = 0;
+        }
+        if (normalizedOptions.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, 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 }));
+        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,
+            launched: true,
+            metro: {
+                owner: metro.owner,
+                port: metro.port,
+            },
+            ok: true,
+            schemaVersion: 1,
+            steps,
+            variant: normalizedOptions.variant,
+        };
+        return { metro, result };
+    }
+    catch (error) {
+        await metro.stop();
+        throw error;
+    }
+}
+async function runHarmonySessionAsync(projectRoot, options = {}) {
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(projectRoot, 'run', () => runHarmonyUnlockedAsync(projectRoot, options));
+}
+async function runHarmonyAsync(projectRoot, options = {}) {
+    const session = await runHarmonySessionAsync(projectRoot, options);
+    try {
+        return session.result;
+    }
+    finally {
+        await session.metro.stop();
+    }
+}

package/build/start/options.d.ts

@@ -0,0 +1,7 @@
+declare function parseStartArgs(argv: string[]): {
+    help: boolean;
+    port: number;
+    project: string;
+    resetCache: boolean;
+};
+export { parseStartArgs };

package/build/start/options.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStartArgs = parseStartArgs;
+const args_1 = require("../args");
+const errors_1 = require("../errors");
+const StartOptions = {
+    ...args_1.CommonOptions,
+    'clear': { short: 'c', type: 'boolean' },
+    'port': { type: 'string' },
+    'reset-cache': { type: 'boolean' },
+};
+function parseStartArgs(argv) {
+    const { positionals, values } = (0, args_1.parseArgs)(StartOptions, argv);
+    if (positionals.length > 1) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Unexpected start positional argument: ${positionals[1]}`, {
+            operation: 'parse-arguments',
+        });
+    }
+    const port = values.port === undefined ? 8081 : Number(values.port);
+    if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--port must be an integer between 1 and 65535.', {
+            operation: 'parse-arguments',
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        port,
+        project: positionals[0],
+        resetCache: Boolean(values['reset-cache'] || values.clear),
+    };
+}

package/build/tools.d.ts

@@ -0,0 +1,39 @@
+import { type HarmonyBuildDescriptor } from '@expo-harmony/prebuild-config/build-descriptor';
+export interface HarmonyTool {
+    args: string[];
+    command: string;
+    source: 'deveco' | 'override' | 'path';
+}
+export interface HarmonyToolchain {
+    hdc: HarmonyTool;
+    hvigor: HarmonyTool;
+    ohpm: HarmonyTool;
+    sdkHome: string | null;
+    toolsRoot: string | null;
+}
+export interface HarmonyBuildPlan {
+    abilityName: string;
+    buildMode: 'debug' | 'release';
+    bundleName: string;
+    expectedHap: string;
+    exportPaths: HarmonyBuildDescriptor['export'];
+    harmonyRoot: string;
+    hvigorArgs: string[];
+    moduleName: string;
+    moduleRoot: string;
+    nativeCache: HarmonyBuildDescriptor['nativeCache'];
+    nativeInputs: HarmonyBuildDescriptor['nativeInputs'];
+    projectFiles: HarmonyBuildDescriptor['projectFiles'];
+    productName: string;
+    targetName: string;
+}
+declare function resolveHarmonyToolchain(): HarmonyToolchain;
+declare function createHarmonyToolchainEnv(toolchain?: HarmonyToolchain): NodeJS.ProcessEnv;
+declare function resolveHarmonyEmulator(toolchain: HarmonyToolchain): HarmonyTool;
+declare function resolveHarmonyBuildPlanIfPresentAsync(projectRoot: string, options?: {
+    buildMode?: 'debug' | 'release';
+}): Promise<HarmonyBuildPlan | null>;
+declare function resolveHarmonyBuildPlanAsync(projectRoot: string, options?: {
+    buildMode?: 'debug' | 'release';
+}): Promise<HarmonyBuildPlan>;
+export { createHarmonyToolchainEnv, resolveHarmonyBuildPlanAsync, resolveHarmonyBuildPlanIfPresentAsync, resolveHarmonyEmulator, resolveHarmonyToolchain, };

package/build/tools.js

@@ -0,0 +1,226 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 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;
+}
+const RequiredSdkComponents = Object.freeze([
+    'default/sdk-pkg.json',
+    'default/hms/ets/uni-package.json',
+    'default/hms/native/uni-package.json',
+    'default/hms/toolchains/uni-package.json',
+    'default/openharmony/ets/oh-uni-package.json',
+    'default/openharmony/native/oh-uni-package.json',
+    'default/openharmony/toolchains/oh-uni-package.json',
+]);
+function sdkRootsNear(seed) {
+    const roots = [];
+    let cursor = node_path_1.default.resolve(seed);
+    for (let depth = 0; depth < 6; depth += 1) {
+        const name = node_path_1.default.basename(cursor).toLowerCase();
+        if (name === 'default' && node_path_1.default.basename(node_path_1.default.dirname(cursor)).toLowerCase() === 'sdk') {
+            roots.push(node_path_1.default.dirname(cursor));
+        }
+        if (name === 'sdk')
+            roots.push(cursor);
+        roots.push(node_path_1.default.join(cursor, 'sdk'));
+        const parent = node_path_1.default.dirname(cursor);
+        if (parent === cursor)
+            break;
+        cursor = parent;
+    }
+    return roots;
+}
+function resolveHarmonySdkRoot(env, platform) {
+    const seeds = [
+        env.DEVECO_SDK_HOME,
+        env.HARMONY_HOME,
+        env.OHOS_SDK_HOME,
+        env.HARMONY_HVIGORW,
+        env.HARMONY_OHPM,
+        env.HARMONY_NODE,
+        ...(env.PATH || '').split(node_path_1.default.delimiter).filter(Boolean),
+        ...(platform === 'darwin' ? ['/Applications/DevEco-Studio.app/Contents'] : []),
+    ].filter(Boolean);
+    const candidates = [...new Set(seeds.flatMap(sdkRootsNear))];
+    return candidates.find(root => RequiredSdkComponents.every(relative => node_fs_1.default.existsSync(node_path_1.default.join(root, ...relative.split('/'))))) || null;
+}
+function devEcoInstallRoots(sdkHome) {
+    const ancestors = [sdkHome, node_path_1.default.dirname(sdkHome), node_path_1.default.dirname(node_path_1.default.dirname(sdkHome))];
+    const sdkDirectory = ancestors.find(candidate => node_path_1.default.basename(candidate).toLowerCase() === 'sdk');
+    const roots = [
+        sdkDirectory && node_path_1.default.dirname(sdkDirectory),
+        node_path_1.default.dirname(sdkHome),
+        node_path_1.default.dirname(node_path_1.default.dirname(sdkHome)),
+    ].filter(Boolean);
+    return [...new Set(roots)];
+}
+function devEcoLayouts(sdkHome) {
+    return devEcoInstallRoots(sdkHome).flatMap(root => [
+        {
+            nodeRoot: node_path_1.default.join(root, 'tools', 'node'),
+            toolsRoot: node_path_1.default.join(root, 'tools'),
+        },
+        {
+            nodeRoot: node_path_1.default.join(root, 'tool', 'node'),
+            toolsRoot: root,
+        },
+    ]);
+}
+function devEcoNode(layout, platform, env) {
+    if (env.HARMONY_NODE)
+        return { command: env.HARMONY_NODE, source: 'override' };
+    const executable = platform === 'win32' ? 'node.exe' : 'node';
+    const command = existingFile([
+        node_path_1.default.join(layout.nodeRoot, 'bin', executable),
+        node_path_1.default.join(layout.nodeRoot, executable),
+    ]);
+    return command ? { command, source: 'deveco' } : null;
+}
+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.
+    const sdkHome = resolveHarmonySdkRoot(env, platform);
+    const layouts = sdkHome ? devEcoLayouts(sdkHome) : [];
+    let ohpm;
+    if (env.HARMONY_OHPM) {
+        ohpm = { args: [], command: env.HARMONY_OHPM, source: 'override' };
+    }
+    else {
+        const devEcoOhpm = existingFile(layouts.map(layout => node_path_1.default.join(layout.toolsRoot, 'ohpm', 'bin', platform === 'win32' ? 'ohpm.bat' : 'ohpm')));
+        ohpm = devEcoOhpm
+            ? { args: [], command: devEcoOhpm, source: 'deveco' }
+            : { args: [], command: platform === 'win32' ? 'ohpm.bat' : 'ohpm', source: 'path' };
+    }
+    let hvigor;
+    if (env.HARMONY_HVIGORW) {
+        if (/\.(?:c|m)?js$/iu.test(env.HARMONY_HVIGORW)) {
+            hvigor = {
+                args: [env.HARMONY_HVIGORW],
+                command: env.HARMONY_NODE || process.execPath,
+                source: 'override',
+            };
+        }
+        else {
+            hvigor = { args: [], command: env.HARMONY_HVIGORW, source: 'override' };
+        }
+    }
+    else {
+        const devEcoHvigor = layouts.map(layout => ({
+            layout,
+            node: devEcoNode(layout, platform, env),
+            script: node_path_1.default.join(layout.toolsRoot, 'hvigor', 'bin', 'hvigorw.js'),
+        })).find(candidate => candidate.node && node_fs_1.default.existsSync(candidate.script));
+        hvigor = devEcoHvigor
+            ? { args: [devEcoHvigor.script], command: devEcoHvigor.node.command, source: 'deveco' }
+            : { args: [], command: platform === 'win32' ? 'hvigorw.bat' : 'hvigorw', source: 'path' };
+    }
+    const toolsRoot = layouts.find(layout => (hvigor.args[0]?.startsWith(`${layout.toolsRoot}${node_path_1.default.sep}`)
+        || ohpm.command.startsWith(`${layout.toolsRoot}${node_path_1.default.sep}`)))?.toolsRoot || null;
+    let hdc;
+    if (env.HARMONY_HDC) {
+        hdc = { args: [], command: env.HARMONY_HDC, source: 'override' };
+    }
+    else {
+        const executable = platform === 'win32' ? 'hdc.exe' : 'hdc';
+        const sdkHdc = sdkHome && existingFile([
+            node_path_1.default.join(sdkHome, 'default', 'openharmony', 'toolchains', executable),
+            node_path_1.default.join(sdkHome, 'default', 'hms', 'toolchains', executable),
+        ]);
+        hdc = sdkHdc
+            ? { args: [], command: sdkHdc, source: 'deveco' }
+            : { args: [], command: executable, source: 'path' };
+    }
+    return { hdc, hvigor, ohpm, sdkHome, toolsRoot };
+}
+function createHarmonyToolchainEnv(toolchain = resolveHarmonyToolchain()) {
+    return {
+        ...process.env,
+        HARMONY_OHPM: toolchain.ohpm.command,
+        // A script-based Hvigor invocation must retain both its script and Node executable.
+        HARMONY_HVIGORW: toolchain.hvigor.args[0] || toolchain.hvigor.command,
+        ...(toolchain.hvigor.args.length > 0 ? { HARMONY_NODE: toolchain.hvigor.command } : {}),
+        ...(toolchain.sdkHome && !process.env.DEVECO_SDK_HOME
+            ? { DEVECO_SDK_HOME: toolchain.sdkHome }
+            : {}),
+    };
+}
+function resolveHarmonyEmulator(toolchain) {
+    if (process.env.HARMONY_EMULATOR) {
+        return { args: [], command: process.env.HARMONY_EMULATOR, source: 'override' };
+    }
+    const executable = process.platform === 'win32' ? 'Emulator.exe' : 'Emulator';
+    const roots = [
+        toolchain.toolsRoot,
+        ...(toolchain.sdkHome ? devEcoLayouts(toolchain.sdkHome).map(layout => layout.toolsRoot) : []),
+        ...(process.platform === 'darwin' ? ['/Applications/DevEco-Studio.app/Contents/tools'] : []),
+    ].filter(Boolean);
+    const command = existingFile(roots.map(root => node_path_1.default.join(root, 'emulator', executable)));
+    return command
+        ? { 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/upstream.d.ts

@@ -0,0 +1,9 @@
+declare const ProjectPackages: Readonly<{
+    expo: "expo";
+    expoAutolinking: "@expo-harmony/expo-modules-autolinking";
+    reactNative: "react-native";
+    rnohCli: "@react-native-oh/react-native-harmony-cli";
+    rnohRuntime: "@react-native-oh/react-native-harmony";
+}>;
+declare const RequiredProjectPackages: readonly ("@expo-harmony/expo-modules-autolinking" | "@react-native-oh/react-native-harmony-cli" | "@react-native-oh/react-native-harmony")[];
+export { ProjectPackages, RequiredProjectPackages, };

package/build/upstream.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredProjectPackages = exports.ProjectPackages = void 0;
+const ProjectPackages = Object.freeze({
+    expo: 'expo',
+    expoAutolinking: '@expo-harmony/expo-modules-autolinking',
+    reactNative: 'react-native',
+    rnohCli: '@react-native-oh/react-native-harmony-cli',
+    rnohRuntime: '@react-native-oh/react-native-harmony',
+});
+exports.ProjectPackages = ProjectPackages;
+const RequiredProjectPackages = Object.freeze([
+    ProjectPackages.rnohRuntime,
+    ProjectPackages.rnohCli,
+    ProjectPackages.expoAutolinking,
+]);
+exports.RequiredProjectPackages = RequiredProjectPackages;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo-harmony/cli",
-  "version": "55.0.26-harmony.1",
+  "version": "55.0.26-harmony.2",
   "keywords": [
     "react-native",
     "expo",