rn-iso 0.1.0

package/src/runner.js

@@ -0,0 +1,136 @@
+import { existsSync, readFileSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { listAllIosSims } from './sim/ios.js';
+
+const LOCKFILES = [
+  // Order matters: most specific / modern first. If a project has multiple
+  // lockfiles (e.g., during a migration), the first match wins.
+  { name: 'bun.lock', pm: 'bun' },
+  { name: 'bun.lockb', pm: 'bun' },
+  { name: 'pnpm-lock.yaml', pm: 'pnpm' },
+  { name: 'yarn.lock', pm: 'yarn' },
+  { name: 'package-lock.json', pm: 'npm' },
+];
+
+// Walk up from startDir looking for a lockfile. In monorepos the lockfile
+// lives at the workspace root, several levels above any individual package.
+// Returns { dir, pm } or null if no lockfile is found before the filesystem
+// root.
+export function findLockfile(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    for (const { name, pm } of LOCKFILES) {
+      if (existsSync(join(dir, name))) return { dir, pm };
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+// Detect package manager from lockfiles, walking up for monorepos.
+// Defaults to npm when no lockfile is found anywhere up the tree.
+export function detectPackageManager(projectRoot) {
+  return findLockfile(projectRoot)?.pm || 'npm';
+}
+
+export function getProjectScript(projectRoot, name) {
+  const p = join(projectRoot, 'package.json');
+  if (!existsSync(p)) return null;
+  try {
+    const pkg = JSON.parse(readFileSync(p, 'utf-8'));
+    return pkg?.scripts?.[name] || null;
+  } catch {
+    return null;
+  }
+}
+
+// Build a `<pm> <script> ...args` invocation. npm needs `--` to separate
+// script-name args from script-passed args; yarn / pnpm / bun pass them
+// directly. We always invoke through the package manager rather than running
+// the script body so the user's pre/post hooks fire.
+export function buildScriptCommand(packageManager, scriptName, extraArgs = []) {
+  const args = extraArgs.filter(Boolean).join(' ');
+  switch (packageManager) {
+    case 'yarn':
+      return `yarn ${scriptName}${args ? ' ' + args : ''}`;
+    case 'pnpm':
+      return `pnpm ${scriptName}${args ? ' ' + args : ''}`;
+    case 'bun':
+      return `bun run ${scriptName}${args ? ' ' + args : ''}`;
+    case 'npm':
+    default:
+      return `npm run ${scriptName}${args ? ' -- ' + args : ''}`;
+  }
+}
+
+// Decide which CLI a script invokes. Affects flag names: Expo CLI takes
+// --device <UDID>, bare RN CLI takes --udid <UDID> for iOS (--device there
+// means physical device by name) and --deviceId for Android.
+export function detectScriptCli(scriptBody) {
+  if (typeof scriptBody !== 'string') return 'unknown';
+  if (/\bexpo\s+(run:ios|run:android|start)\b/.test(scriptBody)) return 'expo';
+  if (/\breact-native\s+(run-ios|run-android|start)\b/.test(scriptBody)) return 'react-native';
+  return 'unknown';
+}
+
+// iOS run command. Prefers the project's `ios` script if present (the most
+// reliable: respects user customization, picks the right CLI). Falls back to
+// expo run:ios / react-native run-ios when no script exists or --no-script.
+export function buildIosCommand({ projectRoot, packageManager, scriptName, isExpo, udid, port, useScript = true }) {
+  if (useScript && scriptName) {
+    const script = getProjectScript(projectRoot, scriptName);
+    if (script) {
+      const cli = detectScriptCli(script);
+      // Expo: --device <UDID>; RN (and unknown, common case): --udid <UDID>.
+      const deviceFlag = cli === 'expo' ? `--device ${udid}` : `--udid ${udid}`;
+      return buildScriptCommand(packageManager, scriptName, [
+        deviceFlag,
+        `--port ${port}`,
+      ]);
+    }
+  }
+  if (isExpo) {
+    return `npx expo run:ios --device ${udid} --port ${port}`;
+  }
+  return `npx react-native run-ios --udid ${udid} --port ${port}`;
+}
+
+export function buildAndroidCommand({ projectRoot, packageManager, scriptName, isExpo, serial, port, useScript = true }) {
+  if (useScript && scriptName) {
+    const script = getProjectScript(projectRoot, scriptName);
+    if (script) {
+      const cli = detectScriptCli(script);
+      // Expo: --device <serial>; RN: --deviceId <serial>.
+      const deviceFlag = cli === 'expo' ? `--device ${serial}` : `--deviceId ${serial}`;
+      return buildScriptCommand(packageManager, scriptName, [
+        deviceFlag,
+        `--port ${port}`,
+      ]);
+    }
+  }
+  if (isExpo) {
+    return `npx expo run:android --device ${serial} --port ${port}`;
+  }
+  return `RCT_METRO_PORT=${port} npx react-native run-android --deviceId ${serial}`;
+}
+
+export function buildMetroCommand({ isExpo, port }) {
+  return isExpo
+    ? `npx expo start --port ${port}`
+    : `npx react-native start --port ${port}`;
+}
+
+export function resolveSimNameByUdid(udid) {
+  const sims = listAllIosSims();
+  const target = sims.find(s => s.udid === udid);
+  if (!target) throw new Error(`Simulator UDID not found: ${udid}`);
+  const sameName = sims.filter(s => s.name === target.name);
+  if (sameName.length > 1) {
+    throw new Error(
+      `Ambiguous: multiple simulators named "${target.name}" -- bare RN takes a name, not UDID. ` +
+      `Rename one in the Simulator app.`
+    );
+  }
+  return target.name;
+}

package/src/sim/android.js

@@ -0,0 +1,103 @@
+import { getExecutor } from '../exec.js';
+
+export function parseAvdList(text) {
+  return text
+    .split('\n')
+    .map(l => l.trim())
+    .filter(l => l && !l.startsWith('INFO') && !l.startsWith('WARNING'));
+}
+
+export function parseAdbDevices(text) {
+  const lines = text.split('\n').slice(1); // skip "List of devices attached"
+  const emulators = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const [serial, status] = trimmed.split(/\s+/);
+    if (status !== 'device') continue;
+    const m = serial.match(/^emulator-(\d+)$/);
+    if (m) emulators.push({ serial, consolePort: parseInt(m[1], 10) });
+  }
+  return { emulators };
+}
+
+export function listAvds() {
+  return parseAvdList(getExecutor().run('emulator -list-avds'));
+}
+
+export function listAdbDevices() {
+  return parseAdbDevices(getExecutor().run('adb devices'));
+}
+
+export function nextConsolePort(claimedPorts) {
+  if (claimedPorts.length === 0) return 5554;
+  const max = Math.max(...claimedPorts);
+  return max + 2; // emulator console ports are even
+}
+
+export function selectAndroidDevice({ existingAvd, existingConsolePort, claimedAvds, claimedConsolePorts }) {
+  const avds = listAvds();
+  const adbDevices = listAdbDevices();
+  const runningPorts = new Set(adbDevices.emulators.map(e => e.consolePort));
+
+  if (existingAvd && avds.includes(existingAvd)) {
+    const port = existingConsolePort ?? nextConsolePort(claimedConsolePorts);
+    return {
+      kind: 'reuse',
+      avdName: existingAvd,
+      consolePort: port,
+      isRunning: runningPorts.has(port),
+    };
+  }
+
+  if (avds.length === 0) {
+    return { kind: 'noAvd' };
+  }
+
+  const claimedAvdSet = new Set(claimedAvds);
+  const candidate = avds.find(a => !claimedAvdSet.has(a));
+  if (!candidate) {
+    return { kind: 'noAvd' };
+  }
+  const consolePort = nextConsolePort(claimedConsolePorts);
+  return {
+    kind: 'allocate',
+    avdName: candidate,
+    consolePort,
+    isRunning: runningPorts.has(consolePort),
+  };
+}
+
+export function bootAndroidEmulator(avdName, consolePort) {
+  const exec = getExecutor();
+  exec.spawn('emulator', ['-avd', avdName, '-port', String(consolePort)], {
+    detached: true,
+    stdio: 'ignore',
+  }).unref();
+}
+
+export async function waitForBoot(serial, timeoutMs = 60000) {
+  const exec = getExecutor();
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const out = exec.runQuiet(`adb -s ${serial} shell getprop sys.boot_completed`);
+    if (out && out.trim() === '1') return true;
+    await new Promise(r => setTimeout(r, 1000));
+  }
+  return false;
+}
+
+export function shutdownAndroidEmulator(serial) {
+  getExecutor().runQuiet(`adb -s ${serial} emu kill`);
+}
+
+export function adbReverse(serial, port) {
+  getExecutor().run(`adb -s ${serial} reverse tcp:${port} tcp:${port}`);
+}
+
+export function getAvdNameForSerial(serial) {
+  const out = getExecutor().runQuiet(`adb -s ${serial} emu avd name`);
+  if (!out) return null;
+  // `adb emu avd name` returns the AVD name on the first line, "OK" on the second.
+  return out.split('\n')[0].trim() || null;
+}

package/src/sim/ios.js

@@ -0,0 +1,128 @@
+import { randomBytes } from 'crypto';
+import { getExecutor } from '../exec.js';
+
+export function parseSimctlList(jsonOutput) {
+  const data = JSON.parse(jsonOutput);
+  const sims = [];
+  for (const [runtime, devices] of Object.entries(data.devices || {})) {
+    // Skip non-iOS runtimes (watchOS, tvOS, visionOS). iOS runtime IDs look
+    // like com.apple.CoreSimulator.SimRuntime.iOS-26-2 (the others have
+    // watchOS-, tvOS-, xrOS- in place of iOS-).
+    if (!/\.iOS-/.test(runtime)) continue;
+    for (const dev of devices) {
+      if (!dev.isAvailable) continue;
+      sims.push({
+        udid: dev.udid,
+        name: dev.name,
+        state: dev.state,
+        runtime,
+      });
+    }
+  }
+  return sims;
+}
+
+export function listAllIosSims() {
+  const out = getExecutor().run('xcrun simctl list devices --json');
+  return parseSimctlList(out);
+}
+
+export function listBootedIosSims() {
+  return listAllIosSims().filter(s => s.state === 'Booted');
+}
+
+export function deviceFamilyRank(name) {
+  if (/^iPhone/i.test(name)) return 0;
+  if (/^iPad/i.test(name)) return 1;
+  return 2;
+}
+
+export function sortSims(sims, usage = {}) {
+  return [...sims].sort((a, b) => {
+    // 1. Family: iPhones before iPads before others.
+    const fa = deviceFamilyRank(a.name);
+    const fb = deviceFamilyRank(b.name);
+    if (fa !== fb) return fa - fb;
+    // 2. State: booted before shutdown (within the same family).
+    if (a.state === 'Booted' && b.state !== 'Booted') return -1;
+    if (b.state === 'Booted' && a.state !== 'Booted') return 1;
+    // 3. Usage count: descending (frequently picked sims float up).
+    const ua = usage[a.udid] || 0;
+    const ub = usage[b.udid] || 0;
+    if (ua !== ub) return ub - ua;
+    // 4. Name: stable alphabetical.
+    return a.name.localeCompare(b.name);
+  });
+}
+
+export function selectIosDevice({ existingUdid, claimedUdids, usage = {} }) {
+  const sims = listAllIosSims();
+  const claimed = new Set(claimedUdids);
+
+  if (existingUdid) {
+    const found = sims.find(s => s.udid === existingUdid);
+    if (found) {
+      return { kind: 'reuse', udid: found.udid, state: found.state };
+    }
+  }
+
+  const unclaimed = sims.filter(s => !claimed.has(s.udid));
+  if (unclaimed.length === 0) return { kind: 'needsBoot' };
+
+  return { kind: 'allocate', candidates: sortSims(unclaimed, usage) };
+}
+
+export function parseRuntimeVersion(runtimeId) {
+  // e.g. com.apple.CoreSimulator.SimRuntime.iOS-26-2 -> "26.2"
+  const m = runtimeId.match(/iOS-(\d+)(?:-(\d+))?$/);
+  if (!m) return runtimeId;
+  return m[2] ? `${m[1]}.${m[2]}` : m[1];
+}
+
+export function bootIosSim(udid) {
+  const exec = getExecutor();
+  try {
+    exec.run(`xcrun simctl boot ${udid}`);
+  } catch (e) {
+    // simctl errors with "Unable to boot device in current state: Booted" if already booted.
+    if (!String(e?.message || e).includes('Booted')) throw e;
+  }
+  exec.runQuiet('open -a Simulator');
+}
+
+export function shutdownIosSim(udid) {
+  getExecutor().runQuiet(`xcrun simctl shutdown ${udid}`);
+}
+
+export function listIosDeviceTypes() {
+  const exec = getExecutor();
+  const out = exec.run('xcrun simctl list devicetypes --json');
+  const data = JSON.parse(out);
+  return (data.devicetypes || []).map(dt => ({
+    identifier: dt.identifier,
+    name: dt.name,
+  }));
+}
+
+export function createIosSim(deviceTypeId, runtimeId) {
+  const suffix = randomBytes(3).toString('hex');
+  const name = `rn-iso-${suffix}`;
+  const out = getExecutor().run(`xcrun simctl create "${name}" "${deviceTypeId}" "${runtimeId}"`);
+  return out.trim();
+}
+
+export function listIosRuntimes() {
+  const out = getExecutor().run('xcrun simctl list runtimes --json');
+  const data = JSON.parse(out);
+  return (data.runtimes || [])
+    .filter(r => r.isAvailable && r.platform === 'iOS')
+    .map(r => ({
+      identifier: r.identifier,
+      name: r.name,
+      version: r.version,
+      supportedDeviceTypes: (r.supportedDeviceTypes || []).map(d => ({
+        identifier: d.identifier,
+        name: d.name,
+      })),
+    }));
+}

package/test/config.test.js

@@ -0,0 +1,208 @@
+import { test, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, existsSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import {
+  getConfigDir,
+  loadConfig,
+  saveConfig,
+  ensureConfig,
+  getProject,
+  upsertProject,
+  removeProject,
+  setMetro,
+  setDevice,
+  clearDevice,
+  allMetroPorts,
+  allClaimedDevices,
+  addReservation,
+  removeReservation,
+  listReservations,
+  clearAllReservations,
+  findReservations,
+  recordSimUsage,
+  getSimUsage,
+} from '../src/config.js';
+
+let tmpHome;
+
+beforeEach(() => {
+  tmpHome = mkdtempSync(join(tmpdir(), 'rn-iso-test-'));
+  process.env.RN_ISO_HOME = tmpHome;
+});
+
+afterEach(() => {
+  rmSync(tmpHome, { recursive: true, force: true });
+  delete process.env.RN_ISO_HOME;
+});
+
+test('getConfigDir respects RN_ISO_HOME', () => {
+  assert.equal(getConfigDir(), tmpHome);
+});
+
+test('loadConfig returns null when no file exists', () => {
+  assert.equal(loadConfig(), null);
+});
+
+test('ensureConfig creates and returns empty config', () => {
+  const cfg = ensureConfig();
+  assert.deepEqual(cfg, { version: 1, projects: {}, reservations: { ios: [], android: [] } });
+  assert.ok(existsSync(join(tmpHome, 'config.json')));
+});
+
+test('saveConfig + loadConfig roundtrip', () => {
+  saveConfig({ version: 1, projects: { '/foo': { metroPort: 8082, platforms: {} } } });
+  const cfg = loadConfig();
+  assert.equal(cfg.projects['/foo'].metroPort, 8082);
+});
+
+test('upsertProject creates a new project entry with defaults', () => {
+  const proj = upsertProject('/abs/path', {
+    bundleId: 'com.foo',
+    androidPackage: 'com.foo',
+    isExpo: true,
+  });
+  assert.equal(proj.bundleId, 'com.foo');
+  assert.equal(proj.metroPort, null);
+  assert.deepEqual(proj.platforms, {});
+});
+
+test('upsertProject preserves existing fields when called again', () => {
+  upsertProject('/p', { bundleId: 'com.a', androidPackage: 'com.a', isExpo: false });
+  setMetro('/p', 8082, 12345);
+  upsertProject('/p', { bundleId: 'com.b', androidPackage: 'com.b', isExpo: false });
+  const proj = getProject('/p');
+  assert.equal(proj.bundleId, 'com.b');
+  assert.equal(proj.metroPort, 8082);
+  assert.equal(proj.metroPid, 12345);
+});
+
+test('setDevice and clearDevice mutate platforms', () => {
+  upsertProject('/p', { bundleId: 'com.a', androidPackage: 'com.a', isExpo: false });
+  setDevice('/p', 'ios', { deviceUdid: 'ABC' });
+  assert.equal(getProject('/p').platforms.ios.deviceUdid, 'ABC');
+  clearDevice('/p', 'ios');
+  assert.equal(getProject('/p').platforms.ios, undefined);
+});
+
+test('allMetroPorts collects ports from all projects', () => {
+  upsertProject('/a', { bundleId: 'com.a', androidPackage: 'com.a', isExpo: false });
+  upsertProject('/b', { bundleId: 'com.b', androidPackage: 'com.b', isExpo: false });
+  setMetro('/a', 8082, null);
+  setMetro('/b', 8083, null);
+  assert.deepEqual(allMetroPorts().sort(), [8082, 8083]);
+});
+
+test('allClaimedDevices returns udids and avd names across projects', () => {
+  upsertProject('/a', { bundleId: 'com.a', androidPackage: 'com.a', isExpo: false });
+  upsertProject('/b', { bundleId: 'com.b', androidPackage: 'com.b', isExpo: false });
+  setDevice('/a', 'ios', { deviceUdid: 'UDID-1' });
+  setDevice('/b', 'android', { avdName: 'Pixel_6', consolePort: 5554 });
+  const claimed = allClaimedDevices();
+  assert.deepEqual(claimed.iosUdids, ['UDID-1']);
+  assert.deepEqual(claimed.androidAvds, ['Pixel_6']);
+  assert.deepEqual(claimed.androidConsolePorts, [5554]);
+});
+
+test('removeProject deletes entry', () => {
+  upsertProject('/p', { bundleId: 'com.a', androidPackage: 'com.a', isExpo: false });
+  removeProject('/p');
+  assert.equal(getProject('/p'), null);
+});
+
+test('addReservation appends an iOS reservation and idempotently updates by UDID', () => {
+  addReservation('ios', { udid: 'UDID-X', label: 'agent-1' });
+  addReservation('ios', { udid: 'UDID-Y' });
+  let r = listReservations();
+  assert.equal(r.ios.length, 2);
+  // Re-add with same UDID -> updated, not duplicated
+  addReservation('ios', { udid: 'UDID-X', label: 'agent-1-renamed' });
+  r = listReservations();
+  assert.equal(r.ios.length, 2);
+  assert.equal(r.ios.find(e => e.udid === 'UDID-X').label, 'agent-1-renamed');
+});
+
+test('addReservation works for android keyed by serial', () => {
+  addReservation('android', { serial: 'emulator-5554', consolePort: 5554, avdName: 'Pixel_6' });
+  const r = listReservations();
+  assert.equal(r.android.length, 1);
+  assert.equal(r.android[0].avdName, 'Pixel_6');
+});
+
+test('removeReservation drops the matching entry', () => {
+  addReservation('ios', { udid: 'UDID-1' });
+  addReservation('ios', { udid: 'UDID-2' });
+  const removed = removeReservation('ios', 'UDID-1');
+  assert.equal(removed, true);
+  assert.deepEqual(listReservations().ios.map(e => e.udid), ['UDID-2']);
+});
+
+test('allClaimedDevices includes reservations alongside project assignments', () => {
+  upsertProject('/p', { bundleId: 'com.a', androidPackage: 'com.a', isExpo: false });
+  setDevice('/p', 'ios', { deviceUdid: 'UDID-PROJECT' });
+  addReservation('ios', { udid: 'UDID-EXTERNAL', label: 'agent-1' });
+  addReservation('android', { serial: 'emulator-5554', consolePort: 5554, avdName: 'Pixel_6' });
+  const claimed = allClaimedDevices();
+  assert.deepEqual(claimed.iosUdids.sort(), ['UDID-EXTERNAL', 'UDID-PROJECT']);
+  assert.deepEqual(claimed.androidAvds, ['Pixel_6']);
+  assert.deepEqual(claimed.androidConsolePorts, [5554]);
+});
+
+test('clearAllReservations empties both platforms', () => {
+  addReservation('ios', { udid: 'UDID-1' });
+  addReservation('android', { serial: 'emulator-5554', consolePort: 5554 });
+  clearAllReservations();
+  const r = listReservations();
+  assert.deepEqual(r, { ios: [], android: [] });
+});
+
+test('findReservations matches by id (UDID for iOS, serial for Android)', () => {
+  addReservation('ios', { udid: 'UDID-1', label: 'agent-2' });
+  addReservation('android', { serial: 'emulator-5554', consolePort: 5554, label: 'agent-1' });
+  const ios = findReservations('UDID-1');
+  assert.deepEqual(ios, [{ platform: 'ios', id: 'UDID-1', label: 'agent-2' }]);
+  const android = findReservations('emulator-5554');
+  assert.deepEqual(android, [{ platform: 'android', id: 'emulator-5554', label: 'agent-1' }]);
+});
+
+test('findReservations matches by label across platforms', () => {
+  addReservation('ios', { udid: 'UDID-1', label: 'shared-label' });
+  addReservation('android', { serial: 'emulator-5554', consolePort: 5554, label: 'shared-label' });
+  const matches = findReservations('shared-label');
+  assert.equal(matches.length, 2);
+  assert.deepEqual(matches.map(m => m.platform).sort(), ['android', 'ios']);
+});
+
+test('findReservations respects platform filter', () => {
+  addReservation('ios', { udid: 'UDID-1', label: 'shared' });
+  addReservation('android', { serial: 'emulator-5554', consolePort: 5554, label: 'shared' });
+  const matches = findReservations('shared', 'android');
+  assert.equal(matches.length, 1);
+  assert.equal(matches[0].platform, 'android');
+});
+
+test('findReservations returns empty when nothing matches', () => {
+  addReservation('ios', { udid: 'UDID-1', label: 'agent-1' });
+  assert.deepEqual(findReservations('nope'), []);
+});
+
+test('recordSimUsage increments and getSimUsage reads counts', () => {
+  recordSimUsage('ios', 'UDID-A');
+  recordSimUsage('ios', 'UDID-A');
+  recordSimUsage('ios', 'UDID-B');
+  recordSimUsage('android', 'Pixel_6');
+  const usage = getSimUsage();
+  assert.equal(usage.ios['UDID-A'], 2);
+  assert.equal(usage.ios['UDID-B'], 1);
+  assert.equal(usage.android['Pixel_6'], 1);
+});
+
+test('allClaimedDevices.iosClaims labels project vs reservation sources', () => {
+  upsertProject('/Users/janic/Developer/myapp', { bundleId: 'com.a', androidPackage: 'com.a', isExpo: true });
+  setDevice('/Users/janic/Developer/myapp', 'ios', { deviceUdid: 'UDID-PROJ' });
+  addReservation('ios', { udid: 'UDID-EXT', label: 'agent-1' });
+  const claimed = allClaimedDevices();
+  assert.deepEqual(claimed.iosClaims['UDID-PROJ'], { source: 'project', label: 'myapp' });
+  assert.deepEqual(claimed.iosClaims['UDID-EXT'], { source: 'reservation', label: 'agent-1' });
+});

package/test/exec.test.js

@@ -0,0 +1,26 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { setExecutor, getExecutor, resetExecutor } from '../src/exec.js';
+
+test('default executor runs commands and returns stdout trimmed', () => {
+  resetExecutor();
+  const out = getExecutor().run('echo hello');
+  assert.equal(out, 'hello');
+});
+
+test('runQuiet returns null on failure', () => {
+  resetExecutor();
+  const out = getExecutor().runQuiet('false');
+  assert.equal(out, null);
+});
+
+test('setExecutor replaces the active executor', () => {
+  setExecutor({
+    run: () => 'mocked',
+    runQuiet: () => 'mocked-quiet',
+    spawn: () => ({ pid: 999 }),
+  });
+  assert.equal(getExecutor().run('anything'), 'mocked');
+  assert.equal(getExecutor().runQuiet('anything'), 'mocked-quiet');
+  resetExecutor();
+});

package/test/fixtures/sample-bare-project/android/app/build.gradle

@@ -0,0 +1,6 @@
+android {
+    namespace "me.sample"
+    defaultConfig {
+        applicationId "me.sample"
+    }
+}

package/test/fixtures/sample-bare-project/ios/SampleApp.xcodeproj/project.pbxproj

@@ -0,0 +1,10 @@
+// Minimal pbxproj fixture mimicking a hybrid project layout: main app
+// bundle id appears in multiple build configs; an extension target adds a
+// suffix on its own id; macros are present too.
+				PRODUCT_BUNDLE_IDENTIFIER = me.sample;
+				PRODUCT_BUNDLE_IDENTIFIER = me.sample;
+				PRODUCT_BUNDLE_IDENTIFIER = me.sample;
+				PRODUCT_BUNDLE_IDENTIFIER = me.sample;
+				PRODUCT_BUNDLE_IDENTIFIER = me.sample.WidgetExtension;
+				PRODUCT_BUNDLE_IDENTIFIER = me.sample.WidgetExtension;
+				PRODUCT_BUNDLE_IDENTIFIER = $(SOMETHING);

package/test/fixtures/sample-bare-project/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "bare-app",
+  "dependencies": { "react-native": "0.74.0" }
+}

package/test/fixtures/sample-expo-project/app.json

@@ -0,0 +1,6 @@
+{
+  "expo": {
+    "ios": { "bundleIdentifier": "com.example.sample" },
+    "android": { "package": "com.example.sample" }
+  }
+}

package/test/fixtures/sample-expo-project/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "sample-app",
+  "dependencies": { "expo": "~50.0.0" }
+}

