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

package/src/runtime/contract.ts

@@ -0,0 +1,165 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+import { createNativeModuleContracts, ohpmDependenciesFromManifest, verifyModulesAsync, type Manifest, type ModuleDescriptor } from '@expo-harmony/expo-modules-autolinking';
+import { assertHarmonyCompatibility, validateHarmonyRuntime, type HarmonyRuntimeContract } from '@expo-harmony/expo-modules-autolinking/runtime';
+import JSON5 from 'json5';
+
+import { publishUpdatesConfigurationAsync } from '../updates/export';
+import { HarmonyCliError } from '../errors';
+import { atomicCopy, atomicWriteJson } from '../file';
+import type { HarmonyBuildPlan } from '../native/types';
+import { readMetroRuntimeAsync, readNativeRuntime, readProjectRuntimeAsync, resolveRuntimeVersionAsync, type HarmonyMetroRuntime } from './config';
+
+async function createRuntimeContractAsync(
+  root: string,
+  project: Awaited<ReturnType<typeof readProjectRuntimeAsync>>,
+  modules: readonly ModuleDescriptor[],
+  metro?: HarmonyMetroRuntime
+): Promise<HarmonyRuntimeContract> {
+  const resolution = metro ?? await readMetroRuntimeAsync(root);
+  if (!resolution?.fixedRuntime || resolution.harmonyPackage !== '@react-native-oh/react-native-harmony'
+    || typeof resolution.reactPackage !== 'string' || !resolution.reactPackage) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_RUNTIME_CONFIG',
+      'Runtime contracts require withHarmonyConfig with the standard RNOH package and supported React resolution.',
+      { operation: 'runtime-contract' }
+    );
+  }
+
+  const require = createRequire(path.join(root, 'package.json'));
+  const version = (name: string) => require(`${name}/package.json`).version as string;
+  const native = createRequire(require.resolve(resolution.harmonyPackage + '/package.json'));
+
+  const contract: HarmonyRuntimeContract = {
+    schemaVersion: 1,
+    platform: 'harmony',
+    runtimeVersion: project.runtimeVersion,
+    development: true,
+    expo: version('expo'),
+    expoModulesCore: version('expo-modules-core'),
+    rnoh: native('./package.json').version,
+    react: version(resolution.reactPackage),
+    hermes: native('hermes-compiler/package.json').version,
+    engine: 'hermes-v1',
+    bundleFormat: 'js-source',
+    renderer: 'rnoh',
+    modules: createNativeModuleContracts(modules),
+    config: project.native,
+  };
+
+  if (contract.rnoh !== '0.84.1' || contract.react !== '19.2.3' || contract.hermes !== '250829098.0.9'
+    || !contract.expo.startsWith('55.') || !modules.some(module => module.packageName === '@expo-harmony/expo-modules-core')) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_RUNTIME_UNSUPPORTED',
+      'The fixed development runtime requires Expo SDK 55, Harmony Expo Modules Core, RNOH 0.84.1, React 19.2.3, and Hermes 250829098.0.9. Check the Metro React alias.',
+      { operation: 'runtime-contract' }
+    );
+  }
+
+  const issues = validateHarmonyRuntime(contract);
+  if (issues.length > 0) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_RUNTIME_CONFIG',
+      issues.map(issue => issue.message).join('\n'),
+      { operation: 'runtime-contract' }
+    );
+  }
+
+  return contract;
+}
+
+export async function resolveRuntimeRequirementsAsync(
+  root: string,
+  metro?: HarmonyMetroRuntime
+): Promise<HarmonyRuntimeContract> {
+  const result = await verifyModulesAsync({ projectRoot: root });
+  if (!result.valid) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_RUNTIME_MODULES',
+      result.diagnostics.filter(item => item.severity === 'error').map(item => item.message).join('\n'),
+      { operation: 'runtime-contract' }
+    );
+  }
+
+  const project = await readProjectRuntimeAsync(root);
+
+  return createRuntimeContractAsync(root, project, result.modules, metro);
+}
+
+export async function publishRuntimeContractAsync(
+  root: string,
+  plan: HarmonyBuildPlan
+): Promise<HarmonyRuntimeContract> {
+  const manifest = JSON.parse(await fs.promises.readFile(path.join(root, '.expo/harmony/autolinking.json'), 'utf8')) as Manifest;
+  if (manifest.schemaVersion !== 4 || manifest.platform !== 'harmony' || manifest.buildType !== plan.buildMode) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_RUNTIME_BUILD',
+      'Runtime publication requires autolinking from this native build.',
+      { operation: 'runtime-contract' }
+    );
+  }
+
+  const project = await readProjectRuntimeAsync(root);
+  const requirements = await createRuntimeContractAsync(root, project, manifest.modules);
+  if (!manifest.runtimeModules || JSON.stringify(requirements.modules) !== JSON.stringify(manifest.runtimeModules)) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_RUNTIME_BUILD',
+      'Native inputs changed or lack a runtime snapshot. Run autolinking/prebuild again before publishing capabilities.',
+      { operation: 'runtime-contract' }
+    );
+  }
+
+  const read = (file: string) => JSON5.parse(fs.readFileSync(file, 'utf8'));
+  const dependencies = read(plan.nativeInputs.manifest);
+  const declared = { ...dependencies.dependencies, ...dependencies.overrides };
+  const linked = ohpmDependenciesFromManifest(manifest, { harmonyProjectPath: plan.harmonyRoot });
+  for (const [name, expected] of Object.entries(linked)) {
+    const actual = declared[name];
+    const target = fs.realpathSync(path.resolve(plan.harmonyRoot, expected));
+    if (typeof actual !== 'string' || !actual.startsWith('.')
+      || fs.realpathSync(path.resolve(plan.harmonyRoot, actual)) !== target) {
+      throw new HarmonyCliError(
+        'ERR_HARMONY_RUNTIME_BUILD',
+        `Native dependency ${name} does not use the HAR recorded by autolinking.`,
+        { operation: 'runtime-contract' }
+      );
+    }
+  }
+
+  const directory = path.join(plan.harmonyRoot, 'oh_modules/@rnoh/react-native-openharmony');
+  const rnoh = read(path.join(directory, 'oh-package.json5'));
+  const hermes = read(path.join(directory, 'src/main/cpp/third-party/hermes/npm/hermes-compiler/package.json'));
+  if (rnoh.version !== requirements.rnoh || hermes.version !== requirements.hermes
+    || declared['@rnoh/react-native-openharmony'] !== requirements.rnoh
+    || process.env.HERMES_V1_ENABLED === 'false') {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_RUNTIME_BUILD',
+      'Runtime publication requires matching installed RNOH and Hermes v1.',
+      { operation: 'runtime-contract' }
+    );
+  }
+
+  const native = readNativeRuntime(plan);
+  requirements.development = plan.buildMode === 'debug';
+  const contract: HarmonyRuntimeContract = {
+    ...requirements,
+    runtimeVersion: await resolveRuntimeVersionAsync(root, project.config, native.app),
+    config: native.config,
+  };
+
+  assertHarmonyCompatibility(contract, requirements);
+
+  const require = createRequire(path.join(root, 'package.json'));
+  const file = path.join(plan.exportPaths.rawfileRoot, 'expo-harmony-runtime.json');
+  const source = require.resolve('@expo-harmony/expo-modules-autolinking/runtime-source');
+  const target = path.join(plan.moduleRoot, 'src/main/ets/generated/HarmonyRuntime.ts');
+
+  await atomicCopy(source, target, root);
+  await atomicWriteJson(contract, file, root);
+  await atomicWriteJson(contract, path.join(root, '.expo/harmony/runtime.json'), root);
+  await publishUpdatesConfigurationAsync(root, plan.exportPaths.rawfileRoot, project.config, contract.runtimeVersion);
+
+  return contract;
+}

