rn-iso 0.1.0

package/src/commands/ios.js

@@ -0,0 +1,210 @@
+// src/commands/ios.js
+import chalk from 'chalk';
+import prompts from 'prompts';
+import { findProjectRoot, detectIsExpo, detectBundleId, detectAndroidPackage } from '../project.js';
+import { getProject, upsertProject, setMetro, setDevice, allClaimedDevices, recordSimUsage, getSimUsage } from '../config.js';
+import { allocatePort, isMetroRunning } from '../ports.js';
+import { selectIosDevice, bootIosSim, listIosRuntimes, createIosSim, parseRuntimeVersion, listAllIosSims, sortSims } from '../sim/ios.js';
+import { buildIosCommand, detectPackageManager } from '../runner.js';
+import { getExecutor } from '../exec.js';
+
+export default function iosCommand(program) {
+  program
+    .command('ios')
+    .description('Ensure a dedicated iOS simulator + Metro server for the current project; build/install if needed')
+    .option('--device-type <name>', 'Explicit opt-in: create a NEW sim of this device type (e.g. "iPhone 17 Pro")')
+    .option('--runtime <version>', 'iOS runtime version when creating a new sim (e.g. "26.2"); defaults to latest')
+    .option('--auto', 'Non-interactive: pick the first unclaimed sim without prompting')
+    .option('--script <name>', 'package.json script to invoke for build/install (default: ios)', 'ios')
+    .option('--no-script', 'Skip the package.json script lookup; run expo/react-native CLI directly')
+    .option('--pm <name>', 'Package manager: npm, yarn, pnpm, bun (default: detected from lockfile)')
+    .option('--no-install', 'Skip the build/install step (assume app is already installed)')
+    .action(async (opts) => {
+      const root = findProjectRoot(process.cwd());
+      if (!root) {
+        console.error(chalk.red('Not in a React Native project (no package.json found).'));
+        process.exit(1);
+      }
+
+      const bundleId = detectBundleId(root);
+      const androidPackage = detectAndroidPackage(root);
+      const isExpo = detectIsExpo(root);
+
+      upsertProject(root, { bundleId, androidPackage, isExpo });
+      let proj = getProject(root);
+
+      if (!proj.metroPort) {
+        const port = await allocatePort(root);
+        setMetro(root, port, null);
+        proj = getProject(root);
+        console.log(chalk.dim(`Allocated Metro port: ${port}`));
+      }
+      const metroAlreadyUp = await isMetroRunning(proj.metroPort);
+      console.log(chalk.dim(
+        `Metro port: ${proj.metroPort}` +
+        (metroAlreadyUp ? ' (already running)' : ' (will be started by build CLI)')
+      ));
+
+      const claimedDevices = allClaimedDevices();
+      const ownUdid = proj.platforms?.ios?.deviceUdid;
+      const claimed = claimedDevices.iosUdids.filter(u => u !== ownUdid);
+      const usage = getSimUsage().ios || {};
+      const selection = selectIosDevice({
+        existingUdid: ownUdid || null,
+        claimedUdids: claimed,
+        usage,
+      });
+
+      let udid;
+      if (selection.kind === 'reuse') {
+        udid = selection.udid;
+        if (selection.state !== 'Booted') {
+          console.log(chalk.dim(`Booting assigned sim ${udid}...`));
+          bootIosSim(udid);
+        } else {
+          console.log(chalk.dim(`Reusing assigned sim ${udid} (already booted)`));
+        }
+      } else if (selection.kind === 'allocate') {
+        const picked = (selection.candidates.length === 1 || opts.auto)
+          ? selection.candidates[0]
+          : await pickSim(selection.candidates, claimedDevices.iosClaims, usage);
+        udid = picked.udid;
+        if (picked.state !== 'Booted') {
+          console.log(chalk.dim(`Booting ${picked.name} (${udid})...`));
+          bootIosSim(udid);
+        } else {
+          console.log(chalk.green(`Assigned ${picked.name} (${udid}, booted)`));
+        }
+      } else {
+        // needsBoot: no unclaimed sim available.
+        if (opts.deviceType) {
+          udid = createNewSim({ deviceType: opts.deviceType, runtimeVersion: opts.runtime });
+          console.log(chalk.green(`Created and booted new sim ${udid}`));
+        } else {
+          console.error(chalk.red('No unclaimed iOS simulator available.'));
+          console.error(chalk.dim('Options:'));
+          console.error(chalk.dim('  - Open a sim in the Simulator app, then re-run'));
+          console.error(chalk.dim('  - `rn-iso unreserve --all` if you have stale reservations'));
+          console.error(chalk.dim('  - Free another rn-iso project (`rn-iso release` from there)'));
+          console.error(chalk.dim('  - Pass --device-type "iPhone 17 Pro" [--runtime 26.2] to create a new sim'));
+          process.exit(1);
+        }
+      }
+
+      setDevice(root, 'ios', { deviceUdid: udid });
+      recordSimUsage('ios', udid);
+
+      // Metro is started by the build CLI (`expo run:ios` / `react-native
+      // run-ios`) using the --port we pass below. We don't spawn a separate
+      // Metro -- that caused two Metros on the same port. For Metro-only
+      // (without build/install), use `rn-iso start`.
+
+      if (opts.install !== false) {
+        const packageManager = opts.pm || detectPackageManager(root);
+        const useScript = opts.script !== false;
+        const scriptName = useScript ? (typeof opts.script === 'string' ? opts.script : 'ios') : null;
+        const cmd = buildIosCommand({
+          projectRoot: root,
+          packageManager,
+          scriptName,
+          isExpo,
+          udid,
+          port: proj.metroPort,
+          useScript,
+        });
+        console.log(chalk.dim(`> ${cmd}`));
+        const exec = getExecutor();
+        const child = exec.spawn('sh', ['-c', cmd], { cwd: root, stdio: 'inherit' });
+        await new Promise((resolve, reject) => {
+          child.on('exit', (code) => code === 0 ? resolve() : reject(new Error(`Build failed (exit ${code})`)));
+        });
+
+      }
+
+      console.log(chalk.green(`\nOK: iOS ready on sim ${udid}, Metro port ${proj.metroPort}`));
+    });
+}
+
+async function pickSim(candidates, iosClaims = {}, usage = {}) {
+  // Show ALL sims (not just unclaimed) so the user can see why something
+  // they expected isn't selectable. Claimed sims are listed but disabled,
+  // labeled with the project/reservation that owns them.
+  const allSims = listAllIosSims();
+  const candidateUdids = new Set(candidates.map(s => s.udid));
+  const sorted = sortSims(allSims, usage);
+
+  const nameWidth = Math.max(...sorted.map(s => s.name.length), 18);
+  const choices = sorted.map(s => {
+    const version = parseRuntimeVersion(s.runtime);
+    const namePart = s.name.padEnd(nameWidth);
+    const versionPart = version.padStart(6);
+    const claim = iosClaims[s.udid];
+    if (claim) {
+      const tag = claim.source === 'project'
+        ? `[claimed by ${claim.label}]`
+        : `[reserved: ${claim.label}]`;
+      return {
+        title: chalk.dim(`${namePart}  ${versionPart}  ${tag}`),
+        value: null,
+        disabled: true,
+      };
+    }
+    const stateTag = s.state === 'Booted' ? chalk.green('  [booted]') : '';
+    const isCandidate = candidateUdids.has(s.udid);
+    if (!isCandidate) {
+      // Shouldn't happen with current selectIosDevice, but be safe.
+      return { title: chalk.dim(`${namePart}  ${versionPart}`), value: null, disabled: true };
+    }
+    return {
+      title: `${namePart}  ${chalk.dim(versionPart)}${stateTag}`,
+      value: s,
+    };
+  });
+  const answer = await prompts({
+    type: 'select',
+    name: 'sim',
+    message: 'Pick a simulator:',
+    choices,
+  });
+  if (!answer.sim) {
+    console.error(chalk.red('Cancelled.'));
+    process.exit(1);
+  }
+  return answer.sim;
+}
+
+function createNewSim({ deviceType, runtimeVersion }) {
+  const runtimes = listIosRuntimes();
+  if (runtimes.length === 0) {
+    throw new Error('No iOS runtimes installed; install one via Xcode.');
+  }
+
+  // Pick the runtime: explicit version flag, else the latest.
+  let runtime;
+  if (runtimeVersion) {
+    runtime = runtimes.find(r => r.version === runtimeVersion || r.name === `iOS ${runtimeVersion}`);
+    if (!runtime) {
+      const available = runtimes.map(r => r.version).join(', ');
+      throw new Error(`Runtime "${runtimeVersion}" not installed. Available: ${available}`);
+    }
+  } else {
+    runtime = [...runtimes].sort(
+      (a, b) => b.version.localeCompare(a.version, undefined, { numeric: true })
+    )[0];
+  }
+
+  // Resolve the device type within the chosen runtime's compatible list.
+  const supported = runtime.supportedDeviceTypes || [];
+  const dt = supported.find(d => d.name === deviceType || d.identifier === deviceType);
+  if (!dt) {
+    const names = supported.map(d => d.name).slice(0, 8).join(', ');
+    throw new Error(
+      `Device type "${deviceType}" not compatible with runtime ${runtime.version}. ` +
+      `Compatible (sample): ${names}...`
+    );
+  }
+
+  const udid = createIosSim(dt.identifier, runtime.identifier);
+  bootIosSim(udid);
+  return udid;
+}

