expo-harmony-toolkit 1.5.0

package/build/commands/syncTemplate.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSyncTemplateCommand = runSyncTemplateCommand;
+const path_1 = __importDefault(require("path"));
+const template_1 = require("../core/template");
+async function runSyncTemplateCommand(options) {
+    const projectRoot = path_1.default.resolve(options.projectRoot ?? process.cwd());
+    const result = await (0, template_1.syncProjectTemplate)(projectRoot, Boolean(options.force));
+    const lines = [
+        `Template sync completed for ${projectRoot}`,
+        `- written: ${result.writtenFiles.length}`,
+        `- unchanged: ${result.unchangedFiles.length}`,
+        `- skipped: ${result.skippedFiles.length}`,
+        `- manifest: ${result.manifestPath}`,
+    ];
+    if (result.warnings.length > 0) {
+        lines.push('', 'Warnings:', ...result.warnings.map((warning) => `- ${warning}`));
+    }
+    process.stdout.write(lines.join('\n') + '\n');
+}

package/build/core/build.d.ts

@@ -0,0 +1,25 @@
+import { BuildReport } from '../types';
+export interface CommandRunnerResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export type CommandRunner = (file: string, args: string[], options: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}) => Promise<CommandRunnerResult>;
+interface BundleProjectOptions {
+    env?: NodeJS.ProcessEnv;
+    runner?: CommandRunner;
+    skipTemplateSync?: boolean;
+}
+interface BuildHapProjectOptions {
+    mode: 'debug' | 'release';
+    env?: NodeJS.ProcessEnv;
+    runner?: CommandRunner;
+}
+export declare function bundleProject(projectRoot: string, options?: BundleProjectOptions): Promise<BuildReport>;
+export declare function buildHapProject(projectRoot: string, options: BuildHapProjectOptions): Promise<BuildReport>;
+export declare function renderBuildReport(report: BuildReport): string;
+export declare function getDesiredHarmonyScripts(projectRoot: string): Promise<Record<string, string>>;
+export {};

package/build/core/build.js