package/src/runtime/fingerprint.ts

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { createFingerprintAsync, type HashSource } from '@expo/fingerprint';
+import { createNativeModuleContracts, verifyModulesAsync } from '@expo-harmony/expo-modules-autolinking';
+import { HarmonyCliError } from '../errors';
+
+export async function fingerprintHarmonyAsync(root: string) {
+  const result = await verifyModulesAsync({ projectRoot: root });
+  if (!result.valid) throw new HarmonyCliError('ERR_HARMONY_FINGERPRINT', 'Build and verify Harmony native modules before calculating the runtime fingerprint.', { operation: 'fingerprint' });
+
+  const require = createRequire(path.join(root, 'package.json'));
+  const dependencies = createNativeModuleContracts(result.modules);
+  const generated: string[] = [];
+  const previous = path.join(root, '.expo/harmony/export-manifest.json');
+  if (fs.existsSync(previous)) {
+    const manifest = JSON.parse(fs.readFileSync(previous, 'utf8'));
+    generated.push(...manifest.assets.map(asset => `**/harmony/**/src/main/resources/rawfile/${asset.path}`));
+  }
+  const sources: HashSource[] = [{ type: 'contents', id: 'harmonyAutolinking', contents: JSON.stringify(dependencies), reasons: ['harmonyAutolinking'] }];
+  for (const name of ['@react-native-oh/react-native-harmony', '@expo-harmony/template', '@expo-harmony/config-plugins', '@expo-harmony/prebuild-config']) {
+    const file = require.resolve(name + '/package.json');
+    sources.push({ type: 'dir', filePath: path.relative(root, path.dirname(file)), reasons: ['harmonyNativeToolchain'] });
+  }
+  if (fs.existsSync(path.join(root, 'harmony'))) sources.push({ type: 'dir', filePath: 'harmony', reasons: ['harmonyNativeProject'] });
+
+  return createFingerprintAsync(root, {
+    platforms: [], extraSources: sources,
+    ignorePaths: [
+      ...generated,
+      '**/harmony/**/build/**', '**/harmony/**/.hvigor/**', '**/harmony/**/.cxx/**', '**/harmony/**/oh_modules/**',
+      '**/harmony/**/oh-package-lock.json5', '**/harmony/**/local.properties', '**/harmony/**/native-inputs.cmake',
+      '**/harmony/**/HarmonyRuntime.ts', '**/harmony/**/expo-harmony-runtime.json', '**/harmony/**/expo-updates/**',
+      '**/harmony/**/hermes_bundle.hbc', '**/harmony/**/hermes_bundle.hbc.*', '**/harmony/**/.expo-harmony/**',
+      '**/harmony/**/autolinking.cmake', '**/harmony/**/autolinking.cpp',
+      '**/harmony/**/generated/**', '**/*.har', '**/*.hap', '**/.git/**', '**/node_modules/**/node_modules/**',
+    ],
+  });
+}

