@expo-harmony/cli 55.0.26-harmony.1

package/src/prebuild/template.ts

@@ -0,0 +1,119 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+
+import { HarmonyCliError } from '../errors';
+import { spawnAsync } from '../process';
+
+interface Api {
+  ROOT_ENV: string;
+  resolveBundled(): {
+    root: string;
+    version: string;
+  };
+}
+
+function resolve(project: string) {
+  const load = createRequire(path.join(project, 'package.json'));
+  let api: Api;
+
+  try {
+    api = load('@expo-harmony/prebuild-config/template');
+  } catch (cause) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_TEMPLATE_INVALID',
+      'Cannot load @expo-harmony/prebuild-config/template from the project. Update the project-local prebuild config to a compatible version.',
+      { cause, operation: 'resolve-template' }
+    );
+  }
+
+  if (typeof api?.ROOT_ENV !== 'string' || typeof api.resolveBundled !== 'function') {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_TEMPLATE_INVALID',
+      'The project-local @expo-harmony/prebuild-config template API is invalid.',
+      { operation: 'resolve-template' }
+    );
+  }
+
+  let template: ReturnType<Api['resolveBundled']>;
+  try {
+    template = api.resolveBundled();
+  } catch (cause) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_TEMPLATE_INVALID',
+      'Cannot resolve the Harmony template declared by the project-local prebuild config.',
+      { cause, operation: 'resolve-template' }
+    );
+  }
+
+  if (!template
+    || typeof template.root !== 'string'
+    || !path.isAbsolute(template.root)
+    || typeof template.version !== 'string'
+    || !template.version) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_TEMPLATE_INVALID',
+      'The project-local @expo-harmony/prebuild-config returned an invalid template descriptor.',
+      { operation: 'resolve-template' }
+    );
+  }
+
+  return {
+    env: { [api.ROOT_ENV]: template.root },
+    root: template.root,
+  };
+}
+
+async function packAsync(project: string) {
+  const template = resolve(project);
+  const temp = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'expo-harmony-template-'));
+  const result = await spawnAsync('npm', [
+    'pack',
+    '--json',
+    '--ignore-scripts',
+    '--cache', path.join(temp, '.npm-cache'),
+    '--pack-destination', temp,
+    template.root,
+  ], { capture: true, cwd: project, operation: 'pack-template' });
+
+  if (result.code !== 0) {
+    await fs.promises.rm(temp, { recursive: true, force: true });
+    throw new HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', `npm pack failed: ${result.stderr.trim()}`, {
+      exitCode: result.code,
+      operation: 'pack-template',
+    });
+  }
+
+  let packs;
+
+  try {
+    packs = JSON.parse(result.stdout);
+  } catch (cause) {
+    await fs.promises.rm(temp, { recursive: true, force: true });
+    throw new HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'npm pack returned invalid JSON.', {
+      cause,
+      operation: 'pack-template',
+    });
+  }
+
+  const filename = packs?.[0]?.filename;
+  const tarball = filename && path.join(temp, filename);
+
+  if (!tarball || !fs.existsSync(tarball)) {
+    await fs.promises.rm(temp, { recursive: true, force: true });
+    throw new HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'npm pack did not create a template tarball.', { operation: 'pack-template' });
+  }
+
+  return {
+    tarball,
+    env: template.env,
+    async cleanup() {
+      await fs.promises.rm(temp, { recursive: true, force: true });
+    },
+  };
+}
+
+export {
+  packAsync,
+};

package/src/process.ts