@@ -0,0 +1,434 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleProject = bundleProject;
+exports.buildHapProject = buildHapProject;
+exports.renderBuildReport = renderBuildReport;
+exports.getDesiredHarmonyScripts = getDesiredHarmonyScripts;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("./constants");
+const env_1 = require("./env");
+const project_1 = require("./project");
+const template_1 = require("./template");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+async function bundleProject(projectRoot, options = {}) {
+    const runtimeEnv = options.env ?? process.env;
+    const runCommand = options.runner ?? defaultCommandRunner;
+    const loadedProject = await (0, project_1.loadProject)(projectRoot);
+    const bundleOutputPath = path_1.default.join(loadedProject.projectRoot, 'harmony', 'entry', 'src', 'main', 'resources', 'rawfile', 'bundle.harmony.js');
+    const assetsDestPath = path_1.default.join(loadedProject.projectRoot, 'harmony', 'entry', 'src', 'main', 'resources', 'rawfile', 'assets');
+    const entryFileName = (0, template_1.resolveHarmonyBundleEntryFile)(loadedProject.packageJson);
+    const entryFilePath = path_1.default.join(loadedProject.projectRoot, entryFileName);
+    const metroConfigPath = path_1.default.join(loadedProject.projectRoot, 'metro.harmony.config.js');
+    const reactNativeCliPath = path_1.default.join(loadedProject.projectRoot, 'node_modules', 'react-native', 'cli.js');
+    const warnings = [];
+    const blockingIssues = [];
+    if (!options.skipTemplateSync) {
+        const syncResult = await (0, template_1.syncProjectTemplate)(loadedProject.projectRoot, false);
+        warnings.push(...syncResult.warnings);
+    }
+    if (!(await fs_extra_1.default.pathExists(reactNativeCliPath))) {
+        blockingIssues.push({
+            code: 'build.bundle.failed',
+            message: `React Native CLI was not found at ${reactNativeCliPath}. Run your package manager install first.`,
+        });
+    }
+    if (!(await fs_extra_1.default.pathExists(entryFilePath))) {
+        blockingIssues.push({
+            code: 'build.bundle.failed',
+            message: `Expected Harmony entry file ${entryFileName} does not exist yet. Run expo-harmony init first.`,
+        });
+    }
+    if (!(await fs_extra_1.default.pathExists(metroConfigPath))) {
+        blockingIssues.push({
+            code: 'build.bundle.failed',
+            message: 'metro.harmony.config.js is missing. Run expo-harmony init first.',
+        });
+    }
+    const initialReport = createBuildReport({
+        projectRoot: loadedProject.projectRoot,
+        command: 'bundle',
+        mode: null,
+        status: blockingIssues.length === 0 ? 'succeeded' : 'failed',
+        entryFile: entryFilePath,
+        bundleOutputPath,
+        assetsDestPath,
+        artifactPaths: [],
+        blockingIssues,
+        warnings,
+        steps: [],
+    });
+    if (blockingIssues.length > 0) {
+        initialReport.status = 'failed';
+        return initialReport;
+    }
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(bundleOutputPath));
+    await fs_extra_1.default.ensureDir(assetsDestPath);
+    const bundleEnvironment = { ...runtimeEnv };
+    if ((0, template_1.usesExpoRouter)(loadedProject.packageJson)) {
+        bundleEnvironment.EXPO_ROUTER_APP_ROOT = bundleEnvironment.EXPO_ROUTER_APP_ROOT ?? 'app';
+    }
+    const bundleArgs = [
+        reactNativeCliPath,
+        'bundle-harmony',
+        '--reset-cache',
+        '--dev',
+        'false',
+        '--entry-file',
+        entryFilePath,
+        '--bundle-output',
+        bundleOutputPath,
+        '--assets-dest',
+        assetsDestPath,
+        '--config',
+        metroConfigPath,
+    ];
+    const bundleCommand = buildInvocation(process.execPath, bundleArgs);
+    const bundleResult = await runCommand(bundleCommand.file, bundleCommand.args, {
+        cwd: loadedProject.projectRoot,
+        env: bundleEnvironment,
+    });
+    const steps = [
+        createStepReport('bundle-harmony', bundleCommand.file, bundleCommand.args, loadedProject.projectRoot, bundleResult.exitCode),
+    ];
+    if (bundleResult.exitCode !== 0 || !(await fs_extra_1.default.pathExists(bundleOutputPath))) {
+        return createBuildReport({
+            projectRoot: loadedProject.projectRoot,
+            command: 'bundle',
+            mode: null,
+            status: 'failed',
+            entryFile: entryFilePath,
+            bundleOutputPath,
+            assetsDestPath,
+            artifactPaths: [],
+            blockingIssues: [
+                {
+                    code: 'build.bundle.failed',
+                    message: bundleResult.stderr.trim() ||
+                        bundleResult.stdout.trim() ||
+                        'react-native bundle-harmony failed before bundle.harmony.js was produced.',
+                },
+            ],
+            warnings,
+            steps,
+        });
+    }
+    return createBuildReport({
+        projectRoot: loadedProject.projectRoot,
+        command: 'bundle',
+        mode: null,
+        status: 'succeeded',
+        entryFile: entryFilePath,
+        bundleOutputPath,
+        assetsDestPath,
+        artifactPaths: [bundleOutputPath],
+        blockingIssues: [],
+        warnings,
+        steps,
+    });
+}
+async function buildHapProject(projectRoot, options) {
+    const runtimeEnv = options.env ?? process.env;
+    const runCommand = options.runner ?? defaultCommandRunner;
+    const loadedProject = await (0, project_1.loadProject)(projectRoot);
+    const envReport = await (0, env_1.buildEnvReport)(loadedProject.projectRoot, {
+        env: runtimeEnv,
+    });
+    const warnings = [
+        ...envReport.warnings.filter((warning) => !warning.startsWith('Harmony sidecar files are not present yet.')),
+        ...envReport.advisories.map((issue) => `${issue.code}: ${issue.message}`),
+    ];
+    const blockingIssues = [];
+    if (!envReport.hvigorPath) {
+        blockingIssues.push({
+            code: 'build.hap.failed',
+            message: 'Hvigor is not available. Run expo-harmony env to inspect the local DevEco setup.',
+        });
+    }
+    if (!envReport.ohpmPath) {
+        blockingIssues.push({
+            code: 'build.hap.failed',
+            message: 'ohpm is not available. CLI HAP builds require the DevEco package manager.',
+        });
+    }
+    if (options.mode === 'release' && !envReport.signingConfigured) {
+        blockingIssues.push({
+            code: 'env.signing.missing',
+            message: 'Release HAP builds require signingConfigs in harmony/build-profile.json5.',
+        });
+    }
+    if (blockingIssues.length > 0) {
+        return createBuildReport({
+            projectRoot: loadedProject.projectRoot,
+            command: 'build-hap',
+            mode: options.mode,
+            status: 'failed',
+            entryFile: path_1.default.join(loadedProject.projectRoot, (0, template_1.resolveHarmonyBundleEntryFile)(loadedProject.packageJson)),
+            bundleOutputPath: getBundleOutputPath(loadedProject.projectRoot),
+            assetsDestPath: getAssetsOutputPath(loadedProject.projectRoot),
+            artifactPaths: [],
+            blockingIssues,
+            warnings,
+            steps: [],
+        });
+    }
+    const bundleReport = await bundleProject(loadedProject.projectRoot, {
+        env: runtimeEnv,
+        runner: runCommand,
+    });
+    const harmonyProjectRoot = envReport.harmonyProjectRoot ?? path_1.default.join(loadedProject.projectRoot, 'harmony');
+    if (bundleReport.status === 'failed') {
+        return createBuildReport({
+            projectRoot: loadedProject.projectRoot,
+            command: 'build-hap',
+            mode: options.mode,
+            status: 'failed',
+            harmonyProjectRoot,
+            entryFile: bundleReport.entryFile,
+            bundleOutputPath: bundleReport.bundleOutputPath,
+            assetsDestPath: bundleReport.assetsDestPath,
+            artifactPaths: [],
+            blockingIssues: bundleReport.blockingIssues,
+            warnings: [...warnings, ...bundleReport.warnings],
+            steps: bundleReport.steps,
+        });
+    }
+    if (!(await fs_extra_1.default.pathExists(harmonyProjectRoot))) {
+        return createBuildReport({
+            projectRoot: loadedProject.projectRoot,
+            command: 'build-hap',
+            mode: options.mode,
+            status: 'failed',
+            harmonyProjectRoot,
+            entryFile: bundleReport.entryFile,
+            bundleOutputPath: bundleReport.bundleOutputPath,
+            assetsDestPath: bundleReport.assetsDestPath,
+            artifactPaths: [],
+            blockingIssues: [
+                {
+                    code: 'build.hap.failed',
+                    message: 'Harmony sidecar files are still missing after bundle sync. Run expo-harmony init --force to inspect template drift.',
+                },
+            ],
+            warnings: [...warnings, ...bundleReport.warnings],
+            steps: bundleReport.steps,
+        });
+    }
+    const steps = [...bundleReport.steps];
+    const buildEnvironment = createHarmonyBuildEnvironment(runtimeEnv, envReport);
+    const ohpmCommand = buildInvocation(envReport.ohpmPath, ['install', '--all']);
+    const ohpmResult = await runCommand(ohpmCommand.file, ohpmCommand.args, {
+        cwd: harmonyProjectRoot,
+        env: buildEnvironment,
+    });
+    steps.push(createStepReport('ohpm install', ohpmCommand.file, ohpmCommand.args, harmonyProjectRoot, ohpmResult.exitCode));
+    if (ohpmResult.exitCode !== 0) {
+        return createBuildReport({
+            projectRoot: loadedProject.projectRoot,
+            command: 'build-hap',
+            mode: options.mode,
+            status: 'failed',
+            harmonyProjectRoot,
+            entryFile: bundleReport.entryFile,
+            bundleOutputPath: bundleReport.bundleOutputPath,
+            assetsDestPath: bundleReport.assetsDestPath,
+            artifactPaths: [],
+            blockingIssues: [
+                {
+                    code: 'build.hap.failed',
+                    message: ohpmResult.stderr.trim() ||
+                        ohpmResult.stdout.trim() ||
+                        'ohpm install failed before the HAP build could start.',
+                },
+            ],
+            warnings: [...warnings, ...bundleReport.warnings],
+            steps,
+        });
+    }
+    const hvigorCommand = buildInvocation(envReport.hvigorPath, [
+        'assembleHap',
+        '--no-daemon',
+        '-p',
+        'product=default',
+        '-p',
+        `buildMode=${options.mode}`,
+    ]);
+    const hvigorResult = await runCommand(hvigorCommand.file, hvigorCommand.args, {
+        cwd: harmonyProjectRoot,
+        env: buildEnvironment,
+    });
+    steps.push(createStepReport('hvigor assembleHap', hvigorCommand.file, hvigorCommand.args, harmonyProjectRoot, hvigorResult.exitCode));
+    const artifactPaths = await findHarmonyArtifacts(harmonyProjectRoot);
+    if (hvigorResult.exitCode !== 0 || artifactPaths.length === 0) {
+        return createBuildReport({
+            projectRoot: loadedProject.projectRoot,
+            command: 'build-hap',
+            mode: options.mode,
+            status: 'failed',
+            harmonyProjectRoot,
+            entryFile: bundleReport.entryFile,
+            bundleOutputPath: bundleReport.bundleOutputPath,
+            assetsDestPath: bundleReport.assetsDestPath,
+            artifactPaths,
+            blockingIssues: [
+                {
+                    code: 'build.hap.failed',
+                    message: hvigorResult.stderr.trim() ||
+                        hvigorResult.stdout.trim() ||
+                        'Hvigor finished without producing any HAP artifacts.',
+                },
+            ],
+            warnings: [...warnings, ...bundleReport.warnings],
+            steps,
+        });
+    }
+    return createBuildReport({
+        projectRoot: loadedProject.projectRoot,
+        command: 'build-hap',
+        mode: options.mode,
+        status: 'succeeded',
+        harmonyProjectRoot,
+        entryFile: bundleReport.entryFile,
+        bundleOutputPath: bundleReport.bundleOutputPath,
+        assetsDestPath: bundleReport.assetsDestPath,
+        artifactPaths,
+        blockingIssues: [],
+        warnings: [...warnings, ...bundleReport.warnings],
+        steps,
+    });
+}
+function renderBuildReport(report) {
+    const lines = [
+        'Expo Harmony build report',
+        `Project: ${report.projectRoot}`,
+        `Command: ${report.command}`,
+        `Mode: ${report.mode ?? 'n/a'}`,
+        `Status: ${report.status}`,
+        `Harmony project: ${report.harmonyProjectRoot ?? 'not found'}`,
+        `Entry file: ${report.entryFile ?? 'n/a'}`,
+        `Bundle output: ${report.bundleOutputPath ?? 'n/a'}`,
+        `Artifacts: ${report.artifactPaths.join(', ') || 'none'}`,
+        '',
+        'Steps:',
+        ...report.steps.map((step) => `- [${step.exitCode ?? 'n/a'}] ${step.label}: ${step.command} (cwd ${step.cwd})`),
+    ];
+    if (report.blockingIssues.length > 0) {
+        lines.push('', 'Blocking issues:', ...report.blockingIssues.map((issue) => `- ${issue.code}: ${issue.message}${issue.subject ? ` (${issue.subject})` : ''}`));
+    }
+    if (report.warnings.length > 0) {
+        lines.push('', 'Warnings:', ...report.warnings.map((warning) => `- ${warning}`));
+    }
+    return lines.join('\n');
+}
+function getBundleOutputPath(projectRoot) {
+    return path_1.default.join(projectRoot, 'harmony', 'entry', 'src', 'main', 'resources', 'rawfile', 'bundle.harmony.js');
+}
+function getAssetsOutputPath(projectRoot) {
+    return path_1.default.join(projectRoot, 'harmony', 'entry', 'src', 'main', 'resources', 'rawfile', 'assets');
+}
+function createBuildReport(input) {
+    return {
+        generatedAt: new Date().toISOString(),
+        projectRoot: input.projectRoot,
+        toolkitVersion: constants_1.TOOLKIT_VERSION,
+        command: input.command,
+        mode: input.mode,
+        status: input.status,
+        harmonyProjectRoot: input.harmonyProjectRoot ?? path_1.default.join(input.projectRoot, 'harmony'),
+        entryFile: input.entryFile,
+        bundleOutputPath: input.bundleOutputPath,
+        assetsDestPath: input.assetsDestPath,
+        artifactPaths: input.artifactPaths,
+        blockingIssues: input.blockingIssues,
+        warnings: input.warnings,
+        steps: input.steps,
+    };
+}
+function createStepReport(label, file, args, cwd, exitCode) {
+    return {
+        label,
+        command: [file, ...args].join(' '),
+        cwd,
+        exitCode,
+    };
+}
+function buildInvocation(file, args) {
+    if (file.endsWith('.js')) {
+        return {
+            file: process.execPath,
+            args: [file, ...args],
+        };
+    }
+    return {
+        file,
+        args,
+    };
+}
+function createHarmonyBuildEnvironment(runtimeEnv, envReport) {
+    const buildEnvironment = {
+        ...runtimeEnv,
+    };
+    if (envReport.sdkRoot) {
+        buildEnvironment.DEVECO_SDK_HOME = envReport.sdkRoot;
+        buildEnvironment.OHOS_BASE_SDK_HOME = envReport.sdkRoot;
+    }
+    if (envReport.devecoStudioPath) {
+        buildEnvironment.NODE_HOME =
+            buildEnvironment.NODE_HOME ??
+                path_1.default.join(envReport.devecoStudioPath, 'Contents', 'tools', 'node');
+    }
+    return buildEnvironment;
+}
+async function findHarmonyArtifacts(harmonyProjectRoot) {
+    const discoveredPaths = [];
+    await walkDirectory(harmonyProjectRoot, async (entryPath) => {
+        if (entryPath.endsWith('.hap') || entryPath.endsWith('.app') || entryPath.endsWith('.hsp')) {
+            discoveredPaths.push(entryPath);
+        }
+    });
+    return discoveredPaths.sort((left, right) => left.localeCompare(right));
+}
+async function walkDirectory(currentPath, visitor) {
+    if (!(await fs_extra_1.default.pathExists(currentPath))) {
+        return;
+    }
+    const entries = await fs_extra_1.default.readdir(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const nextPath = path_1.default.join(currentPath, entry.name);
+        if (entry.isDirectory()) {
+            await walkDirectory(nextPath, visitor);
+            continue;
+        }
+        await visitor(nextPath);
+    }
+}
+async function defaultCommandRunner(file, args, options) {
+    try {
+        const result = await execFileAsync(file, args, {
+            cwd: options.cwd,
+            env: options.env,
+            maxBuffer: 20 * 1024 * 1024,
+        });
+        return {
+            exitCode: 0,
+            stdout: result.stdout,
+            stderr: result.stderr,
+        };
+    }
+    catch (error) {
+        const failed = error;
+        return {
+            exitCode: typeof failed.code === 'number' ? failed.code : 1,
+            stdout: failed.stdout ?? '',
+            stderr: failed.stderr ?? failed.message ?? '',
+        };
+    }
+}
+function getDesiredHarmonyScripts(projectRoot) {
+    return (0, project_1.loadProject)(projectRoot).then((loadedProject) => (0, template_1.buildDesiredPackageScripts)(loadedProject.packageJson));
+}