package/src/runtime/index.ts

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { assertHarmonyCompatibility } from '@expo-harmony/expo-modules-autolinking/runtime';
+
+import { CommonOptions, parseArgs } from '../args';
+import { parseCommandArgs, type Command } from '../command';
+import { HarmonyCliError } from '../errors';
+import { resolveHarmonyBuildPlanAsync } from '../native/project';
+import { publishRuntimeContractAsync, resolveRuntimeRequirementsAsync } from './contract';
+
+export const command: Command = async (argv, io) => {
+  const args = parseCommandArgs((argv) => {
+    const { values, positionals } = parseArgs({
+      ...CommonOptions,
+      publish: { type: 'boolean' },
+      client: { type: 'string' },
+      variant: { type: 'string' },
+    }, argv);
+
+    if (positionals.length > 1 || (values.variant && !['debug', 'release'].includes(values.variant))
+      || (values.publish && values.client)) {
+      throw new HarmonyCliError(
+        'ERR_HARMONY_CONFIG_INVALID',
+        'Use runtime [project] [--client file | --publish] [--variant debug|release].',
+        { operation: 'parse-arguments' }
+      );
+    }
+
+    return { help: Boolean(values.help), project: positionals[0], ...values };
+  }, argv, io);
+  if (!args) return 0;
+
+  const { projectRoot: root, options } = args;
+  if (options.publish) {
+    const plan = await resolveHarmonyBuildPlanAsync(root, { buildMode: options.variant as 'debug' | 'release' });
+    await publishRuntimeContractAsync(root, plan);
+
+    io.log('Published Harmony runtime capabilities and host validator.');
+  } else {
+    const contract = await resolveRuntimeRequirementsAsync(root);
+
+    if (options.client) {
+      const client = JSON.parse(await fs.promises.readFile(path.resolve(options.client), 'utf8'));
+      assertHarmonyCompatibility(client, contract);
+
+      io.log('Project is compatible with the fixed Harmony client.');
+    } else {
+      io.log(JSON.stringify(contract, null, 2));
+    }
+  }
+
+  return 0;
+};

