rn-iso 0.3.3 → 0.4.0

package/README.md

@@ -48,6 +48,7 @@ All commands below take the same `npx rn-iso` prefix.
 | `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 [<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. |
+| `config [<key> [<value>]] [--unset] [--project <target>]` | Get / set a per-project setting (`packageManager`, `ios.script`, `android.script`). |
 
 ## How it works
 
@@ -71,6 +72,25 @@ npx rn-iso unreserve                   # drop the lock without shutting the sim
 
 Reserve binds the sim to the current project the same way `ios` / `android` would, but without running a build. If the sim is already held by another project, the picker prompts you to take it over.
 
+## Per-project settings (`rn-iso config`)
+
+A few options can be persisted per project so you don't have to repeat the same flags every run. Resolution order:
+
+1. CLI flag (`--script`, `--pm`)
+2. Stored project setting (this section)
+3. Default inferred from the project (`ios` / `android` script if present, package manager from lockfile)
+
+```bash
+npx rn-iso config packageManager bun
+npx rn-iso config ios.script dev:ios
+npx rn-iso config android.script "dev:android --variant=debug"
+npx rn-iso config                 # list current project's settings
+npx rn-iso config ios.script      # print one
+npx rn-iso config ios.script --unset
+```
+
+Allowed keys today: `packageManager` (one of `npm|yarn|pnpm|bun`), `ios.script`, `android.script`. Settings live in `~/.rn-iso/config.json` under the project's entry.
+
 ## Project shortcuts (--label)
 
 Each registered project has a "shortcut" you can pass to `stop` / `release` instead of the full path. The first time you run `ios`, `android`, or `reserve` interactively you'll be prompted for one (the directory basename is the default — hit enter to accept). Override any time with `--label <name>`:

package/bin/cli.js

@@ -10,6 +10,7 @@ import statusCommand from '../src/commands/status.js';
 import releaseCommand from '../src/commands/release.js';
 import reserveCommand from '../src/commands/reserve.js';
 import unreserveCommand from '../src/commands/unreserve.js';
+import configCommand from '../src/commands/config.js';
 
 const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
 
@@ -28,5 +29,6 @@ statusCommand(program);
 releaseCommand(program);
 reserveCommand(program);
 unreserveCommand(program);
+configCommand(program);
 
 program.parse();

package/package.json

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

package/skill/SKILL.md

@@ -83,6 +83,7 @@ Reserve binds the sim to the current project the same way `ios` does, but skips
 - `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 [<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.
+- `npx rn-iso config [<key> [<value>]] [--unset] [--project <target>]` — persist per-project settings. Allowed keys: `packageManager` (npm|yarn|pnpm|bun), `ios.script`, `android.script`. Resolution order on `ios`/`android`: CLI flag > stored setting > inferred default. Useful when a project's build script is named differently (`dev:ios` instead of `ios`) or when a different package manager is used than the lockfile suggests.
 
 ### Project shortcuts (--label)
 

package/src/commands/android.js

@@ -23,9 +23,9 @@ export default function androidCommand(program) {
     .description('Ensure a dedicated Android emulator + Metro for the current project; build/install if needed')
     .option('--auto', 'Non-interactive: pick the first unclaimed AVD 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: android)', 'android')
+    .option('--script <name>', 'package.json script to invoke for build/install (default: project setting `android.script`, else `android`)')
     .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('--pm <name>', 'Package manager: npm, yarn, pnpm, bun (default: project setting `packageManager`, else detected from lockfile)')
     .option('--no-install', 'Skip the build/install step')
     .action(async (opts) => {
       const root = findProjectRoot(process.cwd());
@@ -142,9 +142,12 @@ export default function androidCommand(program) {
       console.log(chalk.dim(`adb reverse tcp:${proj.metroPort} configured for ${serial}`));
 
       if (opts.install !== false) {
-        const packageManager = opts.pm || detectPackageManager(root);
+        const settings = proj.settings || {};
+        const packageManager = opts.pm ?? settings.packageManager ?? detectPackageManager(root);
         const useScript = opts.script !== false;
-        const scriptName = useScript ? (typeof opts.script === 'string' ? opts.script : 'android') : null;
+        const scriptName = useScript
+          ? (typeof opts.script === 'string' ? opts.script : (settings.android?.script ?? 'android'))
+          : null;
         const cmd = buildAndroidCommand({
           projectRoot: root,
           packageManager,

package/src/commands/config.js

@@ -0,0 +1,102 @@
+// src/commands/config.js
+import chalk from 'chalk';
+import {
+  findProjectRoot,
+  resolveRegisteredProject,
+  detectIsExpo,
+  detectBundleId,
+  detectAndroidPackage,
+} from '../project.js';
+import {
+  getProject,
+  upsertProject,
+  getProjectSettings,
+  getProjectSetting,
+  setProjectSetting,
+  unsetProjectSetting,
+} from '../config.js';
+
+const ALLOWED_KEYS = ['packageManager', 'ios.script', 'android.script'];
+const PM_VALUES = ['npm', 'yarn', 'pnpm', 'bun'];
+
+export default function configCommand(program) {
+  program
+    .command('config [key] [value]')
+    .description(
+      'Get or set a per-project setting. Allowed keys: ' + ALLOWED_KEYS.join(', ') +
+      '. With no args, lists current settings.'
+    )
+    .option('--unset', 'Remove the value for <key>')
+    .option('--project <target>', 'Run against another project (label / unique basename / absolute path) instead of cwd')
+    .action((key, value, opts) => {
+      const found = resolveTarget(opts.project);
+
+      if (!key) {
+        const settings = getProjectSettings(found);
+        if (Object.keys(settings).length === 0) {
+          console.log(chalk.dim(`No settings for ${found}.`));
+          return;
+        }
+        console.log(found);
+        for (const k of ALLOWED_KEYS) {
+          const v = getProjectSetting(found, k);
+          if (v !== undefined) console.log(`  ${k} = ${chalk.cyan(v)}`);
+        }
+        return;
+      }
+
+      if (!ALLOWED_KEYS.includes(key)) {
+        console.error(chalk.red(`Unknown key "${key}". Allowed: ${ALLOWED_KEYS.join(', ')}.`));
+        process.exit(1);
+      }
+
+      if (opts.unset) {
+        const removed = unsetProjectSetting(found, key);
+        if (removed) console.log(chalk.green(`Unset ${key} for ${found}.`));
+        else console.log(chalk.dim(`${key} was already unset.`));
+        return;
+      }
+
+      if (value === undefined) {
+        const cur = getProjectSetting(found, key);
+        if (cur === undefined) console.log(chalk.dim('(unset)'));
+        else console.log(cur);
+        return;
+      }
+
+      if (key === 'packageManager' && !PM_VALUES.includes(value)) {
+        console.error(chalk.red(`Invalid packageManager "${value}". Must be one of: ${PM_VALUES.join(', ')}.`));
+        process.exit(1);
+      }
+
+      setProjectSetting(found, key, value);
+      console.log(chalk.green(`Set ${key} = ${value} for ${found}.`));
+    });
+}
+
+// `--project` targets an existing registered project; without it we fall
+// back to the cwd and auto-register if needed (so users can configure a
+// project before running `ios` / `android` for the first time).
+function resolveTarget(projectArg) {
+  if (projectArg) {
+    const { found, error } = resolveRegisteredProject(projectArg);
+    if (!found) {
+      console.error(chalk.red(error));
+      process.exit(1);
+    }
+    return 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);
+  }
+  if (!getProject(root)) {
+    upsertProject(root, {
+      bundleId: detectBundleId(root),
+      androidPackage: detectAndroidPackage(root),
+      isExpo: detectIsExpo(root),
+    });
+  }
+  return root;
+}

package/src/commands/ios.js

@@ -17,9 +17,9 @@ export default function iosCommand(program) {
     .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 (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('--script <name>', 'package.json script to invoke for build/install (default: project setting `ios.script`, else `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('--pm <name>', 'Package manager: npm, yarn, pnpm, bun (default: project setting `packageManager`, else detected from lockfile)')
     .option('--no-install', 'Skip the build/install step (assume app is already installed)')
     .action(async (opts) => {
       const root = findProjectRoot(process.cwd());
@@ -144,9 +144,12 @@ export default function iosCommand(program) {
       // (without build/install), use `rn-iso start`.
 
       if (opts.install !== false) {
-        const packageManager = opts.pm || detectPackageManager(root);
+        const settings = proj.settings || {};
+        const packageManager = opts.pm ?? settings.packageManager ?? detectPackageManager(root);
         const useScript = opts.script !== false;
-        const scriptName = useScript ? (typeof opts.script === 'string' ? opts.script : 'ios') : null;
+        const scriptName = useScript
+          ? (typeof opts.script === 'string' ? opts.script : (settings.ios?.script ?? 'ios'))
+          : null;
         const cmd = buildIosCommand({
           projectRoot: root,
           packageManager,

package/src/config.js

@@ -88,6 +88,70 @@ export function clearDevice(projectPath, platform) {
   saveConfig(cfg);
 }
 
+// --- Per-project settings (scripts, package manager, ...) ---
+
+export function getProjectSettings(projectPath) {
+  return getProject(projectPath)?.settings || {};
+}
+
+export function getProjectSetting(projectPath, dottedKey) {
+  return readNested(getProjectSettings(projectPath), dottedKey);
+}
+
+export function setProjectSetting(projectPath, dottedKey, value) {
+  const cfg = ensureConfig();
+  const proj = cfg.projects[projectPath];
+  if (!proj) throw new Error(`Project not registered: ${projectPath}`);
+  proj.settings = proj.settings || {};
+  writeNested(proj.settings, dottedKey, value);
+  saveConfig(cfg);
+}
+
+export function unsetProjectSetting(projectPath, dottedKey) {
+  const cfg = loadConfig();
+  const proj = cfg?.projects?.[projectPath];
+  if (!proj?.settings) return false;
+  const removed = deleteNested(proj.settings, dottedKey);
+  if (removed) saveConfig(cfg);
+  return removed;
+}
+
+function readNested(obj, dottedKey) {
+  if (!obj) return undefined;
+  const keys = dottedKey.split('.');
+  let cur = obj;
+  for (const k of keys) {
+    if (cur == null || typeof cur !== 'object') return undefined;
+    cur = cur[k];
+  }
+  return cur;
+}
+
+function writeNested(obj, dottedKey, value) {
+  const keys = dottedKey.split('.');
+  let cur = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (typeof cur[keys[i]] !== 'object' || cur[keys[i]] === null) {
+      cur[keys[i]] = {};
+    }
+    cur = cur[keys[i]];
+  }
+  cur[keys[keys.length - 1]] = value;
+}
+
+function deleteNested(obj, dottedKey) {
+  const keys = dottedKey.split('.');
+  let cur = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (cur[keys[i]] == null || typeof cur[keys[i]] !== 'object') return false;
+    cur = cur[keys[i]];
+  }
+  const leaf = keys[keys.length - 1];
+  if (!(leaf in cur)) return false;
+  delete cur[leaf];
+  return true;
+}
+
 export function allMetroPorts() {
   const cfg = loadConfig();
   if (!cfg?.projects) return [];