rn-iso 0.2.1 → 0.3.2

package/README.md

@@ -47,7 +47,7 @@ All commands below take the same `npx rn-iso` prefix.
 | `status` | Show all projects' state |
 | `reserve [ios\|android]` | Lock a manually-started sim/emulator to the current project (no build) |
 | `unreserve [ios\|android]` | Drop the current project's lock without shutting the sim down |
-| `release [<shortcut>\|<path>] [--platform <p>] [--shutdown]` | Free a project's assignment; `--shutdown` also stops the sim |
+| `release [<port>\|<shortcut>\|<path>] [--platform <p>] [--shutdown]` | Free a project's assignment. Target can be a Metro port (`8083`), a shortcut (label or unique basename), or an absolute path. `--shutdown` also stops the sim. |
 
 ## How it works
 

package/package.json

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

package/skill/SKILL.md

@@ -82,7 +82,7 @@ Reserve binds the sim to the current project the same way `ios` does, but skips
 - `npx rn-iso status` — show all projects, their assignments, and Metro state.
 - `npx rn-iso start` — start Metro detached on the project's assigned port WITHOUT building/installing. Useful to keep Metro alive across builds.
 - `npx rn-iso stop [<port>|<shortcut>|<path>]` — kill Metro. No arg = current project. Passing a port (e.g. `8083`) kills whatever is on it; a project shortcut (label or unique basename) or absolute path targets that project. Finds the process by port, so it works whether Metro was started by `npx rn-iso start` or by the build CLI.
-- `npx rn-iso release [<shortcut>|<path>] [--platform <p>] [--shutdown]` — free a project's sim assignment. Defaults to the current project. `--shutdown` also stops the sim/emulator.
+- `npx rn-iso release [<port>|<shortcut>|<path>] [--platform <p>] [--shutdown]` — free a project's sim assignment. Defaults to the current project. Target can also be a Metro port (`8083`) or a shortcut (label / unique basename). `--shutdown` also stops the sim/emulator.
 
 ### Project shortcuts (--label)
 

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).'
@@ -161,20 +162,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

@@ -1,21 +1,34 @@
 // src/commands/release.js
 import chalk from 'chalk';
+import prompts from 'prompts';
 import { resolveRegisteredProject } from '../project.js';
