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

package/build/process.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDiagnostics = formatDiagnostics;
+exports.spawnAsync = spawnAsync;
+exports.startManagedProcess = startManagedProcess;
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const errors_1 = require("./errors");
+const DefaultOutputLimit = 1024 * 1024;
+const DefaultStopGraceMs = 3_000;
+class BoundedCapture {
+    limit;
+    buffers = [];
+    head = 0;
+    length = 0;
+    constructor(limit) {
+        this.limit = limit;
+    }
+    append(value) {
+        const buffer = typeof value === 'string' ? new TextEncoder().encode(value) : Uint8Array.from(value);
+        if (buffer.length >= this.limit) {
+            this.buffers = [buffer.subarray(buffer.length - this.limit)];
+            this.head = 0;
+            this.length = this.limit;
+            return;
+        }
+        while (this.length + buffer.length > this.limit && this.head < this.buffers.length) {
+            const first = this.buffers[this.head];
+            const excess = this.length + buffer.length - this.limit;
+            if (first.length > excess) {
+                this.buffers[this.head] = first.subarray(excess);
+                this.length -= excess;
+                break;
+            }
+            this.length -= first.length;
+            this.head += 1;
+        }
+        this.buffers.push(buffer);
+        this.length += buffer.length;
+        if (this.head > 128 && this.head * 2 > this.buffers.length) {
+            this.buffers = this.buffers.slice(this.head);
+            this.head = 0;
+        }
+    }
+    toString() {
+        return Buffer.concat(this.buffers.slice(this.head), this.length).toString('utf8');
+    }
+}
+function formatDiagnostics(result, limit = 4_000) {
+    return (result.stderr || result.stdout || '').slice(-limit).trim();
+}
+function spawnAsync(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const piped = Boolean(options.capture || options.onStdout || options.onStderr);
+        const outputLimit = options.outputLimit || DefaultOutputLimit;
+        const child = (0, cross_spawn_1.default)(command, args, {
+            cwd: options.cwd,
+            env: options.env || process.env,
+            shell: false,
+            stdio: piped ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+            windowsHide: true,
+        });
+        const stdout = new BoundedCapture(outputLimit);
+        const stderr = new BoundedCapture(outputLimit);
+        let timedOut = false;
+        let settled = false;
+        let forceKillTimer = null;
+        if (piped) {
+            child.stdout.on('data', (chunk) => {
+                stdout.append(chunk);
+                options.onStdout?.(chunk);
+            });
+            child.stderr.on('data', (chunk) => {
+                stderr.append(chunk);
+                options.onStderr?.(chunk);
+            });
+        }
+        const stopChild = (signal = 'SIGTERM') => {
+            child.kill(signal);
+            if (forceKillTimer === null) {
+                forceKillTimer = setTimeout(() => child.kill('SIGKILL'), options.stopGraceMs || DefaultStopGraceMs);
+                forceKillTimer.unref?.();
+            }
+        };
+        const forwardSigint = () => stopChild('SIGINT');
+        const forwardSigterm = () => stopChild('SIGTERM');
+        process.once('SIGINT', forwardSigint);
+        process.once('SIGTERM', forwardSigterm);
+        const timeout = options.timeoutMs
+            ? setTimeout(() => {
+                timedOut = true;
+                stopChild('SIGTERM');
+            }, options.timeoutMs)
+            : null;
+        timeout?.unref?.();
+        const cleanup = () => {
+            if (timeout)
+                clearTimeout(timeout);
+            if (forceKillTimer)
+                clearTimeout(forceKillTimer);
+            process.removeListener('SIGINT', forwardSigint);
+            process.removeListener('SIGTERM', forwardSigterm);
+            options.signal?.removeEventListener('abort', abort);
+        };
+        const abort = () => stopChild('SIGTERM');
+        if (options.signal?.aborted)
+            abort();
+        else
+            options.signal?.addEventListener('abort', abort, { once: true });
+        child.once('error', (cause) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(new errors_1.HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot launch ${command}: ${cause.message}`, {
+                cause,
+                operation: options.operation || 'spawn',
+            }));
+        });
+        // `close` runs after stdout/stderr have closed, so captured diagnostics are
+        // complete. `exit` can fire while pipe data is still pending.
+        child.once('close', (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve({
+                code: code === null ? 1 : code,
+                signal,
+                stderr: stderr.toString(),
+                stdout: stdout.toString(),
+                timedOut,
+            });
+        });
+    });
+}
+function startManagedProcess(command, args, options = {}) {
+    const outputLimit = options.outputLimit || DefaultOutputLimit;
+    const piped = options.stdio !== 'inherit';
+    const child = (0, cross_spawn_1.default)(command, args, {
+        cwd: options.cwd,
+        env: options.env || process.env,
+        shell: false,
+        stdio: piped ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+        windowsHide: true,
+    });
+    const stdout = new BoundedCapture(outputLimit);
+    const stderr = new BoundedCapture(outputLimit);
+    let spawnError = null;
+    let closed = false;
+    let stopRequested = false;
+    if (piped) {
+        child.stdout.on('data', (chunk) => {
+            stdout.append(chunk);
+            options.onStdout?.(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr.append(chunk);
+            options.onStderr?.(chunk);
+        });
+    }
+    const forwardSigint = () => {
+        void stop('SIGINT');
+    };
+    const forwardSigterm = () => {
+        void stop('SIGTERM');
+    };
+    const abort = () => {
+        void stop('SIGTERM');
+    };
+    const cleanup = () => {
+        process.removeListener('SIGINT', forwardSigint);
+        process.removeListener('SIGTERM', forwardSigterm);
+        options.signal?.removeEventListener('abort', abort);
+    };
+    const completion = new Promise((resolve, reject) => {
+        child.once('error', (cause) => {
+            spawnError = new errors_1.HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot launch ${command}: ${cause.message}`, {
+                cause,
+                operation: options.operation || 'spawn',
+            });
+        });
+        child.once('close', (code, signal) => {
+            closed = true;
+            cleanup();
+            if (spawnError)
+                reject(spawnError);
+            else
+                resolve({
+                    code: code === null ? 1 : code,
+                    signal,
+                    stderr: stderr.toString(),
+                    stdout: stdout.toString(),
+                    timedOut: false,
+                });
+        });
+    });
+    // A readiness probe may be the first consumer. Keep early spawn failures from
+    // becoming unhandled rejections while the probe is still polling.
+    completion.catch(() => { });
+    async function stop(signal = 'SIGTERM', graceMs = DefaultStopGraceMs) {
+        if (closed)
+            return completion;
+        stopRequested = true;
+        child.kill(signal);
+        let timer;
+        await Promise.race([
+            completion.catch(() => undefined),
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, graceMs);
+                timer.unref?.();
+            }),
+        ]);
+        if (timer)
+            clearTimeout(timer);
+        if (!closed)
+            child.kill('SIGKILL');
+        return completion.catch(() => undefined);
+    }
+    process.once('SIGINT', forwardSigint);
+    process.once('SIGTERM', forwardSigterm);
+    if (options.signal?.aborted)
+        abort();
+    else
+        options.signal?.addEventListener('abort', abort, { once: true });
+    return {
+        child,
+        completion,
+        getStderr: () => stderr.toString(),
+        getStdout: () => stdout.toString(),
+        stop,
+        wasStopped: () => stopRequested,
+    };
+}

