rn-iso 0.3.0 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rn-iso",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "description": "Isolated React Native dev environments per project/worktree",
   "type": "module",
   "bin": {

package/src/commands/android.js

@@ -7,6 +7,7 @@ import { allocatePort, isMetroRunning } from '../ports.js';
 import {
   selectAndroidDevice,
   sortAndroidCandidates,
+  enumerateAndroidCandidates,
   bootAndroidEmulator,
   waitForBoot,
   adbReverse,
@@ -77,16 +78,16 @@ export default function androidCommand(program) {
       if (selection.kind === 'reuse') {
         ({ avdName, consolePort, isRunning } = selection);
         if (isRunning) {
-          console.log(chalk.dim(`Reusing running emulator emulator-${consolePort} (${avdName})`));
+          console.log(chalk.dim(`Reusing running ${avdName} (emulator-${consolePort})`));
         } else {
-          console.log(chalk.dim(`Booting assigned AVD ${avdName} on port ${consolePort}...`));
+          console.log(chalk.dim(`Booting assigned ${avdName} (emulator-${consolePort})...`));
         }
       } else if (selection.kind === 'allocate') {
         const picked = (selection.candidates.length === 1 || auto)
           ? { c: selection.candidates[0], prevClaim: null }
           : await pickAvd({
               candidates: selection.candidates,
-              androidClaims: claimed.androidClaims,
+              androidClaimsByAvd: claimed.androidClaimsByAvd,
             });
         await releasePriorClaim(picked.prevClaim);
         ({ avdName, isRunning, consolePort } = picked.c);
@@ -94,8 +95,8 @@ export default function androidCommand(program) {
           consolePort = nextConsolePort(claimedPorts);
         }
         console.log(isRunning
-          ? chalk.green(`Picked ${avdName} (running on emulator-${consolePort})`)
-          : chalk.dim(`Booting ${avdName} on port ${consolePort}...`));
+          ? chalk.green(`Picked ${avdName} (emulator-${consolePort}, running)`)
+          : chalk.dim(`Booting ${avdName} (emulator-${consolePort})...`));
       } else if (selection.kind === 'allClaimed') {
         if (auto) {
           console.error(chalk.red('All Android AVDs are claimed by other rn-iso projects.'));
@@ -104,7 +105,7 @@ export default function androidCommand(program) {
         }
         const picked = await pickAvd({
           candidates: selection.candidates,
-          androidClaims: claimed.androidClaims,
+          androidClaimsByAvd: claimed.androidClaimsByAvd,
           allClaimed: true,
         });
         await releasePriorClaim(picked.prevClaim);
@@ -115,8 +116,8 @@ export default function androidCommand(program) {
           consolePort = nextConsolePort(fresh);
         }
         console.log(isRunning
-          ? chalk.green(`Took over ${avdName} (running on emulator-${consolePort})`)
-          : chalk.dim(`Booting ${avdName} on port ${consolePort}...`));
+          ? chalk.green(`Took over ${avdName} (emulator-${consolePort}, running)`)
+          : chalk.dim(`Booting ${avdName} (emulator-${consolePort})...`));
       } else {
         console.error(chalk.red(
           'No AVDs available. Create one via Android Studio (Tools -> Device Manager).'
@@ -149,6 +150,7 @@ export default function androidCommand(program) {
           packageManager,
           scriptName,
           isExpo,
+          avdName,
           serial,
           port: proj.metroPort,
           useScript,
@@ -161,20 +163,34 @@ export default function androidCommand(program) {
         });
       }
 
-      console.log(chalk.green(`\nAndroid ready on ${serial}, Metro port ${proj.metroPort}`));
+      console.log(chalk.green(`\nAndroid ready on ${avdName} (${serial}), Metro port ${proj.metroPort}`));
     });
 }
 
-async function pickAvd({ candidates, androidClaims = {}, allClaimed = false }) {
-  const sorted = sortAndroidCandidates(candidates);
+async function pickAvd({ candidates, androidClaimsByAvd = {}, allClaimed = false }) {
+  // Show every AVD on disk (parallel to the iOS picker), so the user can
+  // see what's claimed and optionally take it over. `candidates` is the
+  // unclaimed set passed in by selectAndroidDevice; AVDs outside it are
+  // claimed and will require a confirm prompt on selection.
+  const allAvds = enumerateAndroidCandidates();
+  const candidateAvds = new Set(candidates.map(c => c.avdName));
+  const sorted = sortAndroidCandidates(allAvds);
+
   const nameWidth = Math.max(...sorted.map(c => c.avdName.length), 18);
   const choices = sorted.map(c => {
-    const claim = androidClaims[c.consolePort];
-    const claimTag = claim ? chalk.yellow(`  [claimed by ${claim.label}]`) : '';
-    const runTag = c.isRunning ? chalk.green(`  [running on emulator-${c.consolePort}]`) : '';
+    const claim = androidClaimsByAvd[c.avdName];
+    const isCandidate = candidateAvds.has(c.avdName);
+    const runTag = c.isRunning ? chalk.green(` [emulator-${c.consolePort}, running]`) : '';
+    if (claim || !isCandidate) {
+      const tag = claim ? chalk.yellow(` [claimed by ${claim.label}]`) : '';
+      return {
+        title: chalk.yellow(`${c.avdName.padEnd(nameWidth)}${tag}${runTag}`),
+        value: { c, claim: claim || null },
+      };
+    }
     return {
-      title: `${c.avdName.padEnd(nameWidth)}${runTag}${claimTag}`,
-      value: { c, claim: claim || null },
+      title: `${c.avdName.padEnd(nameWidth)}${runTag}`,
+      value: { c, claim: null },
     };
   });
   const message = allClaimed

package/src/commands/ios.js

@@ -4,7 +4,7 @@ import prompts from 'prompts';
 import { findProjectRoot, detectIsExpo, detectBundleId, detectAndroidPackage } from '../project.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 { selectIosDevice, bootIosSim, listIosRuntimes, createIosSim, parseRuntimeVersion, listAllIosSims, sortSims, formatIosLabel } from '../sim/ios.js';
 import { buildIosCommand, detectPackageManager } from '../runner.js';
 import { getExecutor } from '../exec.js';
 import { resolveLabel } from '../labels.js';
@@ -70,11 +70,12 @@ export default function iosCommand(program) {
       let udid;
       if (selection.kind === 'reuse') {
         udid = selection.udid;
+        const label = `${selection.name} (${udid})`;
         if (selection.state !== 'Booted') {
-          console.log(chalk.dim(`Booting assigned sim ${udid}...`));
+          console.log(chalk.dim(`Booting assigned sim ${label}...`));
           bootIosSim(udid);
         } else {
-          console.log(chalk.dim(`Reusing assigned sim ${udid} (already booted)`));
+          console.log(chalk.dim(`Reusing assigned sim ${label} (already booted)`));
         }
       } else if (selection.kind === 'allocate') {
         const picked = (selection.candidates.length === 1 || auto)
@@ -99,7 +100,7 @@ export default function iosCommand(program) {
         if (auto) {
           if (opts.deviceType) {
             udid = createNewSim({ deviceType: opts.deviceType, runtimeVersion: opts.runtime });
-            console.log(chalk.green(`Created and booted new sim ${udid}`));
+            console.log(chalk.green(`Created and booted new sim ${formatIosLabel(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.'));
@@ -164,7 +165,7 @@ export default function iosCommand(program) {
 
       }
 
-      console.log(chalk.green(`\nOK: iOS ready on sim ${udid}, Metro port ${proj.metroPort}`));
+      console.log(chalk.green(`\nOK: iOS ready on sim ${formatIosLabel(udid)}, Metro port ${proj.metroPort}`));
     });
 }
 

package/src/commands/release.js

@@ -4,7 +4,7 @@ import prompts from 'prompts';
 import { resolveRegisteredProject } from '../project.js';
 import { getProject, clearDevice, findProjectByMetroPort } from '../config.js';
 import { findPidListeningOnPort } from '../metro.js';
-import { shutdownIosSim } from '../sim/ios.js';
+import { shutdownIosSim, formatIosLabel } from '../sim/ios.js';
 import { shutdownAndroidEmulator } from '../sim/android.js';
 
 export default function releaseCommand(program) {
@@ -45,10 +45,10 @@ export default function releaseCommand(program) {
         if (opts.shutdown) {
           if (p === 'ios') {
             shutdownIosSim(entry.deviceUdid);
-            console.log(chalk.green(`Shut down iOS sim ${entry.deviceUdid}`));
+            console.log(chalk.green(`Shut down iOS sim ${formatIosLabel(entry.deviceUdid)}`));
           } else {
             shutdownAndroidEmulator(`emulator-${entry.consolePort}`);
-            console.log(chalk.green(`Shut down emulator-${entry.consolePort}`));
+            console.log(chalk.green(`Shut down ${entry.avdName} (emulator-${entry.consolePort})`));
           }
         }
         clearDevice(found, p);

package/src/config.js

@@ -111,10 +111,12 @@ export function allClaimedDevices() {
     androidAvds: [],
     androidConsolePorts: [],
     // iosClaims: udid -> { label, path }. androidClaims: consolePort ->
-    // { label, path, avdName }. `path` is the absolute project path so
-    // take-over flows can call clearDevice on the owning project.
+    // { label, path, avdName }. androidClaimsByAvd: avdName -> { label,
+    // path, consolePort }. `path` is the absolute project path so take-
+    // over flows can call clearDevice on the owning project.
     iosClaims: {},
     androidClaims: {},
+    androidClaimsByAvd: {},
   };
   if (!cfg) return result;
   for (const [path, proj] of Object.entries(cfg.projects || {})) {
@@ -125,7 +127,14 @@ export function allClaimedDevices() {
       result.iosClaims[ios.deviceUdid] = { label, path };
     }
     const android = proj.platforms?.android;
-    if (android?.avdName) result.androidAvds.push(android.avdName);
+    if (android?.avdName) {
+      result.androidAvds.push(android.avdName);
+      result.androidClaimsByAvd[android.avdName] = {
+        label,
+        path,
+        consolePort: android.consolePort,
+      };
+    }
     if (typeof android?.consolePort === 'number') {
       result.androidConsolePorts.push(android.consolePort);
       result.androidClaims[android.consolePort] = {

package/src/runner.js

@@ -64,9 +64,11 @@ export function buildScriptCommand(packageManager, scriptName, extraArgs = []) {
   }
 }
 
-// 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.
+// Decide which CLI a script invokes. Affects flag names:
+//   iOS:     Expo `--device <UDID>`     | RN `--udid <UDID>`
+//   Android: Expo `--device <AVD-name>` | RN `--deviceId <serial>`
+// Expo's run:android resolves --device by name (not by serial), so we pass
+// the AVD name there even though we boot/track by serial.
 export function detectScriptCli(scriptBody) {
   if (typeof scriptBody !== 'string') return 'unknown';
   if (/\bexpo\s+(run:ios|run:android|start)\b/.test(scriptBody)) return 'expo';
@@ -96,13 +98,13 @@ export function buildIosCommand({ projectRoot, packageManager, scriptName, isExp
   return `npx react-native run-ios --udid ${udid} --port ${port}`;
 }
 
-export function buildAndroidCommand({ projectRoot, packageManager, scriptName, isExpo, serial, port, useScript = true }) {
+export function buildAndroidCommand({ projectRoot, packageManager, scriptName, isExpo, avdName, 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}`;
+      // Expo: --device <AVD name>; RN: --deviceId <serial>.
+      const deviceFlag = cli === 'expo' ? `--device "${avdName}"` : `--deviceId ${serial}`;
       return buildScriptCommand(packageManager, scriptName, [
         deviceFlag,
         `--port ${port}`,
@@ -110,7 +112,7 @@ export function buildAndroidCommand({ projectRoot, packageManager, scriptName, i
     }
   }
   if (isExpo) {
-    return `npx expo run:android --device ${serial} --port ${port}`;
+    return `npx expo run:android --device "${avdName}" --port ${port}`;
   }
   return `RCT_METRO_PORT=${port} npx react-native run-android --deviceId ${serial}`;
 }

package/src/sim/android.js

@@ -35,37 +35,45 @@ export function nextConsolePort(claimedPorts) {
   return max + 2; // emulator console ports are even
 }
 
-export function selectAndroidDevice({ existingAvd, existingConsolePort, claimedAvds, claimedConsolePorts }) {
+// Build the full candidate list: every AVD on disk, paired with whether it
+// currently has a running emulator and (if so) on which console port.
+// Emulators that fail to respond to `adb emu avd name` are dropped from
+// the running map. Returns [] when no AVDs are installed.
+export function enumerateAndroidCandidates() {
   const avds = listAvds();
-  if (avds.length === 0) return { kind: 'noAvd' };
+  if (avds.length === 0) return [];
 
   const adbDevices = listAdbDevices();
-  // Resolve which AVD each running emulator is. Emulators that don't respond
-  // to `adb emu avd name` are dropped from the running map.
   const runningByAvd = {};
   for (const e of adbDevices.emulators) {
     const avdName = getAvdNameForSerial(e.serial);
     if (avdName) runningByAvd[avdName] = e.consolePort;
   }
 
-  const buildCandidate = (avdName) => ({
+  return avds.map(avdName => ({
     avdName,
     isRunning: avdName in runningByAvd,
     consolePort: runningByAvd[avdName] ?? null,
-  });
+  }));
+}
 
-  if (existingAvd && avds.includes(existingAvd)) {
-    const runningPort = runningByAvd[existingAvd];
-    return {
-      kind: 'reuse',
-      avdName: existingAvd,
-      consolePort: runningPort ?? existingConsolePort ?? nextConsolePort(claimedConsolePorts),
-      isRunning: runningPort != null,
-    };
+export function selectAndroidDevice({ existingAvd, existingConsolePort, claimedAvds, claimedConsolePorts }) {
+  const all = enumerateAndroidCandidates();
+  if (all.length === 0) return { kind: 'noAvd' };
+
+  if (existingAvd) {
+    const found = all.find(c => c.avdName === existingAvd);
+    if (found) {
+      return {
+        kind: 'reuse',
+        avdName: existingAvd,
+        consolePort: found.consolePort ?? existingConsolePort ?? nextConsolePort(claimedConsolePorts),
+        isRunning: found.isRunning,
+      };
+    }
   }
 
   const claimedAvdSet = new Set(claimedAvds);
-  const all = avds.map(buildCandidate);
   const unclaimed = all.filter(c => !claimedAvdSet.has(c.avdName));
 
   if (unclaimed.length === 0) {

package/src/sim/ios.js

@@ -31,6 +31,16 @@ export function listBootedIosSims() {
   return listAllIosSims().filter(s => s.state === 'Booted');
 }
 
+// "iPhone 16 Pro (ABC-123-...)" if simctl knows about the UDID; the bare
+// UDID otherwise (deleted sim, or simctl unavailable).
+export function formatIosLabel(udid) {
+  try {
+    const sim = listAllIosSims().find(s => s.udid === udid);
+    if (sim) return `${sim.name} (${udid})`;
+  } catch { /* simctl not available */ }
+  return udid;
+}
+
 export function deviceFamilyRank(name) {
   if (/^iPhone/i.test(name)) return 0;
   if (/^iPad/i.test(name)) return 1;
@@ -62,7 +72,7 @@ export function selectIosDevice({ existingUdid, claimedUdids, usage = {} }) {
   if (existingUdid) {
     const found = sims.find(s => s.udid === existingUdid);
     if (found) {
-      return { kind: 'reuse', udid: found.udid, state: found.state };
+      return { kind: 'reuse', udid: found.udid, name: found.name, state: found.state };
     }
   }