-import { getProject, clearDevice } from '../config.js';
-import { shutdownIosSim } from '../sim/ios.js';
+import { getProject, clearDevice, findProjectByMetroPort } from '../config.js';
+import { findPidListeningOnPort } from '../metro.js';
+import { shutdownIosSim, formatIosLabel } from '../sim/ios.js';
 import { shutdownAndroidEmulator } from '../sim/android.js';
 
 export default function releaseCommand(program) {
   program
     .command('release [target]')
-    .description('Free a project assignment. [target] is an absolute project path; defaults to the current project.')
+    .description('Free a project assignment. [target] is a Metro port (e.g. 8083), a project shortcut (label or unique basename), or an absolute 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) => {
-      const { found, error } = resolveRegisteredProject(target);
-      if (!found) {
-        console.error(chalk.red(error));
-        process.exit(1);
+    .action(async (target, opts) => {
+      let found;
+      if (target && /^\d+$/.test(target)) {
+        const port = parseInt(target, 10);
+        found = findProjectByMetroPort(port);
+        if (!found) {
+          await handleUnmatchedPort(port);
+          return;
+        }
+      } else {
+        const result = resolveRegisteredProject(target);
+        if (!result.found) {
+          console.error(chalk.red(result.error));
+          process.exit(1);
+        }
+        found = result.found;
       }
       const proj = getProject(found);
       if (!proj) {
@@ -32,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);
@@ -43,3 +56,33 @@ export default function releaseCommand(program) {
       }
     });
 }
+
+async function handleUnmatchedPort(port) {
+  const pid = findPidListeningOnPort(port);
+  if (!pid) {
+    console.error(chalk.red(`No registered project has Metro port ${port}, and nothing is listening on that port.`));
+    process.exit(1);
+  }
+  console.log(chalk.dim(`No registered project has Metro port ${port}, but pid ${pid} is listening.`));
+  if (!process.stdin.isTTY) {
+    console.error(chalk.red('Refusing to kill an unrecognized process under non-TTY (no way to confirm).'));
+    process.exit(1);
+  }
+  const ok = await prompts({
+    type: 'confirm',
+    name: 'ok',
+    message: `Kill pid ${pid} on port ${port}?`,
+    initial: false,
+  });
+  if (!ok.ok) {
+    console.error(chalk.red('Cancelled.'));
+    process.exit(1);
+  }
+  try {
+    process.kill(pid, 'SIGTERM');
+    console.log(chalk.green(`Killed pid ${pid} on port ${port}.`));
+  } catch (e) {
+    console.error(chalk.red(`Could not kill pid ${pid}: ${e.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/status.js

@@ -3,7 +3,8 @@ import chalk from 'chalk';
 import { loadConfig } from '../config.js';
 import { isMetroRunning } from '../ports.js';
 import { isPidAlive } from '../metro.js';
-import { findProjectRoot } from '../project.js';
+import { findProjectRoot, projectShortcut } from '../project.js';
+import { listAllIosSims } from '../sim/ios.js';
 
 export default function statusCommand(program) {
   program
@@ -19,11 +20,20 @@ export default function statusCommand(program) {
 
       const cwdRoot = findProjectRoot(process.cwd());
 
+      // Build a UDID -> sim name map so we can show "iPhone 16 Pro (UDID)"
+      // rather than a raw UDID. Tolerate missing simctl (Linux dev box, etc.).
+      let iosNameByUdid = {};
+      try {
+        for (const sim of listAllIosSims()) iosNameByUdid[sim.udid] = sim.name;
+      } catch { /* no simctl available; we'll just print the udid */ }
+
       for (const [path, proj] of Object.entries(cfg?.projects || {})) {
         const isCurrent = path === cwdRoot;
-        const header = isCurrent ? chalk.bold.cyan(`* ${path}`) : path;
+        const shortcut = projectShortcut(path, proj);
+        const headerText = `${shortcut} ${chalk.dim(`(${path})`)}`;
+        const header = isCurrent ? chalk.bold.cyan(`* ${shortcut}`) + ' ' + chalk.dim(`(${path})`) : headerText;
         console.log('\n' + header);
-        console.log(chalk.dim(`  app: ${proj.bundleId} (${proj.isExpo ? 'expo' : 'bare'})`));
+        console.log(chalk.dim(`  app: ${proj.bundleId ?? '?'} (${proj.isExpo ? 'expo' : 'bare'})`));
 
         if (proj.metroPort) {
           const running = await isMetroRunning(proj.metroPort);
@@ -37,9 +47,14 @@ export default function statusCommand(program) {
         }
 
         const ios = proj.platforms?.ios;
-        if (ios) console.log(`  ios: ${chalk.cyan(ios.deviceUdid)}`);
+        if (ios) {
+          const name = iosNameByUdid[ios.deviceUdid] || chalk.dim('(unknown sim)');
+          console.log(`  ios: ${chalk.cyan(name)} ${chalk.dim(`(${ios.deviceUdid})`)}`);
+        }
         const android = proj.platforms?.android;
-        if (android) console.log(`  android: ${chalk.cyan(android.avdName)} on emulator-${android.consolePort}`);
+        if (android) {
+          console.log(`  android: ${chalk.cyan(android.avdName)} ${chalk.dim(`(emulator-${android.consolePort})`)}`);
+        }
       }
       console.log('');
     });

package/src/commands/stop.js

@@ -1,9 +1,8 @@
 // src/commands/stop.js
 import chalk from 'chalk';
 import { resolveRegisteredProject } from '../project.js';
-import { loadConfig, getProject, setMetro } from '../config.js';
-import { killMetroByPid } from '../metro.js';
-import { getExecutor } from '../exec.js';
+import { getProject, setMetro, findProjectByMetroPort } from '../config.js';
+import { killMetroByPid, findPidListeningOnPort } from '../metro.js';
 
 export default function stopCommand(program) {
   program
@@ -65,19 +64,10 @@ function killByPort(port) {
   console.log(chalk.green(`Killed pid ${pid} on port ${port}`));
 
   // If a project owned this port, clear its recorded pid so `status` reflects.
-  const cfg = loadConfig();
-  for (const [path, proj] of Object.entries(cfg?.projects || {})) {
-    if (proj.metroPort === port) {
-      setMetro(path, port, null);
-      console.log(chalk.dim(`Cleared metroPid for ${path}`));
-      break;
-    }
+  const owner = findProjectByMetroPort(port);
+  if (owner) {
+    setMetro(owner, port, null);
+    console.log(chalk.dim(`Cleared metroPid for ${owner}`));
   }
 }
 
-function findPidListeningOnPort(port) {
-  const out = getExecutor().runQuiet(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`);
-  if (!out) return null;
-  const pid = parseInt(out.split('\n')[0], 10);
-  return Number.isFinite(pid) ? pid : null;
-}

package/src/config.js

@@ -96,6 +96,14 @@ export function allMetroPorts() {
     .filter(p => typeof p === 'number');
 }
 
+export function findProjectByMetroPort(port) {
+  const cfg = loadConfig();
+  for (const [path, proj] of Object.entries(cfg?.projects || {})) {
+    if (proj.metroPort === port) return path;
+  }
+  return null;
+}
+
 export function allClaimedDevices() {
   const cfg = loadConfig();
   const result = {
@@ -103,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 || {})) {
@@ -117,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/metro.js

@@ -52,6 +52,13 @@ export function killMetroByPid(pid) {
   }
 }
 
+export function findPidListeningOnPort(port) {
+  const out = getExecutor().runQuiet(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`);
+  if (!out) return null;
+  const pid = parseInt(out.split('\n')[0], 10);
+  return Number.isFinite(pid) ? pid : null;
+}
+
 export function isPidAlive(pid) {
   if (!pid) return false;
   try {

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 };
     }
   }