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

package/build/start/options.js

@@ -0,0 +1,38 @@
+"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' },
+    'host': { type: 'string' },
+    'port': { type: 'string' },
+    'private-key-path': { 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',
+        });
+    }
+    if (values.host !== undefined && !/^[A-Za-z0-9.-]+$/.test(values.host)) {
+        throw new errors_1.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/build/updates/export.d.ts

@@ -0,0 +1,14 @@
+import type { ExpoConfigWithHarmony } from '@expo-harmony/config-plugins';
+export interface UpdateAsset {
+    key: string;
+    hash: string;
+    contentType: string;
+    fileExtension: string;
+    embeddedAssetFilename: string;
+}
+export declare function publishUpdatesConfigurationAsync(root: string, directory: string, config: ExpoConfigWithHarmony, runtime: string): Promise<void>;
+export declare function publishEmbeddedUpdateAsync(root: string, paths: {
+    rawfileRoot: string;
+    bundle: string;
+    metadataRoot: string;
+}, assets: UpdateAsset[]): Promise<void>;

package/build/updates/export.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishUpdatesConfigurationAsync = publishUpdatesConfigurationAsync;
+exports.publishEmbeddedUpdateAsync = publishEmbeddedUpdateAsync;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const file_1 = require("../file");
+const errors_1 = require("../errors");
+const config_1 = require("../runtime/config");
+async function publishUpdatesConfigurationAsync(root, directory, config, runtime) {
+    const updates = { ...config.updates, runtimeVersion: runtime };
+    if (updates.url) {
+        const url = new URL(updates.url);
+        if (!['http:', 'https:'].includes(url.protocol))
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_UPDATES_CONFIG', 'Updates URL must use HTTP or HTTPS.', { operation: 'updates-config' });
+    }
+    if (updates.codeSigningCertificate) {
+        const certificate = await promises_1.default.readFile(node_path_1.default.resolve(root, updates.codeSigningCertificate), 'utf8');
+        new node_crypto_1.default.X509Certificate(certificate);
+        updates.codeSigningCertificate = certificate;
+    }
+    await (0, file_1.atomicWriteJson)(updates, node_path_1.default.join(directory, 'expo-updates/config.json'), directory);
+}
+async function publishEmbeddedUpdateAsync(root, paths, assets) {
+    const project = await (0, config_1.readProjectRuntimeAsync)(root);
+    const bundle = await promises_1.default.readFile(paths.bundle);
+    const hash = node_crypto_1.default.createHash('sha256').update(Uint8Array.from(bundle)).digest('base64url');
+    const directory = node_path_1.default.join(paths.rawfileRoot, 'expo-updates');
+    const id = node_crypto_1.default.randomUUID();
+    const manifest = {
+        id, commitTime: Date.now(),
+        launchAsset: { packagerHash: `bundle-${id}`, hash, type: 'hbc',
+            embeddedAssetFilename: node_path_1.default.relative(paths.rawfileRoot, paths.bundle).split(node_path_1.default.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 (0, file_1.atomicWriteJson)(manifest, node_path_1.default.join(directory, 'manifest.json'), paths.rawfileRoot);
+    await (0, file_1.atomicWriteJson)(manifest, node_path_1.default.join(paths.metadataRoot, 'update.json'), paths.metadataRoot);
+}

package/build/updates/index.d.ts

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

package/build/updates/index.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_module_1 = require("node:module");
+const config_1 = require("@expo/config");
+const node_path_1 = __importDefault(require("node:path"));
+const args_1 = require("../args");
+const command_1 = require("../command");
+const export_1 = require("../exportEmbed/export");
+const errors_1 = require("../errors");
+const file_1 = require("../file");
+const path_1 = require("../path");
+const expo_1 = require("../expo");
+const config_2 = require("../runtime/config");
+const command = async (argv, io) => {
+    const args = (0, command_1.parseCommandArgs)((values) => {
+        const { values: options, positionals } = (0, args_1.parseArgs)({ ...args_1.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 errors_1.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 errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_ARGUMENTS', 'OTA export requires --asset-url with the HTTP(S) directory that will host its assets.', { operation: 'export' });
+    }
+    const output = node_path_1.default.resolve(root, options['output-dir'] ?? 'dist');
+    const temporary = await promises_1.default.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'expo-harmony-update-'));
+    try {
+        await (0, export_1.exportEmbedAsync)(root, { outputDirectory: temporary, resetCache: options['reset-cache'] });
+        const embedded = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(temporary, 'update.json'), 'utf8'));
+        const project = await (0, config_2.readProjectRuntimeAsync)(root);
+        const { exp } = (0, config_1.getConfig)(root, { isPublicConfig: true });
+        const require = (0, node_module_1.createRequire)((0, expo_1.resolveExpoCli)(root).cliPath);
+        const upstream = (0, node_module_1.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 = [];
+        for (const asset of assets) {
+            const relative = `assets/${asset.hash}${asset.fileExtension}`;
+            await (0, file_1.atomicCopy)(node_path_1.default.join(temporary, 'embedded', (0, path_1.assertSafeRelative)(asset.embeddedAssetFilename, 'Embedded update asset')), node_path_1.default.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 (0, file_1.atomicCopy)(node_path_1.default.join(temporary, 'hermes_bundle.hbc.map'), node_path_1.default.join(output, 'bundle.hbc.map'), output);
+        await (0, file_1.atomicWriteJson)({ version: 0, bundler: 'metro', fileMetadata: { harmony: {
+                    bundle: `assets/${manifest.launchAsset.hash}.hbc`, assets: metadata,
+                } } }, node_path_1.default.join(output, 'metadata.json'), output);
+        await (0, file_1.atomicWriteJson)(manifest, node_path_1.default.join(output, 'manifest.json'), output);
+        if (options['private-key-path']) {
+            const key = await promises_1.default.readFile(node_path_1.default.resolve(root, options['private-key-path']), 'utf8');
+            if (node_crypto_1.default.createPrivateKey(key).asymmetricKeyType !== 'rsa')
+                throw new errors_1.HarmonyCliError('ERR_HARMONY_UPDATES_SIGNING', 'Expo Updates signing requires an RSA private key.', { operation: 'export' });
+            const body = await promises_1.default.readFile(node_path_1.default.join(output, 'manifest.json'));
+            const signature = node_crypto_1.default.sign('RSA-SHA256', Uint8Array.from(body), key).toString('base64');
+            const id = exp.updates?.codeSigningMetadata?.keyid ?? 'root';
+            const { serializeDictionary } = upstream('structured-headers');
+            await promises_1.default.writeFile(node_path_1.default.join(temporary, 'signature.txt'), serializeDictionary(new Map([
+                ['sig', [signature, new Map()]], ['keyid', [id, new Map()]], ['alg', ['rsa-v1_5-sha256', new Map()]],
+            ])));
+            await (0, file_1.atomicCopy)(node_path_1.default.join(temporary, 'signature.txt'), node_path_1.default.join(output, 'signature.txt'), output);
+        }
+        else {
+            await promises_1.default.rm(node_path_1.default.join(output, 'signature.txt'), { force: true });
+        }
+        io.log(`Exported Harmony update ${manifest.id} for runtime ${manifest.runtimeVersion} to ${output}.`);
+    }
+    finally {
+        await promises_1.default.rm(temporary, { recursive: true, force: true });
+    }
+    return 0;
+};
+exports.command = command;

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 ("@react-native-oh/react-native-harmony" | "@expo-harmony/expo-modules-autolinking" | "@react-native-oh/react-native-harmony-cli")[];
+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.11",
   "keywords": [
     "react-native",
     "expo",
@@ -30,16 +30,32 @@
       "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"
+    },
+    "./internal/development": {
+      "types": "./build/internal/development.d.ts",
+      "require": "./build/internal/development.js",
+      "default": "./build/internal/development.js"
+    }
   },
   "bin": {
     "expo-harmony": "build/bin/expo-harmony.js"
   },
   "dependencies": {
-    "@expo-harmony/config-plugins": "55.0.10-harmony.1",
-    "@expo-harmony/expo-modules-autolinking": "55.0.25-harmony.1",
-    "@expo-harmony/prebuild-config": "55.0.0-harmony.1",
+    "@expo-harmony/config-plugins": "55.0.10-harmony.5",
+    "@expo-harmony/expo-modules-autolinking": "55.0.25-harmony.5",
+    "@expo-harmony/prebuild-config": "55.0.0-harmony.9",
     "@expo/config": "55.0.17",
+    "@expo/fingerprint": "0.16.7",
     "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;
+};