package/build/project.d.ts

@@ -0,0 +1,2 @@
+declare function resolveProject(start?: string): string;
+export { resolveProject };

package/build/project.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.resolveProject = resolveProject;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+function resolveProject(start = process.cwd()) {
+    let current = node_path_1.default.resolve(start);
+    if (node_fs_1.default.existsSync(current) && node_fs_1.default.statSync(current).isFile())
+        current = node_path_1.default.dirname(current);
+    while (true) {
+        if (node_fs_1.default.existsSync(node_path_1.default.join(current, 'package.json')))
+            return node_fs_1.default.realpathSync(current);
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `No package.json was found from ${start}.`, { operation: 'resolve-project' });
+}

package/build/projectLock.d.ts

@@ -0,0 +1,2 @@
+declare function withHarmonyProjectLockAsync<T>(projectRoot: string, operation: string, callback: () => Promise<T> | T): Promise<T>;
+export { withHarmonyProjectLockAsync };

package/build/projectLock.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withHarmonyProjectLockAsync = withHarmonyProjectLockAsync;
+const node_async_hooks_1 = require("node:async_hooks");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const DefaultMalformedLockGraceMs = 30_000;
+const DefaultPollIntervalMs = 100;
+const DefaultWaitTimeoutMs = 5_000;
+const LockRelativePath = '.expo/harmony/native-operation.lock';
+const ActiveLock = new node_async_hooks_1.AsyncLocalStorage();
+async function canonicalProjectRootAsync(projectRoot) {
+    try {
+        return await node_fs_1.default.promises.realpath(node_path_1.default.resolve(projectRoot));
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_PROJECT_LOCK', 'Cannot resolve the application project before acquiring its Harmony native operation lock.', { cause, operation: 'project-lock' });
+    }
+}
+function projectLockPath(projectRoot) {
+    return node_path_1.default.join(projectRoot, ...LockRelativePath.split('/'));
+}
+async function processIsAliveAsync(pid) {
+    if (!Number.isInteger(pid) || Number(pid) <= 0)
+        return false;
+    try {
+        process.kill(Number(pid), 0);
+        return true;
+    }
+    catch (cause) {
+        return cause?.code !== 'ESRCH';
+    }
+}
+async function readLockOwnerAsync(lockPath) {
+    try {
+        const candidate = JSON.parse(await node_fs_1.default.promises.readFile(lockPath, 'utf8'));
+        if (!candidate
+            || typeof candidate !== 'object'
+            || !Number.isInteger(candidate.pid)
+            || candidate.pid <= 0
+            || typeof candidate.createdAt !== 'string'
+            || typeof candidate.operation !== 'string'
+            || typeof candidate.projectRoot !== 'string'
+            || typeof candidate.token !== 'string') {
+            return null;
+        }
+        return candidate;
+    }
+    catch (_cause) {
+        return null;
+    }
+}
+async function removeStaleProjectLockAsync(lockPath) {
+    let observed;
+    try {
+        observed = await node_fs_1.default.promises.lstat(lockPath);
+    }
+    catch (_cause) {
+        return false;
+    }
+    if (!observed.isFile() || observed.isSymbolicLink())
+        return false;
+    const owner = await readLockOwnerAsync(lockPath);
+    if (owner) {
+        if (await processIsAliveAsync(owner.pid))
+            return false;
+    }
+    else if (Date.now() - observed.mtimeMs < DefaultMalformedLockGraceMs) {
+        return false;
+    }
+    try {
+        const current = await node_fs_1.default.promises.lstat(lockPath);
+        if (!current.isFile() || current.isSymbolicLink()
+            || current.dev !== observed.dev
+            || current.ino !== observed.ino
+            || current.mtimeMs !== observed.mtimeMs
+            || current.size !== observed.size) {
+            return false;
+        }
+        await node_fs_1.default.promises.unlink(lockPath);
+        return true;
+    }
+    catch (_cause) {
+        return false;
+    }
+}
+async function releaseOwnedLockAsync(handle, lockPath, owned) {
+    await handle.close().catch(() => { });
+    if (!owned)
+        return false;
+    try {
+        const current = await node_fs_1.default.promises.lstat(lockPath);
+        if (!current.isFile() || current.isSymbolicLink()
+            || current.dev !== owned.dev || current.ino !== owned.ino) {
+            return false;
+        }
+        await node_fs_1.default.promises.unlink(lockPath);
+        return true;
+    }
+    catch (_cause) {
+        return false;
+    }
+}
+function delayAsync(milliseconds) {
+    return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+async function acquireHarmonyProjectLockAsync(projectRoot, operation) {
+    const canonicalRoot = await canonicalProjectRootAsync(projectRoot);
+    const lockPath = projectLockPath(canonicalRoot);
+    const deadline = Date.now() + DefaultWaitTimeoutMs;
+    await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(lockPath), { recursive: true });
+    while (true) {
+        try {
+            const handle = await node_fs_1.default.promises.open(lockPath, 'wx', 0o600);
+            let owned;
+            const owner = {
+                createdAt: new Date().toISOString(),
+                operation,
+                pid: process.pid,
+                projectRoot: canonicalRoot,
+                token: node_crypto_1.default.randomUUID(),
+            };
+            try {
+                owned = await handle.stat();
+                await handle.writeFile(`${JSON.stringify(owner)}\n`);
+                await handle.sync();
+            }
+            catch (cause) {
+                await releaseOwnedLockAsync(handle, lockPath, owned);
+                throw new errors_1.HarmonyCliError('ERR_HARMONY_PROJECT_LOCK', 'Cannot initialize the Harmony native operation lock.', { cause, operation: 'project-lock' });
+            }
+            let released = false;
+            return {
+                async releaseAsync() {
+                    if (released)
+                        return;
+                    released = true;
+                    if (await releaseOwnedLockAsync(handle, lockPath, owned))
+                        return;
+                    throw new errors_1.HarmonyCliError('ERR_HARMONY_PROJECT_LOCK', 'The Harmony native operation lock changed before it could be released safely.', { operation: 'project-lock' });
+                },
+            };
+        }
+        catch (cause) {
+            if (cause instanceof errors_1.HarmonyCliError)
+                throw cause;
+            if (cause?.code !== 'EEXIST') {
+                throw new errors_1.HarmonyCliError('ERR_HARMONY_PROJECT_LOCK', 'Cannot acquire the Harmony native operation lock.', { cause, operation: 'project-lock' });
+            }
+            if (await removeStaleProjectLockAsync(lockPath))
+                continue;
+            if (Date.now() >= deadline) {
+                const owner = await readLockOwnerAsync(lockPath);
+                const detail = owner?.operation ? ` (${owner.operation}, pid ${owner.pid})` : '';
+                throw new errors_1.HarmonyCliError('ERR_HARMONY_PROJECT_BUSY', `Another Harmony native operation is using this project${detail}. Retry after it finishes.`, { operation });
+            }
+            await delayAsync(Math.min(DefaultPollIntervalMs, Math.max(1, deadline - Date.now())));
+        }
+    }
+}
+async function withHarmonyProjectLockAsync(projectRoot, operation, callback) {
+    const canonicalRoot = await canonicalProjectRootAsync(projectRoot);
+    const active = ActiveLock.getStore();
+    if (active?.projectRoot === canonicalRoot && !active.released)
+        return await callback();
+    const lease = await acquireHarmonyProjectLockAsync(canonicalRoot, operation);
+    const context = { projectRoot: canonicalRoot, released: false };
+    try {
+        return await ActiveLock.run(context, callback);
+    }
+    finally {
+        context.released = true;
+        await lease.releaseAsync();
+    }
+}

