rn-iso 0.1.0

package/src/commands/stop.js

@@ -0,0 +1,51 @@
+// src/commands/stop.js
+import chalk from 'chalk';
+import { findProjectRoot } from '../project.js';
+import { getProject, setMetro } from '../config.js';
+import { killMetroByPid } from '../metro.js';
+import { getExecutor } from '../exec.js';
+
+export default function stopCommand(program) {
+  program
+    .command('stop')
+    .description('Kill the Metro process 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 proj = getProject(root);
+      if (!proj?.metroPort) {
+        console.log(chalk.dim('No Metro port assigned to this project.'));
+        return;
+      }
+
+      // Try the recorded PID first (Metro spawned by `rn-iso start`).
+      // If not set or stale, look up by port (Metro spawned by the build CLI).
+      let pid = proj.metroPid;
+      if (!pid || !killMetroByPid(pid)) {
+        pid = findPidListeningOnPort(proj.metroPort);
+        if (!pid) {
+          console.log(chalk.dim(`No Metro process found on port ${proj.metroPort}.`));
+          if (proj.metroPid) setMetro(root, proj.metroPort, null);
+          return;
+        }
+        try {
+          process.kill(pid, 'SIGTERM');
+        } catch {
+          console.log(chalk.dim(`Could not kill pid ${pid}.`));
+          return;
+        }
+      }
+      setMetro(root, proj.metroPort, null);
+      console.log(chalk.green(`Killed Metro pid ${pid} on port ${proj.metroPort}`));
+    });
+}
+
+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/commands/unreserve.js

@@ -0,0 +1,57 @@
+// src/commands/unreserve.js
+import chalk from 'chalk';
+import { findReservations, removeReservation, clearAllReservations } from '../config.js';
+
+export default function unreserveCommand(program) {
+  program
+    .command('unreserve [arg1] [arg2]')
+    .description('Release a reservation by UDID/serial or by the --label set when reserving')
+    .option('--all', 'Remove all reservations')
+    .option('--platform <platform>', 'Restrict to ios or android')
+    .action((arg1, arg2, opts) => {
+      if (opts.all) {
+        clearAllReservations();
+        console.log(chalk.green('Cleared all reservations.'));
+        return;
+      }
+
+      // Two-arg form (backward compat): `unreserve ios <id-or-label>`.
+      // Single-arg form: `unreserve <id-or-label>` (search across platforms).
+      let platform = opts.platform || null;
+      let target;
+      if (arg2 !== undefined) {
+        if (arg1 !== 'ios' && arg1 !== 'android') {
+          console.error(chalk.red(`Unknown platform: ${arg1}. Use ios or android.`));
+          process.exit(1);
+        }
+        platform = arg1;
+        target = arg2;
+      } else {
+        target = arg1;
+      }
+
+      if (!target) {
+        console.error(chalk.red('Usage: rn-iso unreserve <UDID|emulator-PORT|label>'));
+        console.error(chalk.dim('       rn-iso unreserve <ios|android> <UDID|emulator-PORT|label>'));
+        console.error(chalk.dim('       rn-iso unreserve --all'));
+        process.exit(1);
+      }
+
+      const matches = findReservations(target, platform);
+      if (matches.length === 0) {
+        console.log(chalk.dim(
+          `No reservation matches "${target}"` +
+          (platform ? ` on ${platform}` : '') +
+          '.'
+        ));
+        return;
+      }
+      for (const m of matches) {
+        removeReservation(m.platform, m.id);
+        console.log(chalk.green(
+          `Released ${m.platform} reservation ${m.id}` +
+          (m.label ? ` (${m.label})` : '')
+        ));
+      }
+    });
+}

package/src/config.js