package/src/start/index.ts

@@ -0,0 +1,37 @@
+import { parseCommandArgs, type Command } from '../command';
+import { parseStartArgs } from './options';
+
+export const command: Command = async (argv, io) => {
+  const args = parseCommandArgs(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.development) {
+      io.log(`Harmony manifest: ${metro.development.manifestUrl}`);
+      io.log(`Harmony JS bundle: ${metro.development.bundleUrl}`);
+      io.log(`Harmony launch link: ${metro.development.launchLink}`);
+    }
+
+    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();
+  }
+};

package/src/start/options.ts

@@ -4,7 +4,9 @@ import { HarmonyCliError } from '../errors';
 const StartOptions = {
   ...CommonOptions,
   'clear': { short: 'c', type: 'boolean' },
+  'host': { type: 'string' },
   'port': { type: 'string' },
+  'private-key-path': { type: 'string' },
   'reset-cache': { type: 'boolean' },
 } as const;
 
@@ -25,9 +27,19 @@ function parseStartArgs(argv: string[]) {
     });
   }
 
+  if (values.host !== undefined && !/^[A-Za-z0-9.-]+$/.test(values.host)) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_CONFIG_INVALID',
+      '--host must be a hostname or IPv4 address without a port or scheme.',
+      { operation: 'parse-arguments' }
+    );
+  }
+
   return {
     help: Boolean(values.help),
+    host: values.host,
     port,
+    privateKeyPath: values['private-key-path'],
     project: positionals[0],
     resetCache: Boolean(values['reset-cache'] || values.clear),
   };

package/src/updates/export.ts

@@ -0,0 +1,60 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import type { ExpoConfigWithHarmony } from '@expo-harmony/config-plugins';
+import { atomicWriteJson } from '../file';
+import { HarmonyCliError } from '../errors';
+import { readProjectRuntimeAsync } from '../runtime/config';
+
+export interface UpdateAsset {
+  key: string;
+  hash: string;
+  contentType: string;
+  fileExtension: string;
+  embeddedAssetFilename: string;
+}
+
+export async function publishUpdatesConfigurationAsync(
+  root: string,
+  directory: string,
+  config: ExpoConfigWithHarmony,
+  runtime: string
+): Promise<void> {
+  const updates = { ...config.updates, runtimeVersion: runtime };
+  if (updates.url) {
+    const url = new URL(updates.url);
+    if (!['http:', 'https:'].includes(url.protocol)) throw new HarmonyCliError('ERR_HARMONY_UPDATES_CONFIG', 'Updates URL must use HTTP or HTTPS.', { operation: 'updates-config' });
+  }
+  if (updates.codeSigningCertificate) {
+    const certificate = await fs.readFile(path.resolve(root, updates.codeSigningCertificate), 'utf8');
+    new crypto.X509Certificate(certificate);
+    updates.codeSigningCertificate = certificate;
+  }
+
+  await atomicWriteJson(updates, path.join(directory, 'expo-updates/config.json'), directory);
+}
+
+export async function publishEmbeddedUpdateAsync(
+  root: string,
+  paths: { rawfileRoot: string; bundle: string; metadataRoot: string },
+  assets: UpdateAsset[]
+): Promise<void> {
+  const project = await readProjectRuntimeAsync(root);
+  const bundle = await fs.readFile(paths.bundle);
+  const hash = crypto.createHash('sha256').update(Uint8Array.from(bundle)).digest('base64url');
+  const directory = path.join(paths.rawfileRoot, 'expo-updates');
+  const id = crypto.randomUUID();
+  const manifest = {
+    id, commitTime: Date.now(),
+    launchAsset: { packagerHash: `bundle-${id}`, hash, type: 'hbc',
+      embeddedAssetFilename: path.relative(paths.rawfileRoot, paths.bundle).split(path.sep).join('/') },
+    assets: [...new Map(assets.map(asset => [asset.key, asset])).values()].map(asset => ({
+      packagerHash: asset.key, hash: asset.hash, type: asset.fileExtension.replace(/^\./, ''),
+      embeddedAssetFilename: asset.embeddedAssetFilename,
+    })),
+  };
+
+  await publishUpdatesConfigurationAsync(root, paths.rawfileRoot, project.config, project.runtimeVersion);
+  await atomicWriteJson(manifest, path.join(directory, 'manifest.json'), paths.rawfileRoot);
+  await atomicWriteJson(manifest, path.join(paths.metadataRoot, 'update.json'), paths.metadataRoot);
+}