package/src/commands/logs.js

@@ -0,0 +1,28 @@
+// src/commands/logs.js
+import chalk from 'chalk';
+import { findProjectRoot } from '../project.js';
+import { logFileExists } from '../metro.js';
+import { getExecutor } from '../exec.js';
+
+export default function logsCommand(program) {
+  program
+    .command('logs')
+    .description('Tail the Metro log file for the current project')
+    .action(() => {
+      const root = findProjectRoot(process.cwd());
+      if (!root) {
+        console.error(chalk.red('Not in a React Native project.'));
+        process.exit(1);
+      }
+      const path = logFileExists(root);
+      if (!path) {
+        console.error(chalk.red('No Metro log file found. Have you run `rn-iso start` or `rn-iso ios/android`?'));
+        process.exit(1);
+      }
+      console.log(chalk.dim(`Tailing ${path}\n`));
+      const exec = getExecutor();
+      const child = exec.spawn('tail', ['-f', path], { stdio: 'inherit' });
+      // Forward SIGINT cleanly
+      process.on('SIGINT', () => child.kill('SIGINT'));
+    });
+}

package/src/commands/prune.js

@@ -0,0 +1,57 @@
+// src/commands/prune.js
+import { existsSync } from 'fs';
+import chalk from 'chalk';
+import { loadConfig, removeProject, clearDevice } from '../config.js';
+import { listAllIosSims, shutdownIosSim } from '../sim/ios.js';
+import { listAvds, shutdownAndroidEmulator } from '../sim/android.js';
+
+export default function pruneCommand(program) {
+  program
+    .command('prune')
+    .description('Garbage-collect dead project entries and missing device assignments')
+    .option('--shutdown', 'Also shut down sims/emulators referenced only by dropped entries')
+    .action((opts) => {
+      const cfg = loadConfig();
+      if (!cfg?.projects) {
+        console.log(chalk.dim('Nothing to prune.'));
+        return;
+      }
+
+      const allIosUdids = new Set(listAllIosSims().map(s => s.udid));
+      const allAvds = new Set(listAvds());
+
+      const droppedSims = [];
+      const droppedEmulators = [];
+
+      for (const [path, proj] of Object.entries(cfg.projects)) {
+        // Drop entire project if its dir is gone.
+        if (!existsSync(path)) {
+          if (opts.shutdown) {
+            if (proj.platforms?.ios?.deviceUdid) droppedSims.push(proj.platforms.ios.deviceUdid);
+            if (proj.platforms?.android?.consolePort) droppedEmulators.push(proj.platforms.android.consolePort);
+          }
+          removeProject(path);
+          console.log(chalk.yellow(`Dropped missing project: ${path}`));
+          continue;
+        }
+
+        // Drop iOS assignment if UDID no longer exists.
+        if (proj.platforms?.ios && !allIosUdids.has(proj.platforms.ios.deviceUdid)) {
+          clearDevice(path, 'ios');
+          console.log(chalk.dim(`${path}: cleared stale iOS assignment ${proj.platforms.ios.deviceUdid}`));
+        }
+        // Drop Android assignment if AVD no longer exists.
+        if (proj.platforms?.android && !allAvds.has(proj.platforms.android.avdName)) {
+          clearDevice(path, 'android');
+          console.log(chalk.dim(`${path}: cleared stale Android assignment ${proj.platforms.android.avdName}`));
+        }
+      }
+
+      if (opts.shutdown) {
+        for (const udid of droppedSims) shutdownIosSim(udid);
+        for (const port of droppedEmulators) shutdownAndroidEmulator(`emulator-${port}`);
+      }
+
+      console.log(chalk.green('Prune complete.'));
+    });
+}