package/build/run/cache.d.ts

@@ -0,0 +1,11 @@
+import type { HarmonyBuildPlan } from '../tools';
+export interface HarmonyNativeBuildCacheState {
+    artifactCount: number;
+    cacheFile: string;
+    changed: boolean;
+    fingerprint: string;
+    fingerprintVersion: number;
+}
+declare function prepareHarmonyNativeBuildCacheAsync(projectRoot: string, plan: HarmonyBuildPlan): Promise<HarmonyNativeBuildCacheState>;
+declare function commitHarmonyNativeBuildCacheAsync(state: HarmonyNativeBuildCacheState): Promise<void>;
+export { commitHarmonyNativeBuildCacheAsync, prepareHarmonyNativeBuildCacheAsync, };

package/build/run/cache.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commitHarmonyNativeBuildCacheAsync = commitHarmonyNativeBuildCacheAsync;
+exports.prepareHarmonyNativeBuildCacheAsync = prepareHarmonyNativeBuildCacheAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const native_inputs_1 = require("@expo-harmony/config-plugins/native-inputs");
+const errors_1 = require("../errors");
+const CacheSchemaVersion = 1;
+async function readOptionalFile(file) {
+    try {
+        return await node_fs_1.default.promises.readFile(file);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return null;
+        throw new errors_1.HarmonyCliError(error.code || 'ERR_HARMONY_NATIVE_CACHE', error.message || `Cannot read a Harmony native cache input: ${file}`, { cause: error, exitCode: error.exitCode, operation: error.operation });
+    }
+}
+async function resolveNativeDependencyFingerprintAsync(projectRoot, plan) {
+    try {
+        return (0, native_inputs_1.fingerprintHarmonyNativeInputsSync)({
+            lockfile: plan.nativeInputs.lockfile,
+            manifest: plan.nativeInputs.manifest,
+            projectRoot,
+        });
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_CACHE', `Cannot fingerprint generated Harmony native dependencies: ${cause.message}`, { cause, operation: 'native-cache' });
+    }
+}
+async function prepareHarmonyNativeBuildCacheAsync(projectRoot, plan) {
+    const current = await resolveNativeDependencyFingerprintAsync(projectRoot, plan);
+    const file = plan.nativeCache.stateFile;
+    const source = await readOptionalFile(file);
+    let saved = null;
+    if (source) {
+        try {
+            saved = JSON.parse(source.toString('utf8'));
+        }
+        catch {
+            saved = null;
+        }
+    }
+    const changed = saved?.schemaVersion !== CacheSchemaVersion
+        || saved?.fingerprintVersion !== native_inputs_1.HarmonyNativeInputsFingerprintVersion
+        || saved?.fingerprint !== current.fingerprint;
+    if (changed) {
+        for (const root of plan.nativeCache.invalidationRoots) {
+            await node_fs_1.default.promises.rm(root, { force: true, recursive: true });
+        }
+    }
+    return {
+        ...current,
+        cacheFile: file,
+        changed,
+    };
+}
+async function commitHarmonyNativeBuildCacheAsync(state) {
+    const root = node_path_1.default.dirname(state.cacheFile);
+    const temp = `${state.cacheFile}.${process.pid}.tmp`;
+    await node_fs_1.default.promises.mkdir(root, { recursive: true });
+    await node_fs_1.default.promises.writeFile(temp, `${JSON.stringify({
+        artifactCount: state.artifactCount,
+        fingerprint: state.fingerprint,
+        fingerprintVersion: state.fingerprintVersion,
+        schemaVersion: CacheSchemaVersion,
+    }, null, 2)}\n`);
+    await node_fs_1.default.promises.rename(temp, state.cacheFile);
+}