package/src/updates/index.ts

@@ -0,0 +1,89 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import { createRequire } from 'node:module';
+import { getConfig } from '@expo/config';
+import path from 'node:path';
+import { CommonOptions, parseArgs } from '../args';
+import { parseCommandArgs, type Command } from '../command';
+import { exportEmbedAsync } from '../exportEmbed/export';
+import { HarmonyCliError } from '../errors';
+import { atomicCopy, atomicWriteJson } from '../file';
+import { assertSafeRelative } from '../path';
+import { resolveExpoCli } from '../expo';
+import { readProjectRuntimeAsync } from '../runtime/config';
+
+export const command: Command = async (argv, io) => {
+  const args = parseCommandArgs((values) => {
+    const { values: options, positionals } = parseArgs({ ...CommonOptions,
+      'output-dir': { type: 'string' }, 'asset-url': { type: 'string' },
+      'private-key-path': { type: 'string' }, 'reset-cache': { type: 'boolean' },
+    }, values);
+    if (positionals.length > 1) throw new HarmonyCliError('ERR_HARMONY_EXPORT_ARGUMENTS', 'Expected at most one project directory.', { operation: 'export' });
+    return { ...options, project: positionals[0], help: Boolean(options.help) };
+  }, argv, io);
+  if (!args) return 0;
+
+  const { projectRoot: root, options } = args;
+  const base = options['asset-url'];
+  if (!base || !['http:', 'https:'].includes(new URL(base).protocol)) {
+    throw new HarmonyCliError('ERR_HARMONY_EXPORT_ARGUMENTS', 'OTA export requires --asset-url with the HTTP(S) directory that will host its assets.', { operation: 'export' });
+  }
+
+  const output = path.resolve(root, options['output-dir'] ?? 'dist');
+  const temporary = await fs.mkdtemp(path.join(os.tmpdir(), 'expo-harmony-update-'));
+
+  try {
+    await exportEmbedAsync(root, { outputDirectory: temporary, resetCache: options['reset-cache'] });
+    const embedded = JSON.parse(await fs.readFile(path.join(temporary, 'update.json'), 'utf8'));
+    const project = await readProjectRuntimeAsync(root);
+    const { exp } = getConfig(root, { isPublicConfig: true });
+    const require = createRequire(resolveExpoCli(root).cliPath);
+    const upstream = createRequire(require.resolve('@expo/cli/package.json'));
+    const mime = upstream('mime-types');
+    const assets = [embedded.launchAsset, ...embedded.assets].map(asset => ({
+      key: asset.packagerHash, hash: asset.hash,
+      contentType: asset.type === 'hbc' ? 'application/javascript' : mime.lookup(asset.type) || 'application/octet-stream',
+      fileExtension: asset.type ? '.' + asset.type : '', embeddedAssetFilename: asset.embeddedAssetFilename,
+    }));
+    const manifest = {
+      id: embedded.id, createdAt: new Date(embedded.commitTime).toISOString(), runtimeVersion: project.runtimeVersion,
+      launchAsset: assets[0], assets: assets.slice(1), metadata: {},
+      extra: { expoClient: exp, eas: { projectId: exp.extra?.eas?.projectId },
+        scopeKey: exp.originalFullName ?? `@${exp.owner ?? 'anonymous'}/${exp.slug}` },
+    };
+    const metadata: { path: string; ext: string }[] = [];
+    for (const asset of assets) {
+      const relative = `assets/${asset.hash}${asset.fileExtension}`;
+      await atomicCopy(path.join(temporary, 'embedded', assertSafeRelative(asset.embeddedAssetFilename, 'Embedded update asset')), path.join(output, relative), output);
+      Object.assign(asset, { url: new URL(relative, base.endsWith('/') ? base : base + '/').href });
+      delete asset.embeddedAssetFilename;
+      if (asset !== manifest.launchAsset) metadata.push({ path: relative, ext: asset.fileExtension.replace(/^\./, '') });
+    }
+    await atomicCopy(path.join(temporary, 'hermes_bundle.hbc.map'), path.join(output, 'bundle.hbc.map'), output);
+    await atomicWriteJson({ version: 0, bundler: 'metro', fileMetadata: { harmony: {
+      bundle: `assets/${manifest.launchAsset.hash}.hbc`, assets: metadata,
+    } } }, path.join(output, 'metadata.json'), output);
+    await atomicWriteJson(manifest, path.join(output, 'manifest.json'), output);
+    if (options['private-key-path']) {
+      const key = await fs.readFile(path.resolve(root, options['private-key-path']), 'utf8');
+      if (crypto.createPrivateKey(key).asymmetricKeyType !== 'rsa') throw new HarmonyCliError('ERR_HARMONY_UPDATES_SIGNING', 'Expo Updates signing requires an RSA private key.', { operation: 'export' });
+
+      const body = await fs.readFile(path.join(output, 'manifest.json'));
+      const signature = crypto.sign('RSA-SHA256', Uint8Array.from(body), key).toString('base64');
+      const id = exp.updates?.codeSigningMetadata?.keyid ?? 'root';
+      const { serializeDictionary } = upstream('structured-headers');
+      await fs.writeFile(path.join(temporary, 'signature.txt'), serializeDictionary(new Map([
+        ['sig', [signature, new Map()]], ['keyid', [id, new Map()]], ['alg', ['rsa-v1_5-sha256', new Map()]],
+      ])));
+      await atomicCopy(path.join(temporary, 'signature.txt'), path.join(output, 'signature.txt'), output);
+    } else {
+      await fs.rm(path.join(output, 'signature.txt'), { force: true });
+    }
+    io.log(`Exported Harmony update ${manifest.id} for runtime ${manifest.runtimeVersion} to ${output}.`);
+  } finally {
+    await fs.rm(temporary, { recursive: true, force: true });
+  }
+
+  return 0;
+};