package/src/commands/release.js

@@ -0,0 +1,51 @@
+// src/commands/release.js
+import chalk from 'chalk';
+import { resolveRegisteredProject } from '../project.js';
+import { getProject, clearDevice, findReservations, removeReservation } from '../config.js';
+
+export default function releaseCommand(program) {
+  program
+    .command('release [target]')
+    .description('Free a project assignment OR a reservation. [target] is an absolute project path, a reservation label (set via `rn-iso reserve --label`), or a UDID/serial. Defaults to the current project.')
+    .option('--platform <platform>', 'ios or android (default: both)')
+    .action((target, opts) => {
+      // 1. If a target was given, try it as a reservation label / id first.
+      if (target) {
+        const matches = findReservations(target, opts.platform);
+        if (matches.length > 0) {
+          for (const m of matches) {
+            removeReservation(m.platform, m.id);
+            console.log(chalk.green(
+              `Released ${m.platform} reservation ${m.id}` +
+              (m.label ? ` (${m.label})` : '')
+            ));
+          }
+          return;
+        }
+      }
+
+      // 2. Otherwise treat the target as a project path (or default to cwd).
+      const { found, error } = resolveRegisteredProject(target);
+      if (!found) {
+        console.error(chalk.red(error));
+        if (target) {
+          console.error(chalk.dim('(Also tried as reservation label/id; no match.)'));
+        }
+        process.exit(1);
+      }
+      const proj = getProject(found);
+      if (!proj) {
+        console.log(chalk.dim('No project entry to release.'));
+        return;
+      }
+      const platforms = opts.platform ? [opts.platform] : ['ios', 'android'];
+      for (const p of platforms) {
+        if (proj.platforms?.[p]) {
+          clearDevice(found, p);
+          console.log(chalk.green(`Released ${p} assignment for ${found}.`));
+        } else {
+          console.log(chalk.dim(`No ${p} assignment to release for ${found}.`));
+        }
+      }
+    });
+}