package/build/run/devices.d.ts

@@ -0,0 +1,29 @@
+import type { HarmonyTool } from '../tools';
+interface Device {
+    aliases: string[];
+    connectTool: string | null;
+    id: string;
+    location: string | null;
+    state: string;
+    transport: string;
+}
+interface HdcOptions {
+    allowFailure?: boolean;
+    code?: string;
+    cwd?: string;
+    devicePort?: number;
+    message?: string;
+    operation?: string;
+    outputLimit?: number;
+    timeoutMs?: number;
+}
+interface DeviceSelectionOptions extends HdcOptions {
+    emulator?: HarmonyTool;
+    emulatorLogFile?: string;
+    onProgress?: (message: string) => void;
+}
+declare function selectDeviceAsync(hdc: HarmonyTool, requested?: string, options?: DeviceSelectionOptions): Promise<Device>;
+declare function installHapAsync(hdc: HarmonyTool, device: Device, hap: string, options?: HdcOptions): Promise<void>;
+declare function configureMetroPortAsync(hdc: HarmonyTool, device: Device, port: number, options?: HdcOptions): Promise<void>;
+declare function launchAppAsync(hdc: HarmonyTool, device: Device, bundleName: string, abilityName: string, options?: HdcOptions): Promise<void>;
+export { configureMetroPortAsync, installHapAsync, launchAppAsync, selectDeviceAsync, };