package/src/buildHap/common.ts

@@ -1,145 +0,0 @@
-import fs from 'node:fs';
-
-import { doctorAsync, type DoctorResult } from '../doctor/doctor';
-import { HarmonyCliError } from '../errors';
-import { checkAsync } from '../prebuild/check';
-import { prebuildParsedAsync } from '../prebuild/prebuild';
-import { formatDiagnostics, spawnAsync } from '../process';
-import { resolveHarmonyBuildPlanIfPresentAsync } from '../tools';
-
-interface HarmonyBuildPipelineOptions {
-  io?: Pick<Console, 'error' | 'log' | 'warn'>;
-  requireDeviceTools?: boolean;
-  /** @internal The caller already completed an isolated prebuild check. */
-  skipGeneratedProjectCheck?: boolean;
-  sync: boolean;
-  variant: 'debug' | 'release';
-}
-
-interface CheckedProcessOptions {
-  code: string;
-  cwd: string;
-  env?: NodeJS.ProcessEnv;
-  message: string;
-  operation: string;
-  outputLimit?: number;
-  timeoutMs?: number;
-}
-
-function progress(options: HarmonyBuildPipelineOptions, message: string): void {
-  options.io?.log?.(`› ${message}`);
-}
-
-async function timed<T>(
-  steps: Record<string, number>,
-  name: string,
-  operation: () => Promise<T> | T
-): Promise<T> {
-  const started = performance.now();
-  try {
-    return await operation();
-  } finally {
-    steps[name] = Math.max(0, Math.round(performance.now() - started));
-  }
-}
-
-function assertDoctor(result: DoctorResult): void {
-  if (result.ok) return;
-
-  const failing = result.checks.filter(check => check.status === 'error').map(check => check.id);
-
-  throw new HarmonyCliError('ERR_HARMONY_DOCTOR_FAILED', `Harmony doctor found blocking checks: ${failing.join(', ') || 'unknown'}.`, { operation: 'doctor' });
-}
-
-function isNonEmptyRegularFile(file: string): boolean {
-  try {
-    const stat = fs.lstatSync(file);
-    return !stat.isSymbolicLink() && stat.isFile() && stat.size > 0;
-  } catch {
-    return false;
-  }
-}
-
-async function runCheckedAsync(
-  command: string,
-  args: string[],
-  options: CheckedProcessOptions
-) {
-  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 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;
-}
-
-async function ensureGeneratedProjectAsync(
-  projectRoot: string,
-  options: HarmonyBuildPipelineOptions,
-  steps: Record<string, number>
-) {
-  const plan = await resolveHarmonyBuildPlanIfPresentAsync(projectRoot, {
-    buildMode: options.variant,
-  });
-  const exists = Boolean(plan && fs.existsSync(plan.harmonyRoot));
-
-  progress(options, 'Checking the Harmony project');
-  const doctor = await timed(steps, 'doctor', () => doctorAsync(projectRoot, {
-    requireBuildTools: true,
-    requireDeviceTools: options.requireDeviceTools,
-    validateGeneratedProject: exists,
-    validateModules: false,
-  }));
-  assertDoctor(doctor);
-
-  if (!exists || options.sync) {
-    progress(options, exists
-      ? 'Synchronizing the generated Harmony project'
-      : 'Generating the missing Harmony project');
-    await timed(steps, 'prebuild', () => prebuildParsedAsync(
-      projectRoot,
-      [],
-      { buildType: options.variant }
-    ));
-    steps.cngCheck = 0;
-    return;
-  }
-
-  steps.prebuild = 0;
-  if (options.skipGeneratedProjectCheck) {
-    steps.cngCheck = 0;
-    return;
-  }
-  progress(options, 'Checking CNG ownership and drift');
-  const check = await timed(steps, 'cngCheck', () => checkAsync(projectRoot, { buildType: options.variant }));
-  if (!check.clean) {
-    const summary = check.changes.slice(0, 8).map(change => `${change.type}:${change.path}`).join(', ');
-    throw new HarmonyCliError(
-      'ERR_HARMONY_MANIFEST_DRIFT',
-      `Generated Harmony files differ from CNG desired state${summary ? ` (${summary})` : ''}. Run expo-harmony prebuild or retry with --sync.`,
-      { operation: 'check' }
-    );
-  }
-}
-
-export {
-  ensureGeneratedProjectAsync,
-  isNonEmptyRegularFile,
-  progress,
-  runCheckedAsync,
-  timed,
-};
-export type { CheckedProcessOptions, HarmonyBuildPipelineOptions };