package/src/commands/reserve.js

@@ -0,0 +1,176 @@
+// src/commands/reserve.js
+import chalk from 'chalk';
+import prompts from 'prompts';
+import { addReservation, listReservations, allClaimedDevices } from '../config.js';
+import { listBootedIosSims } from '../sim/ios.js';
+import { listAdbDevices, getAvdNameForSerial } from '../sim/android.js';
+
+export default function reserveCommand(program) {
+  program
+    .command('reserve [platform] [identifier]')
+    .description('Mark a sim/emulator as in-use by an external process so rn-iso skips it during allocation')
+    .option('--label <text>', 'Optional label (e.g. "agent-1") for clarity in `rn-iso status`')
+    .option('--list', 'List current reservations and exit')
+    .action(async (platform, identifier, opts) => {
+      if (opts.list) {
+        printReservations();
+        return;
+      }
+
+      // Direct path: both platform and identifier provided.
+      if (platform && identifier) {
+        addOne(platform, identifier, opts.label);
+        return;
+      }
+
+      // Interactive path: list running devices and multi-select.
+      if (platform && platform !== 'ios' && platform !== 'android') {
+        console.error(chalk.red(`Unknown platform: ${platform}. Use ios or android.`));
+        process.exit(1);
+      }
+
+      const showIos = !platform || platform === 'ios';
+      const showAndroid = !platform || platform === 'android';
+      const claimed = allClaimedDevices();
+      const claimedIos = new Set(claimed.iosUdids);
+      const claimedAndroidPorts = new Set(claimed.androidConsolePorts);
+
+      const choices = [];
+
+      if (showIos) {
+        let iosSims = [];
+        try {
+          iosSims = listBootedIosSims();
+        } catch (e) {
+          console.error(chalk.dim(`(could not list iOS sims: ${e.message})`));
+        }
+        for (const sim of iosSims) {
+          const taken = claimedIos.has(sim.udid);
+          choices.push({
+            title: `${chalk.bold('ios')}  ${sim.name.padEnd(22)} ${chalk.dim(sim.udid)}${taken ? chalk.yellow(' [reserved]') : ''}`,
+            value: { kind: 'ios', udid: sim.udid, name: sim.name },
+            disabled: taken,
+          });
+        }
+      }
+
+      if (showAndroid) {
+        let emulators = [];
+        try {
+          emulators = listAdbDevices().emulators;
+        } catch (e) {
+          console.error(chalk.dim(`(could not list Android emulators: ${e.message})`));
+        }
+        for (const e of emulators) {
+          const taken = claimedAndroidPorts.has(e.consolePort);
+          const avdName = taken ? null : getAvdNameForSerial(e.serial);
+          const label = avdName ? `${avdName} on ${e.serial}` : e.serial;
+          choices.push({
+            title: `${chalk.bold('and')}  ${label}${taken ? chalk.yellow(' [reserved]') : ''}`,
+            value: { kind: 'android', serial: e.serial, consolePort: e.consolePort, avdName },
+            disabled: taken,
+          });
+        }
+      }
+
+      if (choices.length === 0) {
+        const what = !platform ? 'booted iOS sims or running Android emulators'
+          : platform === 'ios' ? 'booted iOS sims'
+          : 'running Android emulators';
+        console.error(chalk.red(`No ${what} found.`));
+        process.exit(1);
+      }
+
+      const answer = await prompts({
+        type: 'multiselect',
+        name: 'selected',
+        message: 'Pick devices to reserve (space to toggle, enter to confirm)',
+        choices,
+        instructions: false,
+        hint: '- space to select, enter to confirm',
+      });
+
+      if (!answer.selected || answer.selected.length === 0) {
+        console.log(chalk.dim('Nothing selected.'));
+        return;
+      }
+
+      let label = opts.label;
+      if (!label) {
+        const labelAnswer = await prompts({
+          type: 'text',
+          name: 'label',
+          message: 'Label (optional, e.g. "agent-1"):',
+        });
+        label = labelAnswer.label || undefined;
+      }
+
+      for (const sel of answer.selected) {
+        if (sel.kind === 'ios') {
+          addReservation('ios', { udid: sel.udid, label });
+          console.log(chalk.green(`Reserved iOS ${sel.name} (${sel.udid})${label ? ` (${label})` : ''}`));
+        } else {
+          addReservation('android', {
+            serial: sel.serial,
+            consolePort: sel.consolePort,
+            avdName: sel.avdName,
+            label,
+          });
+          console.log(chalk.green(
+            `Reserved emulator ${sel.serial}` +
+            (sel.avdName ? ` (AVD: ${sel.avdName})` : '') +
+            (label ? ` (${label})` : '')
+          ));
+        }
+      }
+    });
+}
+
+function addOne(platform, identifier, label) {
+  if (platform === 'ios') {
+    addReservation('ios', { udid: identifier, label });
+    console.log(chalk.green(`Reserved iOS sim ${identifier}${label ? ` (${label})` : ''}`));
+    return;
+  }
+  if (platform === 'android') {
+    const m = identifier.match(/^emulator-(\d+)$/);
+    if (!m) {
+      console.error(chalk.red('Android identifier must look like emulator-5554'));
+      process.exit(1);
+    }
+    const consolePort = parseInt(m[1], 10);
+    const avdName = getAvdNameForSerial(identifier);
+    addReservation('android', { serial: identifier, consolePort, avdName, label });
+    console.log(chalk.green(
+      `Reserved emulator ${identifier}` +
+      (avdName ? ` (AVD: ${avdName})` : '') +
+      (label ? ` (${label})` : '')
+    ));
+    return;
+  }
+  console.error(chalk.red(`Unknown platform: ${platform}. Use ios or android.`));
+  process.exit(1);
+}
+
+function printReservations() {
+  const r = listReservations();
+  const ios = r.ios || [];
+  const android = r.android || [];
+  if (ios.length === 0 && android.length === 0) {
+    console.log(chalk.dim('No reservations.'));
+    return;
+  }
+  if (ios.length > 0) {
+    console.log(chalk.bold('iOS:'));
+    for (const e of ios) {
+      console.log(`  ${chalk.cyan(e.udid)}${e.label ? chalk.dim(` (${e.label})`) : ''}`);
+    }
+  }
+  if (android.length > 0) {
+    console.log(chalk.bold('Android:'));
+    for (const e of android) {
+      const tag = e.avdName ? `${e.avdName} on ${e.serial}` : e.serial;
+      console.log(`  ${chalk.cyan(tag)}${e.label ? chalk.dim(` (${e.label})`) : ''}`);
+    }
+  }
+}