package/build/core/constants.d.ts

@@ -0,0 +1,21 @@
+export declare const TOOLKIT_PACKAGE_NAME = "expo-harmony-toolkit";
+export declare const CLI_NAME = "expo-harmony";
+export declare const TOOLKIT_VERSION = "1.5.0";
+export declare const TEMPLATE_VERSION = "rnoh-0.82.18";
+export declare const RNOH_VERSION = "0.82.18";
+export declare const RNOH_CLI_VERSION = "0.82.18";
+export declare const SUPPORTED_EXPO_SDKS: number[];
+export declare const GENERATED_DIR = ".expo-harmony";
+export declare const GENERATED_SHIMS_DIR = ".expo-harmony/shims";
+export declare const MANIFEST_FILENAME = "manifest.json";
+export declare const DOCTOR_REPORT_FILENAME = "doctor-report.json";
+export declare const ENV_REPORT_FILENAME = "env-report.json";
+export declare const BUILD_REPORT_FILENAME = "build-report.json";
+export declare const TOOLKIT_CONFIG_FILENAME = "toolkit-config.json";
+export declare const PREBUILD_METADATA_FILENAME = "prebuild-metadata.json";
+export declare const DEFAULT_HVIGOR_PLUGIN_FILENAME = "rnoh-hvigor-plugin-0.82.18.tgz";
+export declare const STRICT_DOCTOR_EXIT_CODE = 2;
+export declare const STRICT_ENV_EXIT_CODE = 3;
+export declare const HARMONY_ROUTER_ENTRY_FILENAME = "index.harmony.js";
+export declare const HARMONY_RUNTIME_PRELUDE_RELATIVE_PATH = ".expo-harmony/shims/runtime-prelude.js";
+export declare const DESIRED_PACKAGE_SCRIPTS: Record<string, string>;