package/test/metro.test.js

@@ -0,0 +1,34 @@
+import { test, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { resetExecutor } from '../src/exec.js';
+import { logFileFor, projectHash, buildMetroSpawnArgs } from '../src/metro.js';
+
+afterEach(() => resetExecutor());
+
+test('projectHash is deterministic and short', () => {
+  const a = projectHash('/foo/bar');
+  const b = projectHash('/foo/bar');
+  const c = projectHash('/foo/baz');
+  assert.equal(a, b);
+  assert.notEqual(a, c);
+  assert.equal(a.length, 12);
+});
+
+test('logFileFor uses RN_ISO_HOME and project hash', () => {
+  process.env.RN_ISO_HOME = '/tmp/test-rn-iso';
+  const path = logFileFor('/some/project');
+  assert.match(path, /^\/tmp\/test-rn-iso\/logs\/[0-9a-f]{12}\.log$/);
+  delete process.env.RN_ISO_HOME;
+});
+
+test('buildMetroSpawnArgs returns correct argv for expo', () => {
+  const { cmd, args } = buildMetroSpawnArgs({ isExpo: true, port: 8083 });
+  assert.equal(cmd, 'npx');
+  assert.deepEqual(args, ['expo', 'start', '--port', '8083']);
+});
+
+test('buildMetroSpawnArgs returns correct argv for bare', () => {
+  const { cmd, args } = buildMetroSpawnArgs({ isExpo: false, port: 8083 });
+  assert.equal(cmd, 'npx');
+  assert.deepEqual(args, ['react-native', 'start', '--port', '8083']);
+});