package/src/commands/shutdown.js

@@ -0,0 +1,41 @@
+// src/commands/shutdown.js
+import chalk from 'chalk';
+import { findProjectRoot } from '../project.js';
+import { getProject, clearDevice } from '../config.js';
+import { shutdownIosSim } from '../sim/ios.js';
+import { shutdownAndroidEmulator } from '../sim/android.js';
+
+export default function shutdownCommand(program) {
+  program
+    .command('shutdown')
+    .description('Release and shut down the simulator/emulator(s) for the current project')
+    .option('--platform <platform>', 'ios or android (default: both)')
+    .action((opts) => {
+      const root = findProjectRoot(process.cwd());
+      if (!root) {
+        console.error(chalk.red('Not in a React Native project.'));
+        process.exit(1);
+      }
+      const proj = getProject(root);
+      if (!proj) {
+        console.log(chalk.dim('No project entry.'));
+        return;
+      }
+      const platforms = opts.platform ? [opts.platform] : ['ios', 'android'];
+      for (const p of platforms) {
+        const entry = proj.platforms?.[p];
+        if (!entry) {
+          console.log(chalk.dim(`No ${p} assignment.`));
+          continue;
+        }
+        if (p === 'ios') {
+          shutdownIosSim(entry.deviceUdid);
+          console.log(chalk.green(`Shut down iOS sim ${entry.deviceUdid}`));
+        } else {
+          shutdownAndroidEmulator(`emulator-${entry.consolePort}`);
+          console.log(chalk.green(`Shut down emulator-${entry.consolePort}`));
+        }
+        clearDevice(root, p);
+      }
+    });
+}