package/build/core/constants.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DESIRED_PACKAGE_SCRIPTS = exports.HARMONY_RUNTIME_PRELUDE_RELATIVE_PATH = exports.HARMONY_ROUTER_ENTRY_FILENAME = exports.STRICT_ENV_EXIT_CODE = exports.STRICT_DOCTOR_EXIT_CODE = exports.DEFAULT_HVIGOR_PLUGIN_FILENAME = exports.PREBUILD_METADATA_FILENAME = exports.TOOLKIT_CONFIG_FILENAME = exports.BUILD_REPORT_FILENAME = exports.ENV_REPORT_FILENAME = exports.DOCTOR_REPORT_FILENAME = exports.MANIFEST_FILENAME = exports.GENERATED_SHIMS_DIR = exports.GENERATED_DIR = exports.SUPPORTED_EXPO_SDKS = exports.RNOH_CLI_VERSION = exports.RNOH_VERSION = exports.TEMPLATE_VERSION = exports.TOOLKIT_VERSION = exports.CLI_NAME = exports.TOOLKIT_PACKAGE_NAME = void 0;
+exports.TOOLKIT_PACKAGE_NAME = 'expo-harmony-toolkit';
+exports.CLI_NAME = 'expo-harmony';
+exports.TOOLKIT_VERSION = '1.5.0';
+exports.TEMPLATE_VERSION = 'rnoh-0.82.18';
+exports.RNOH_VERSION = '0.82.18';
+exports.RNOH_CLI_VERSION = '0.82.18';
+exports.SUPPORTED_EXPO_SDKS = [53, 55];
+exports.GENERATED_DIR = '.expo-harmony';
+exports.GENERATED_SHIMS_DIR = `${exports.GENERATED_DIR}/shims`;
+exports.MANIFEST_FILENAME = 'manifest.json';
+exports.DOCTOR_REPORT_FILENAME = 'doctor-report.json';
+exports.ENV_REPORT_FILENAME = 'env-report.json';
+exports.BUILD_REPORT_FILENAME = 'build-report.json';
+exports.TOOLKIT_CONFIG_FILENAME = 'toolkit-config.json';
+exports.PREBUILD_METADATA_FILENAME = 'prebuild-metadata.json';
+exports.DEFAULT_HVIGOR_PLUGIN_FILENAME = `rnoh-hvigor-plugin-${exports.RNOH_CLI_VERSION}.tgz`;
+exports.STRICT_DOCTOR_EXIT_CODE = 2;
+exports.STRICT_ENV_EXIT_CODE = 3;
+exports.HARMONY_ROUTER_ENTRY_FILENAME = 'index.harmony.js';
+exports.HARMONY_RUNTIME_PRELUDE_RELATIVE_PATH = `${exports.GENERATED_SHIMS_DIR}/runtime-prelude.js`;
+exports.DESIRED_PACKAGE_SCRIPTS = {
+    'harmony:doctor': 'expo-harmony doctor',
+    'harmony:init': 'expo-harmony init',
+    'harmony:sync-template': 'expo-harmony sync-template',
+    'harmony:env': 'expo-harmony env',
+    'harmony:bundle': 'expo-harmony bundle',
+    'harmony:build:debug': 'expo-harmony build-hap --mode debug',
+    'harmony:build:release': 'expo-harmony build-hap --mode release',
+};

package/build/core/env.d.ts

@@ -0,0 +1,8 @@
+import { EnvReport } from '../types';
+interface BuildEnvReportOptions {
+    env?: NodeJS.ProcessEnv;
+}
+export declare function buildEnvReport(projectRoot: string, options?: BuildEnvReportOptions): Promise<EnvReport>;
+export declare function renderEnvReport(report: EnvReport): string;
+export declare function getStrictEnvExitCode(): number;
+export {};