rn-iso 0.1.0 → 0.2.0

package/src/commands/ios.js

@@ -2,11 +2,12 @@
 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 { getProject, upsertProject, setMetro, setDevice, clearDevice, 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';
+import { resolveLabel } from '../labels.js';
 
 export default function iosCommand(program) {
   program
@@ -14,7 +15,8 @@ export default function iosCommand(program) {
     .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('--auto', 'Non-interactive: pick the first unclaimed sim without prompting (also implied when stdin is not a TTY)')
+    .option('--label <name>', 'Optional shortcut name; refer to the project as <name> in stop / release / etc.')
     .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)')
@@ -26,11 +28,21 @@ export default function iosCommand(program) {
         process.exit(1);
       }
 
+      // Treat non-TTY environments (agents, CI) as if --auto was passed.
+      const auto = opts.auto || !process.stdin.isTTY;
+
       const bundleId = detectBundleId(root);
       const androidPackage = detectAndroidPackage(root);
       const isExpo = detectIsExpo(root);
 
-      upsertProject(root, { bundleId, androidPackage, isExpo });
+      const existing = getProject(root);
+      const label = await resolveLabel({ root, existingProject: existing, optsLabel: opts.label });
+      upsertProject(root, {
+        bundleId,
+        androidPackage,
+        isExpo,
+        ...(label ? { label } : {}),
+      });
       let proj = getProject(root);
 
       if (!proj.metroPort) {
@@ -65,28 +77,59 @@ export default function iosCommand(program) {
           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})...`));
+        const picked = (selection.candidates.length === 1 || auto)
+          ? { sim: selection.candidates[0], prevClaim: null }
+          : await pickSim({
+              candidates: selection.candidates,
+              iosClaims: claimedDevices.iosClaims,
+              usage,
+            });
+        udid = picked.sim.udid;
+        releasePriorClaim(picked.prevClaim);
+        if (picked.sim.state !== 'Booted') {
+          console.log(chalk.dim(`Booting ${picked.sim.name} (${udid})...`));
           bootIosSim(udid);
         } else {
-          console.log(chalk.green(`Assigned ${picked.name} (${udid}, booted)`));
+          console.log(chalk.green(`Assigned ${picked.sim.name} (${udid}, booted)`));
+        }
+      } else if (selection.kind === 'allClaimed') {
+        // Sims exist but every one is claimed by another project. With
+        // --auto, refuse rather than silently stealing. Interactive: show
+        // picker so the user can confirm-steal one.
+        if (auto) {
+          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('All iOS simulators are claimed by other rn-iso projects.'));
+            console.error(chalk.dim('Re-run without --auto to confirm taking one over, or pass --device-type to create a new sim.'));
+            process.exit(1);
+          }
+        } else {
+          const picked = await pickSim({
+            candidates: [],
+            iosClaims: claimedDevices.iosClaims,
+            usage,
+            allClaimed: true,
+          });
+          udid = picked.sim.udid;
+          releasePriorClaim(picked.prevClaim);
+          if (picked.sim.state !== 'Booted') {
+            console.log(chalk.dim(`Booting ${picked.sim.name} (${udid})...`));
+            bootIosSim(udid);
+          } else {
+            console.log(chalk.green(`Took over ${picked.sim.name} (${udid}, booted)`));
+          }
         }
       } else {
-        // needsBoot: no unclaimed sim available.
+        // noSims: no iOS simulators exist on this machine at all.
         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'));
+          console.error(chalk.red('No iOS simulators found.'));
+          console.error(chalk.dim('Pass --device-type "iPhone 17 Pro" [--runtime 26.2] to create one,'));
+          console.error(chalk.dim('or install a simulator runtime via Xcode.'));
           process.exit(1);
         }
       }
@@ -125,10 +168,10 @@ export default function iosCommand(program) {
     });
 }
 
-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.
+async function pickSim({ candidates, iosClaims = {}, usage = {}, allClaimed = false }) {
+  // Show ALL sims so the user has full context. Unclaimed candidates pick
+  // immediately; claimed sims are selectable too but require a confirm
+  // prompt so the steal is intentional.
   const allSims = listAllIosSims();
   const candidateUdids = new Set(candidates.map(s => s.udid));
   const sorted = sortSims(allSims, usage);
@@ -140,37 +183,56 @@ async function pickSim(candidates, iosClaims = {}, usage = {}) {
     const versionPart = version.padStart(6);
     const claim = iosClaims[s.udid];
     if (claim) {
-      const tag = claim.source === 'project'
-        ? `[claimed by ${claim.label}]`
-        : `[reserved: ${claim.label}]`;
+      const stateTag = s.state === 'Booted' ? chalk.green(' [booted]') : '';
       return {
-        title: chalk.dim(`${namePart}  ${versionPart}  ${tag}`),
-        value: null,
-        disabled: true,
+        title: chalk.yellow(`${namePart}  ${versionPart}  [claimed by ${claim.label}]${stateTag}`),
+        value: { sim: s, claim },
       };
     }
     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,
+      value: { sim: s, claim: null },
     };
   });
+  const message = allClaimed
+    ? 'All sims are claimed. Pick one to take over:'
+    : 'Pick a simulator (claimed sims will prompt to confirm):';
   const answer = await prompts({
     type: 'select',
-    name: 'sim',
-    message: 'Pick a simulator:',
+    name: 'pick',
+    message,
     choices,
   });
-  if (!answer.sim) {
+  if (!answer.pick) {
     console.error(chalk.red('Cancelled.'));
     process.exit(1);
   }
-  return answer.sim;
+  const { sim, claim } = answer.pick;
+  if (claim) {
+    const confirm = await prompts({
+      type: 'confirm',
+      name: 'ok',
+      message: `${sim.name} is currently held by project "${claim.label}". Take it over?`,
+      initial: false,
+    });
+    if (!confirm.ok) {
+      console.error(chalk.red('Cancelled.'));
+      process.exit(1);
+    }
+    return { sim, prevClaim: claim };
+  }
+  return { sim, prevClaim: null };
+}
+
+function releasePriorClaim(prevClaim) {
+  if (!prevClaim?.path) return;
+  clearDevice(prevClaim.path, 'ios');
+  console.log(chalk.dim(`Released prior assignment from "${prevClaim.label}"`));
 }
 
 function createNewSim({ deviceType, runtimeVersion }) {

package/src/commands/release.js

@@ -1,36 +1,20 @@
 // src/commands/release.js
 import chalk from 'chalk';
 import { resolveRegisteredProject } from '../project.js';
-import { getProject, clearDevice, findReservations, removeReservation } from '../config.js';
+import { getProject, clearDevice } from '../config.js';
+import { shutdownIosSim } from '../sim/ios.js';
+import { shutdownAndroidEmulator } from '../sim/android.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.')
+    .description('Free a project assignment. [target] is an absolute project path; defaults to the current project.')
     .option('--platform <platform>', 'ios or android (default: both)')
+    .option('--shutdown', 'Also shut down the simulator/emulator after releasing')
     .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);
@@ -40,12 +24,22 @@ export default function releaseCommand(program) {
       }
       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 {
+        const entry = proj.platforms?.[p];
+        if (!entry) {
           console.log(chalk.dim(`No ${p} assignment to release for ${found}.`));
+          continue;
+        }
+        if (opts.shutdown) {
+          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(found, p);
+        console.log(chalk.green(`Released ${p} assignment for ${found}.`));
       }
     });
 }

package/src/commands/reserve.js

@@ -1,176 +1,173 @@
 // 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 { findProjectRoot, detectIsExpo, detectBundleId, detectAndroidPackage } from '../project.js';
+import { getProject, upsertProject, setMetro, setDevice, clearDevice, allClaimedDevices } from '../config.js';
+import { allocatePort } from '../ports.js';
+import { listBootedIosSims, parseRuntimeVersion, sortSims } from '../sim/ios.js';
 import { listAdbDevices, getAvdNameForSerial } from '../sim/android.js';
+import { resolveLabel } from '../labels.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.`));
+    .command('reserve [platform]')
+    .description('Lock a manually-started sim/emulator to the current project (registers without building).')
+    .option('--label <name>', 'Optional shortcut name; refer to the project as <name> in stop / release / etc.')
+    .action(async (platform, opts) => {
+      const plat = platform || 'ios';
+      if (plat !== 'ios' && plat !== 'android') {
+        console.error(chalk.red(`Unknown platform: ${plat}. 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.`));
+      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 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',
+      const existing = getProject(root);
+      const label = await resolveLabel({ root, existingProject: existing, optsLabel: opts.label });
+      upsertProject(root, {
+        bundleId: detectBundleId(root),
+        androidPackage: detectAndroidPackage(root),
+        isExpo: detectIsExpo(root),
+        ...(label ? { label } : {}),
       });
-
-      if (!answer.selected || answer.selected.length === 0) {
-        console.log(chalk.dim('Nothing selected.'));
-        return;
+      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}`));
       }
 
-      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})` : '')
-          ));
-        }
+      if (plat === 'ios') {
+        await reserveIos(root, proj);
+      } else {
+        await reserveAndroid(root, proj);
       }
     });
 }
 