package/src/commands/start.js

@@ -0,0 +1,43 @@
+// src/commands/start.js
+import chalk from 'chalk';
+import { findProjectRoot, detectIsExpo, detectBundleId, detectAndroidPackage } from '../project.js';
+import { getProject, upsertProject, setMetro } from '../config.js';
+import { allocatePort } from '../ports.js';
+import { ensureMetro } from '../metro.js';
+
+export default function startCommand(program) {
+  program
+    .command('start')
+    .description('Ensure Metro is running for the current project (no platform action)')
+    .action(async () => {
+      const root = findProjectRoot(process.cwd());
+      if (!root) {
+        console.error(chalk.red('Not in a React Native project (no package.json found).'));
+        process.exit(1);
+      }
+      const isExpo = detectIsExpo(root);
+
+      let proj = getProject(root);
+      if (!proj) {
+        upsertProject(root, {
+          bundleId: detectBundleId(root),
+          androidPackage: detectAndroidPackage(root),
+          isExpo,
+        });
+        proj = getProject(root);
+      }
+      if (!proj.metroPort) {
+        const port = await allocatePort(root);
+        setMetro(root, port, null);
+        proj = getProject(root);
+      }
+
+      const metro = await ensureMetro({ projectPath: root, isExpo, port: proj.metroPort });
+      if (metro.alreadyRunning) {
+        console.log(chalk.dim(`Metro already running on port ${proj.metroPort}`));
+      } else {
+        setMetro(root, proj.metroPort, metro.pid);
+        console.log(chalk.green(`Metro started (pid ${metro.pid}, port ${proj.metroPort})`));
+      }
+    });
+}