package/src/run/install.ts

@@ -1,41 +0,0 @@
-import { HarmonyCliError } from '../errors';
-import type { HarmonyBuildPlan, HarmonyToolchain } from '../tools';
-import { formatDiagnostics, spawnAsync, type ProcessResult } from '../process';
-
-interface InstallOptions {
-  timeoutMs?: number;
-}
-
-function installMessage(result: ProcessResult): string {
-  const diagnostics = formatDiagnostics(result);
-  return `OHPM install exited with code ${result.code}${result.timedOut ? ' after timing out' : ''}.`
-    + `${diagnostics ? `\n${diagnostics}` : ''}`;
-}
-
-/** Runs OHPM against the generated project without rewriting its manifest. */
-async function installHarmonyDependenciesAsync(
-  plan: HarmonyBuildPlan,
-  toolchain: HarmonyToolchain,
-  options: InstallOptions = {}
-): Promise<void> {
-  const result = await spawnAsync(
-    toolchain.ohpm.command,
-    [...toolchain.ohpm.args, 'install', '--all'],
-    {
-      capture: true,
-      cwd: plan.harmonyRoot,
-      operation: 'ohpm-install',
-      outputLimit: 2 * 1024 * 1024,
-      timeoutMs: options.timeoutMs || 5 * 60_000,
-    }
-  );
-
-  if (result.code !== 0 || result.timedOut) {
-    throw new HarmonyCliError('ERR_HARMONY_OHPM_FAILED', installMessage(result), {
-      exitCode: result.code || 1,
-      operation: 'ohpm-install',
-    });
-  }
-}
-
-export { installHarmonyDependenciesAsync };