@@ -0,0 +1,275 @@
+import spawn from 'cross-spawn';
+
+import { HarmonyCliError } from './errors';
+
+const DefaultOutputLimit = 1024 * 1024;
+const DefaultStopGraceMs = 3_000;
+
+export interface ProcessOptions {
+  capture?: boolean;
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  onStderr?: (chunk: Uint8Array) => void;
+  onStdout?: (chunk: Uint8Array) => void;
+  operation?: string;
+  outputLimit?: number;
+  signal?: AbortSignal;
+  stdio?: 'inherit' | 'pipe';
+  stopGraceMs?: number;
+  timeoutMs?: number;
+}
+
+export interface ProcessResult {
+  code: number;
+  signal: NodeJS.Signals | null;
+  stderr: string;
+  stdout: string;
+  timedOut: boolean;
+}
+
+class BoundedCapture {
+  private buffers: Uint8Array[] = [];
+  private head = 0;
+  private length = 0;
+
+  constructor(private readonly limit: number) {
+  }
+
+  append(value: Uint8Array | string): void {
+    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(): string {
+    return Buffer.concat(this.buffers.slice(this.head), this.length).toString('utf8');
+  }
+}
+
+function formatDiagnostics(result: Pick<ProcessResult, 'stderr' | 'stdout'>, limit = 4_000): string {
+  return (result.stderr || result.stdout || '').slice(-limit).trim();
+}
+
+function spawnAsync(command: string, args: string[], options: ProcessOptions = {}): Promise<ProcessResult> {
+  return new Promise<ProcessResult>((resolve, reject) => {
+    const piped = Boolean(options.capture || options.onStdout || options.onStderr);
+    const outputLimit = options.outputLimit || DefaultOutputLimit;
+    const child = spawn(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: NodeJS.Timeout | null = 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: NodeJS.Signals = '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 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: string, args: string[], options: ProcessOptions = {}) {
+  const outputLimit = options.outputLimit || DefaultOutputLimit;
+  const piped = options.stdio !== 'inherit';
+  const child = spawn(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: HarmonyCliError | null = 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<ProcessResult>((resolve, reject) => {
+    child.once('error', (cause) => {
+      spawnError = new 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: NodeJS.Signals = 'SIGTERM', graceMs = DefaultStopGraceMs) {
+    if (closed) return completion;
+
+    stopRequested = true;
+    child.kill(signal);
+    let timer: NodeJS.Timeout | undefined;
+
+    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,
+  };
+}
+
+export { formatDiagnostics, spawnAsync, startManagedProcess };

package/src/project.ts

@@ -0,0 +1,21 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { HarmonyCliError } from './errors';
+
+function resolveProject(start = process.cwd()) {
+  let current = path.resolve(start);
+
+  if (fs.existsSync(current) && fs.statSync(current).isFile()) current = path.dirname(current);
+
+  while (true) {
+    if (fs.existsSync(path.join(current, 'package.json'))) return fs.realpathSync(current);
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+
+  throw new HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `No package.json was found from ${start}.`, { operation: 'resolve-project' });
+}
+
+export { resolveProject };

package/src/projectLock.ts

@@ -0,0 +1,229 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { HarmonyCliError } from './errors';
+
+const DefaultMalformedLockGraceMs = 30_000;
+const DefaultPollIntervalMs = 100;
+const DefaultWaitTimeoutMs = 5_000;
+const LockRelativePath = '.expo/harmony/native-operation.lock';
+
+interface HarmonyProjectLockLease {
+  releaseAsync(): Promise<void>;
+}
+
+interface ActiveProjectLock {
+  projectRoot: string;
+  released: boolean;
+}
+
+interface LockOwner {
+  createdAt: string;
+  operation: string;
+  pid: number;
+  projectRoot: string;
+  token: string;
+}
+
+const ActiveLock = new AsyncLocalStorage<ActiveProjectLock>();
+
+async function canonicalProjectRootAsync(projectRoot: string): Promise<string> {
+  try {
+    return await fs.promises.realpath(path.resolve(projectRoot));
+  } catch (cause) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_PROJECT_LOCK',
+      'Cannot resolve the application project before acquiring its Harmony native operation lock.',
+      { cause, operation: 'project-lock' }
+    );
+  }
+}
+
+function projectLockPath(projectRoot: string): string {
+  return path.join(projectRoot, ...LockRelativePath.split('/'));
+}
+
+async function processIsAliveAsync(pid: unknown): Promise<boolean> {
+  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: string): Promise<LockOwner | null> {
+  try {
+    const candidate = JSON.parse(await fs.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 as LockOwner;
+  } catch (_cause) {
+    return null;
+  }
+}
+
+async function removeStaleProjectLockAsync(
+  lockPath: string
+): Promise<boolean> {
+  let observed;
+  try {
+    observed = await fs.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 fs.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 fs.promises.unlink(lockPath);
+    return true;
+  } catch (_cause) {
+    return false;
+  }
+}
+
+async function releaseOwnedLockAsync(
+  handle: fs.promises.FileHandle,
+  lockPath: string,
+  owned: fs.Stats | undefined
+): Promise<boolean> {
+  await handle.close().catch(() => {});
+  if (!owned) return false;
+
+  try {
+    const current = await fs.promises.lstat(lockPath);
+    if (!current.isFile() || current.isSymbolicLink()
+      || current.dev !== owned.dev || current.ino !== owned.ino) {
+      return false;
+    }
+    await fs.promises.unlink(lockPath);
+    return true;
+  } catch (_cause) {
+    return false;
+  }
+}
+
+function delayAsync(milliseconds: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+
+async function acquireHarmonyProjectLockAsync(
+  projectRoot: string,
+  operation: string
+): Promise<HarmonyProjectLockLease> {
+  const canonicalRoot = await canonicalProjectRootAsync(projectRoot);
+  const lockPath = projectLockPath(canonicalRoot);
+  const deadline = Date.now() + DefaultWaitTimeoutMs;
+
+  await fs.promises.mkdir(path.dirname(lockPath), { recursive: true });
+
+  while (true) {
+    try {
+      const handle = await fs.promises.open(lockPath, 'wx', 0o600);
+      let owned: fs.Stats | undefined;
+      const owner: LockOwner = {
+        createdAt: new Date().toISOString(),
+        operation,
+        pid: process.pid,
+        projectRoot: canonicalRoot,
+        token: crypto.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 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 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 HarmonyCliError) throw cause;
+      if (cause?.code !== 'EEXIST') {
+        throw new 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 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<T>(
+  projectRoot: string,
+  operation: string,
+  callback: () => Promise<T> | T
+): Promise<T> {
+  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: ActiveProjectLock = { projectRoot: canonicalRoot, released: false };
+  try {
+    return await ActiveLock.run(context, callback);
+  } finally {
+    context.released = true;
+    await lease.releaseAsync();
+  }
+}
+
+export { withHarmonyProjectLockAsync };