@@ -0,0 +1,221 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+export function getConfigDir() {
+  return process.env.RN_ISO_HOME || join(homedir(), '.rn-iso');
+}
+
+function getConfigPath() {
+  return join(getConfigDir(), 'config.json');
+}
+
+function ensureDir() {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+export function loadConfig() {
+  const p = getConfigPath();
+  if (!existsSync(p)) return null;
+  return JSON.parse(readFileSync(p, 'utf-8'));
+}
+
+export function saveConfig(config) {
+  ensureDir();
+  writeFileSync(getConfigPath(), JSON.stringify(config, null, 2) + '\n');
+}
+
+export function ensureConfig() {
+  const existing = loadConfig();
+  if (existing) {
+    if (!existing.reservations) {
+      existing.reservations = { ios: [], android: [] };
+      saveConfig(existing);
+    }
+    return existing;
+  }
+  const fresh = { version: 1, projects: {}, reservations: { ios: [], android: [] } };
+  saveConfig(fresh);
+  return fresh;
+}
+
+export function getProject(projectPath) {
+  const cfg = loadConfig();
+  return cfg?.projects?.[projectPath] || null;
+}
+
+export function upsertProject(projectPath, fields) {
+  const cfg = ensureConfig();
+  const existing = cfg.projects[projectPath] || {
+    metroPort: null,
+    metroPid: null,
+    platforms: {},
+  };
+  cfg.projects[projectPath] = {
+    ...existing,
+    ...fields,
+  };
+  saveConfig(cfg);
+  return cfg.projects[projectPath];
+}
+
+export function removeProject(projectPath) {
+  const cfg = loadConfig();
+  if (!cfg?.projects?.[projectPath]) return;
+  delete cfg.projects[projectPath];
+  saveConfig(cfg);
+}
+
+export function setMetro(projectPath, metroPort, metroPid) {
+  const cfg = ensureConfig();
+  if (!cfg.projects[projectPath]) {
+    throw new Error(`Project not registered: ${projectPath}`);
+  }
+  cfg.projects[projectPath].metroPort = metroPort;
+  cfg.projects[projectPath].metroPid = metroPid;
+  saveConfig(cfg);
+}
+
+export function setDevice(projectPath, platform, deviceFields) {
+  const cfg = ensureConfig();
+  if (!cfg.projects[projectPath]) {
+    throw new Error(`Project not registered: ${projectPath}`);
+  }
+  cfg.projects[projectPath].platforms = cfg.projects[projectPath].platforms || {};
+  cfg.projects[projectPath].platforms[platform] = deviceFields;
+  saveConfig(cfg);
+}
+
+export function clearDevice(projectPath, platform) {
+  const cfg = loadConfig();
+  if (!cfg?.projects?.[projectPath]?.platforms) return;
+  delete cfg.projects[projectPath].platforms[platform];
+  saveConfig(cfg);
+}
+
+export function allMetroPorts() {
+  const cfg = loadConfig();
+  if (!cfg?.projects) return [];
+  return Object.values(cfg.projects)
+    .map(p => p.metroPort)
+    .filter(p => typeof p === 'number');
+}
+
+export function allClaimedDevices() {
+  const cfg = loadConfig();
+  const result = {
+    iosUdids: [],
+    androidAvds: [],
+    androidConsolePorts: [],
+    // iosClaims: udid -> { source: 'project'|'reservation', label: string }
+    iosClaims: {},
+  };
+  if (!cfg) return result;
+  for (const [path, proj] of Object.entries(cfg.projects || {})) {
+    const ios = proj.platforms?.ios;
+    if (ios?.deviceUdid) {
+      result.iosUdids.push(ios.deviceUdid);
+      result.iosClaims[ios.deviceUdid] = {
+        source: 'project',
+        label: path.split('/').pop() || path,
+      };
+    }
+    const android = proj.platforms?.android;
+    if (android?.avdName) result.androidAvds.push(android.avdName);
+    if (typeof android?.consolePort === 'number') result.androidConsolePorts.push(android.consolePort);
+  }
+  for (const r of cfg.reservations?.ios || []) {
+    if (r.udid) {
+      result.iosUdids.push(r.udid);
+      result.iosClaims[r.udid] = {
+        source: 'reservation',
+        label: r.label || 'reserved',
+      };
+    }
+  }
+  for (const r of cfg.reservations?.android || []) {
+    if (r.avdName) result.androidAvds.push(r.avdName);
+    if (typeof r.consolePort === 'number') result.androidConsolePorts.push(r.consolePort);
+  }
+  return result;
+}
+
+export function recordSimUsage(platform, identifier) {
+  if (platform !== 'ios' && platform !== 'android') return;
+  const cfg = ensureConfig();
+  cfg.simUsage = cfg.simUsage || { ios: {}, android: {} };
+  cfg.simUsage[platform][identifier] = (cfg.simUsage[platform][identifier] || 0) + 1;
+  saveConfig(cfg);
+}
+
+export function getSimUsage() {
+  const cfg = loadConfig();
+  return cfg?.simUsage || { ios: {}, android: {} };
+}
+
+export function listReservations() {
+  const cfg = loadConfig();
+  return cfg?.reservations || { ios: [], android: [] };
+}
+
+// Find reservations matching either an identifier (UDID for iOS, serial for
+// Android) or a label (the --label set via `rn-iso reserve`). Returns
+// `[{ platform, id, label }]`. Pass platform to restrict the search.
+export function findReservations(idOrLabel, platform = null) {
+  const r = listReservations();
+  const matches = [];
+  if (!platform || platform === 'ios') {
+    for (const e of r.ios || []) {
+      if (e.udid === idOrLabel || e.label === idOrLabel) {
+        matches.push({ platform: 'ios', id: e.udid, label: e.label });
+      }
+    }
+  }
+  if (!platform || platform === 'android') {
+    for (const e of r.android || []) {
+      if (e.serial === idOrLabel || e.label === idOrLabel) {
+        matches.push({ platform: 'android', id: e.serial, label: e.label });
+      }
+    }
+  }
+  return matches;
+}
+
+export function addReservation(platform, fields) {
+  if (platform !== 'ios' && platform !== 'android') {
+    throw new Error(`Unknown platform: ${platform}`);
+  }
+  const cfg = ensureConfig();
+  cfg.reservations = cfg.reservations || { ios: [], android: [] };
+  const list = cfg.reservations[platform];
+  const key = platform === 'ios' ? 'udid' : 'serial';
+  const existing = list.find(r => r[key] === fields[key]);
+  if (existing) {
+    Object.assign(existing, fields);
+  } else {
+    list.push(fields);
+  }
+  saveConfig(cfg);
+  return fields;
+}
+
+export function removeReservation(platform, identifier) {
+  if (platform !== 'ios' && platform !== 'android') {
+    throw new Error(`Unknown platform: ${platform}`);
+  }
+  const cfg = loadConfig();
+  if (!cfg?.reservations?.[platform]) return false;
+  const key = platform === 'ios' ? 'udid' : 'serial';
+  const before = cfg.reservations[platform].length;
+  cfg.reservations[platform] = cfg.reservations[platform].filter(r => r[key] !== identifier);
+  saveConfig(cfg);
+  return cfg.reservations[platform].length < before;
+}
+
+export function clearAllReservations() {
+  const cfg = loadConfig();
+  if (!cfg) return;
+  cfg.reservations = { ios: [], android: [] };
+  saveConfig(cfg);
+}

package/src/exec.js

@@ -0,0 +1,31 @@
+import { execSync, spawn } from 'child_process';
+
+const defaultExecutor = {
+  run(cmd) {
+    return execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  },
+  runQuiet(cmd) {
+    try {
+      return this.run(cmd);
+    } catch {
+      return null;
+    }
+  },
+  spawn(cmd, args, opts) {
+    return spawn(cmd, args, opts);
+  },
+};
+
+let active = defaultExecutor;
+
+export function setExecutor(e) {
+  active = e;
+}
+
+export function resetExecutor() {
+  active = defaultExecutor;
+}
+
+export function getExecutor() {
+  return active;
+}

package/src/metro.js

@@ -0,0 +1,73 @@
+import { createHash } from 'crypto';
+import { mkdirSync, existsSync, openSync, statSync } from 'fs';
+import { join } from 'path';
+import { getExecutor } from './exec.js';
+import { getConfigDir } from './config.js';
+import { isMetroRunning } from './ports.js';
+
+export function projectHash(projectPath) {
+  return createHash('sha256').update(projectPath).digest('hex').slice(0, 12);
+}
+
+export function logFileFor(projectPath) {
+  const dir = join(getConfigDir(), 'logs');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return join(dir, `${projectHash(projectPath)}.log`);
+}
+
+export function buildMetroSpawnArgs({ isExpo, port }) {
+  return {
+    cmd: 'npx',
+    args: isExpo
+      ? ['expo', 'start', '--port', String(port)]
+      : ['react-native', 'start', '--port', String(port)],
+  };
+}
+
+export async function ensureMetro({ projectPath, isExpo, port, detach = true }) {
+  if (await isMetroRunning(port)) return { alreadyRunning: true, pid: null };
+
+  const log = logFileFor(projectPath);
+  const fd = openSync(log, 'a');
+
+  const { cmd, args } = buildMetroSpawnArgs({ isExpo, port });
+  const exec = getExecutor();
+  const child = exec.spawn(cmd, args, {
+    cwd: projectPath,
+    detached: detach,
+    stdio: ['ignore', fd, fd],
+    env: { ...process.env, RCT_METRO_PORT: String(port) },
+  });
+  if (detach) child.unref();
+  return { alreadyRunning: false, pid: child.pid };
+}
+
+export function killMetroByPid(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 'SIGTERM');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function isPidAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function logFileExists(projectPath) {
+  const path = logFileFor(projectPath);
+  try {
+    statSync(path);
+    return path;
+  } catch {
+    return null;
+  }
+}

package/src/ports.js

@@ -0,0 +1,50 @@
+import { request } from 'http';
+import { loadConfig, allMetroPorts, removeProject } from './config.js';
+
+export function isMetroRunning(port) {
+  return new Promise((resolve) => {
+    const req = request(
+      { hostname: 'localhost', port, path: '/status', timeout: 2000 },
+      (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => resolve(data.includes('packager-status:running')));
+      }
+    );
+    req.on('error', () => resolve(false));
+    req.on('timeout', () => { req.destroy(); resolve(false); });
+    req.end();
+  });
+}
+
+export function computeNextPort() {
+  const ports = allMetroPorts();
+  if (ports.length === 0) return 8082;
+  return Math.max(...ports, 8081) + 1;
+}
+
+export async function findReclaimablePort(excludeProjectPath, probe = isMetroRunning) {
+  const cfg = loadConfig();
+  if (!cfg?.projects) return null;
+  const candidates = [];
+  for (const [path, proj] of Object.entries(cfg.projects)) {
+    if (path === excludeProjectPath) continue;
+    if (typeof proj.metroPort === 'number') {
+      candidates.push({ port: proj.metroPort, ownerPath: path });
+    }
+  }
+  for (const c of candidates) {
+    const alive = await probe(c.port);
+    if (!alive) return c;
+  }
+  return null;
+}
+
+export async function allocatePort(projectPath, probe = isMetroRunning) {
+  const reclaim = await findReclaimablePort(projectPath, probe);
+  if (reclaim) {
+    removeProject(reclaim.ownerPath);
+    return reclaim.port;
+  }
+  return computeNextPort();
+}