-function addOne(platform, identifier, label) {
-  if (platform === 'ios') {
-    addReservation('ios', { udid: identifier, label });
-    console.log(chalk.green(`Reserved iOS sim ${identifier}${label ? ` (${label})` : ''}`));
-    return;
+async function reserveIos(root, proj) {
+  const booted = listBootedIosSims();
+  if (booted.length === 0) {
+    console.error(chalk.red('No booted iOS simulators found.'));
+    console.error(chalk.dim('Boot one (Simulator.app, Xcode, or `xcrun simctl boot`) and re-run.'));
+    process.exit(1);
+  }
+
+  const auto = !process.stdin.isTTY;
+  const claims = allClaimedDevices().iosClaims;
+  const sorted = sortSims(booted);
+
+  let pick;
+  if (sorted.length === 1 || auto) {
+    pick = sorted[0];
+  } else {
+    const nameWidth = Math.max(...sorted.map(s => s.name.length), 18);
+    const choices = sorted.map(s => {
+      const claim = claims[s.udid];
+      const tag = !claim ? ''
+        : claim.path === root ? chalk.dim(' [already yours]')
+        : chalk.yellow(` [claimed by ${claim.label}]`);
+      const title = `${s.name.padEnd(nameWidth)}  ${chalk.dim(parseRuntimeVersion(s.runtime).padStart(6))}${tag}`;
+      return { title, value: s };
+    });
+    const answer = await prompts({
+      type: 'select',
+      name: 'sim',
+      message: 'Pick a booted simulator to lock to this project:',
+      choices,
+    });
+    if (!answer.sim) {
+      console.error(chalk.red('Cancelled.'));
+      process.exit(1);
+    }
+    pick = answer.sim;
   }
-  if (platform === 'android') {
-    const m = identifier.match(/^emulator-(\d+)$/);
-    if (!m) {
-      console.error(chalk.red('Android identifier must look like emulator-5554'));
+
+  const claim = claims[pick.udid];
+  if (claim && claim.path !== root) {
+    if (auto) {
+      console.error(chalk.red(`${pick.name} is held by project "${claim.label}". Re-run interactively to confirm taking it over.`));
       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;
+    const ok = await prompts({
+      type: 'confirm',
+      name: 'ok',
+      message: `${pick.name} is currently held by project "${claim.label}". Take it over?`,
+      initial: false,
+    });
+    if (!ok.ok) {
+      console.error(chalk.red('Cancelled.'));
+      process.exit(1);
+    }
+    clearDevice(claim.path, 'ios');
+    console.log(chalk.dim(`Released prior assignment from "${claim.label}"`));
   }
-  console.error(chalk.red(`Unknown platform: ${platform}. Use ios or android.`));
-  process.exit(1);
+
+  setDevice(root, 'ios', { deviceUdid: pick.udid });
+  console.log(chalk.green(`Locked iOS sim ${pick.name} (${pick.udid}) to ${root}`));
 }
 
-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;
+async function reserveAndroid(root, proj) {
+  const running = listAdbDevices().emulators;
+  if (running.length === 0) {
+    console.error(chalk.red('No running Android emulators found.'));
+    console.error(chalk.dim('Start one (Android Studio or `emulator -avd ...`) and re-run.'));
+    process.exit(1);
   }
-  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})`) : ''}`);
+
+  const auto = !process.stdin.isTTY;
+  const claims = allClaimedDevices().androidClaims;
+
+  let pick;
+  if (running.length === 1 || auto) {
+    pick = running[0];
+  } else {
+    const choices = running.map(e => {
+      const claim = claims[e.consolePort];
+      const tag = !claim ? ''
+        : claim.path === root ? chalk.dim(' [already yours]')
+        : chalk.yellow(` [claimed by ${claim.label}]`);
+      return { title: `${e.serial}${tag}`, value: e };
+    });
+    const answer = await prompts({
+      type: 'select',
+      name: 'emu',
+      message: 'Pick a running emulator to lock to this project:',
+      choices,
+    });
+    if (!answer.emu) {
+      console.error(chalk.red('Cancelled.'));
+      process.exit(1);
     }
+    pick = answer.emu;
   }
-  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})`) : ''}`);
+
+  const claim = claims[pick.consolePort];
+  if (claim && claim.path !== root) {
+    if (auto) {
+      console.error(chalk.red(`${pick.serial} is held by project "${claim.label}". Re-run interactively to confirm taking it over.`));
+      process.exit(1);
     }
+    const ok = await prompts({
+      type: 'confirm',
+      name: 'ok',
+      message: `${pick.serial} is held by project "${claim.label}". Take it over?`,
+      initial: false,
+    });
+    if (!ok.ok) {
+      console.error(chalk.red('Cancelled.'));
+      process.exit(1);
+    }
+    clearDevice(claim.path, 'android');
+    console.log(chalk.dim(`Released prior assignment from "${claim.label}"`));
   }
+
+  const avdName = getAvdNameForSerial(pick.serial) || `emulator-${pick.consolePort}`;
+  setDevice(root, 'android', { avdName, consolePort: pick.consolePort });
+  console.log(chalk.green(`Locked emulator ${pick.serial} (AVD: ${avdName}) to ${root}`));
 }

package/src/commands/status.js

@@ -12,10 +12,7 @@ export default function statusCommand(program) {
     .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) {
+      if (!hasProjects) {
         console.log(chalk.dim('No projects registered.'));
         return;
       }
@@ -44,17 +41,6 @@ export default function statusCommand(program) {
         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('');
     });
 }