package/src/commands/status.js

@@ -0,0 +1,60 @@
+// src/commands/status.js
+import chalk from 'chalk';
+import { loadConfig } from '../config.js';
+import { isMetroRunning } from '../ports.js';
+import { isPidAlive } from '../metro.js';
+import { findProjectRoot } from '../project.js';
+
+export default function statusCommand(program) {
+  program
+    .command('status')
+    .description('Show all rn-iso project assignments and Metro state')
+    .action(async () => {
+      const cfg = loadConfig();
+      const hasProjects = cfg && Object.keys(cfg.projects || {}).length > 0;
+      const reservations = cfg?.reservations || { ios: [], android: [] };
+      const hasReservations = (reservations.ios?.length || 0) + (reservations.android?.length || 0) > 0;
+
+      if (!hasProjects && !hasReservations) {
+        console.log(chalk.dim('No projects registered.'));
+        return;
+      }
+
+      const cwdRoot = findProjectRoot(process.cwd());
+
+      for (const [path, proj] of Object.entries(cfg?.projects || {})) {
+        const isCurrent = path === cwdRoot;
+        const header = isCurrent ? chalk.bold.cyan(`* ${path}`) : path;
+        console.log('\n' + header);
+        console.log(chalk.dim(`  app: ${proj.bundleId} (${proj.isExpo ? 'expo' : 'bare'})`));
+
+        if (proj.metroPort) {
+          const running = await isMetroRunning(proj.metroPort);
+          const pidLive = isPidAlive(proj.metroPid);
+          const label = running
+            ? chalk.green('running')
+            : pidLive ? chalk.yellow('pid alive but not responding') : chalk.dim('stopped');
+          console.log(`  metro: port ${proj.metroPort} pid ${proj.metroPid ?? '?'} (${label})`);
+        } else {
+          console.log(chalk.dim('  metro: unassigned'));
+        }
+
+        const ios = proj.platforms?.ios;
+        if (ios) console.log(`  ios: ${chalk.cyan(ios.deviceUdid)}`);
+        const android = proj.platforms?.android;
+        if (android) console.log(`  android: ${chalk.cyan(android.avdName)} on emulator-${android.consolePort}`);
+      }
+
+      if (hasReservations) {
+        console.log('\n' + chalk.bold('Reservations (external):'));
+        for (const r of reservations.ios || []) {
+          console.log(`  ios: ${chalk.cyan(r.udid)}${r.label ? chalk.dim(` (${r.label})`) : ''}`);
+        }
+        for (const r of reservations.android || []) {
+          const tag = r.avdName ? `${r.avdName} on ${r.serial}` : r.serial;
+          console.log(`  android: ${chalk.cyan(tag)}${r.label ? chalk.dim(` (${r.label})`) : ''}`);
+        }
+      }
+      console.log('');
+    });
+}