package/src/project.js

@@ -0,0 +1,186 @@
+import { existsSync, readFileSync, readdirSync, realpathSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { loadConfig } from './config.js';
+
+// Resolve a project from one of two forms:
+//   - undefined / null  -> walk up from cwd (current behavior)
+//   - absolute or relative path that matches a registered project key
+//
+// Basename / fuzzy matching is intentionally NOT supported -- collisions
+// across worktrees with the same dir name make it ambiguous. Use full paths
+// or the reservation label (`--label` on `rn-iso reserve`) instead.
+//
+// Returns { found, error }.
+export function resolveRegisteredProject(arg) {
+  const cfg = loadConfig();
+  const projects = cfg?.projects || {};
+
+  if (!arg) {
+    const root = findProjectRoot(process.cwd());
+    if (!root) return { found: null, error: 'Not in a React Native project (no package.json found).' };
+    if (!projects[root]) return { found: null, error: `No rn-iso entry for ${root}. Run \`rn-iso ios\` or \`rn-iso android\` first.` };
+    return { found: root };
+  }
+
+  // Exact path match. realpath() canonicalizes symlinks the same way
+  // findProjectRoot does, so the keys line up.
+  let abs;
+  try { abs = realpathSync(resolve(arg)); } catch { abs = resolve(arg); }
+  if (projects[abs]) return { found: abs };
+  if (projects[arg]) return { found: arg };
+
+  return {
+    found: null,
+    error: `No registered project at "${arg}". Pass an absolute path; see \`rn-iso status\` for the list.`,
+  };
+}
+
+export function findProjectRoot(startDir) {
+  let dir;
+  try {
+    dir = realpathSync(resolve(startDir));
+  } catch {
+    dir = resolve(startDir);
+  }
+  while (true) {
+    if (existsSync(join(dir, 'package.json'))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+function readPackageJson(projectRoot) {
+  const p = join(projectRoot, 'package.json');
+  if (!existsSync(p)) return null;
+  try {
+    return JSON.parse(readFileSync(p, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+export function detectIsExpo(projectRoot) {
+  // The `expo` package can be in deps for prebuild / config / modules without
+  // the project actually using `expo run:ios`. The strongest signal is what the
+  // project's `ios` script invokes -- check that first.
+  const iosScript = readPackageJson(projectRoot)?.scripts?.ios;
+  if (typeof iosScript === 'string') {
+    if (/\bexpo\s+run:ios\b/.test(iosScript)) return true;
+    if (/\breact-native\s+run-ios\b/.test(iosScript)) return false;
+  }
+  // No conclusive script. Require `expo` in deps AND an expo config block to
+  // be reasonably sure expo run:ios is appropriate as a fallback.
+  const pkg = readPackageJson(projectRoot);
+  if (!pkg) return false;
+  const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+  if (!('expo' in deps)) return false;
+  const appJson = readAppJson(projectRoot);
+  if (appJson?.expo) return true;
+  const text = readAppConfigText(projectRoot);
+  if (text && /\b(?:from\s+['"]expo['"]|expo\/config|ExpoConfig)\b/.test(text)) return true;
+  return false;
+}
+
+function readAppJson(projectRoot) {
+  const p = join(projectRoot, 'app.json');
+  if (!existsSync(p)) return null;
+  try {
+    return JSON.parse(readFileSync(p, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function readAppConfigText(projectRoot) {
+  for (const name of ['app.config.js', 'app.config.ts', 'app.config.cjs', 'app.config.mjs']) {
+    const p = join(projectRoot, name);
+    if (existsSync(p)) {
+      try {
+        return readFileSync(p, 'utf-8');
+      } catch { /* ignore */ }
+    }
+  }
+  return null;
+}
+
+export function detectBundleId(projectRoot) {
+  const appJson = readAppJson(projectRoot);
+  const fromJson = appJson?.expo?.ios?.bundleIdentifier;
+  if (fromJson) return fromJson;
+
+  const text = readAppConfigText(projectRoot);
+  if (text) {
+    const m = text.match(/bundleIdentifier\s*:\s*["']([^"']+)["']/);
+    if (m) return m[1];
+  }
+
+  // Fallback: hybrid Expo / bare RN projects keep the bundle ID in the Xcode
+  // project file rather than app config. Pick the most common concrete value
+  // (the main app target appears in multiple build configs; extensions show up
+  // less often) and tie-break by shortest length (extensions usually have a
+  // suffix on the main app's id).
+  return detectBundleIdFromPbxproj(projectRoot);
+}
+
+export function detectAndroidPackage(projectRoot) {
+  const appJson = readAppJson(projectRoot);
+  const fromJson = appJson?.expo?.android?.package;
+  if (fromJson) return fromJson;
+
+  const text = readAppConfigText(projectRoot);
+  if (text) {
+    const m = text.match(/package\s*:\s*["']([^"']+)["']/);
+    if (m) return m[1];
+  }
+
+  // Fallback: bare RN keeps the package in android/app/build.gradle.
+  return detectAndroidPackageFromGradle(projectRoot);
+}
+
+export function detectBundleIdFromPbxproj(projectRoot) {
+  const iosDir = join(projectRoot, 'ios');
+  if (!existsSync(iosDir)) return null;
+  let entries;
+  try {
+    entries = readdirSync(iosDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.endsWith('.xcodeproj')) continue;
+    const pbx = join(iosDir, entry.name, 'project.pbxproj');
+    if (!existsSync(pbx)) continue;
+    let text;
+    try { text = readFileSync(pbx, 'utf-8'); } catch { continue; }
+    const all = [...text.matchAll(/PRODUCT_BUNDLE_IDENTIFIER\s*=\s*([^;\s"]+)\s*;/g)].map(m => m[1]);
+    const concrete = all.filter(id => id && !id.startsWith('$') && !id.includes('('));
+    if (concrete.length === 0) continue;
+    const counts = {};
+    for (const id of concrete) counts[id] = (counts[id] || 0) + 1;
+    let best = null, bestCount = 0, bestLen = Infinity;
+    for (const [id, count] of Object.entries(counts)) {
+      if (count > bestCount || (count === bestCount && id.length < bestLen)) {
+        best = id;
+        bestCount = count;
+        bestLen = id.length;
+      }
+    }
+    return best;
+  }
+  return null;
+}
+
+export function detectAndroidPackageFromGradle(projectRoot) {
+  const gradle = join(projectRoot, 'android', 'app', 'build.gradle');
+  if (!existsSync(gradle)) return null;
+  let text;
+  try { text = readFileSync(gradle, 'utf-8'); } catch { return null; }
+  // Try `namespace "com.foo"` (modern AGP) first, then fall back to
+  // `applicationId "com.foo"`.
+  const ns = text.match(/namespace\s+["']([^"']+)["']/);
+  if (ns) return ns[1];
+  const app = text.match(/applicationId\s+["']([^"']+)["']/);
+  if (app) return app[1];
+  return null;
+}