happy-stacks 0.3.0 → 0.4.0

package/scripts/utils/cli/log_forwarder.mjs

@@ -0,0 +1,157 @@
+import { createReadStream, existsSync } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import { setTimeout as delay } from 'node:timers/promises';
+
+function splitLines(s) {
+  return String(s ?? '').split(/\r?\n/);
+}
+
+function supportsAnsi() {
+  if (!process.stdout.isTTY) return false;
+  if (process.env.NO_COLOR) return false;
+  if ((process.env.TERM ?? '').toLowerCase() === 'dumb') return false;
+  return true;
+}
+
+function dim(s) {
+  return supportsAnsi() ? `\x1b[2m${s}\x1b[0m` : String(s);
+}
+
+/**
+ * Lightweight file log forwarder (tail-like) with pause/resume.
+ *
+ * - Always advances the file offset (prevents backpressure issues).
+ * - While paused, it buffers the last N lines and prints them once resumed.
+ */
+export function createFileLogForwarder({
+  path,
+  enabled = true,
+  pollMs = 200,
+  maxBytesPerTick = 256 * 1024,
+  bufferedLinesWhilePaused = 120,
+  startFromEnd = true,
+  label = 'logs',
+} = {}) {
+  const p = String(path ?? '').trim();
+  if (!enabled || !p) {
+    return {
+      ok: false,
+      start: async () => {},
+      stop: async () => {},
+      pause: () => {},
+      resume: () => {},
+      isPaused: () => false,
+      path: p,
+    };
+  }
+
+  let running = false;
+  let paused = false;
+  let offset = 0;
+  let partial = '';
+  let buffered = [];
+
+  const pushBufferedLine = (line) => {
+    if (!line) return;
+    buffered.push(line);
+    if (buffered.length > bufferedLinesWhilePaused) {
+      buffered = buffered.slice(buffered.length - bufferedLinesWhilePaused);
+    }
+  };
+
+  const flushBuffered = () => {
+    if (!buffered.length) return;
+    // eslint-disable-next-line no-console
+    console.log(dim(`[${label}] (showing last ${buffered.length} lines while paused)`));
+    for (const l of buffered) {
+      // eslint-disable-next-line no-console
+      console.log(l);
+    }
+    buffered = [];
+  };
+
+  const readNewBytes = async () => {
+    if (!existsSync(p)) return;
+    let st = null;
+    try {
+      st = await stat(p);
+    } catch {
+      return;
+    }
+    const size = Number(st?.size ?? 0);
+    if (!Number.isFinite(size) || size <= 0) return;
+    if (size < offset) {
+      // truncated/rotated
+      offset = 0;
+    }
+    if (size === offset) return;
+
+    const end = Math.min(size, offset + maxBytesPerTick);
+    const start = offset;
+    offset = end;
+
+    await new Promise((resolvePromise) => {
+      const chunks = [];
+      const stream = createReadStream(p, { start, end: end - 1 });
+      stream.on('data', (d) => chunks.push(Buffer.from(d)));
+      stream.on('error', () => resolvePromise());
+      stream.on('close', () => {
+        const text = partial + Buffer.concat(chunks).toString('utf-8');
+        const lines = splitLines(text);
+        partial = lines.pop() ?? '';
+        for (const line of lines) {
+          if (paused) {
+            pushBufferedLine(line);
+          } else {
+            // eslint-disable-next-line no-console
+            console.log(line);
+          }
+        }
+        resolvePromise();
+      });
+    });
+  };
+
+  const loop = async () => {
+    while (running) {
+      // eslint-disable-next-line no-await-in-loop
+      await readNewBytes();
+      // eslint-disable-next-line no-await-in-loop
+      await delay(pollMs);
+    }
+  };
+
+  return {
+    ok: true,
+    path: p,
+    start: async () => {
+      if (running) return;
+      running = true;
+      // By default, start at end (don't replay historical logs).
+      if (startFromEnd) {
+        try {
+          const st = await stat(p);
+          offset = Number(st?.size ?? 0) || 0;
+        } catch {
+          offset = 0;
+        }
+      } else {
+        offset = 0;
+      }
+      void loop();
+    },
+    stop: async () => {
+      running = false;
+    },
+    pause: () => {
+      paused = true;
+      buffered = [];
+    },
+    resume: () => {
+      paused = false;
+      flushBuffered();
+    },
+    isPaused: () => paused,
+  };
+}
+

package/scripts/utils/cli/prereqs.mjs

@@ -0,0 +1,72 @@
+import { commandExists } from '../proc/commands.mjs';
+
+function formatMissingTool({ name, why, install }) {
+  return [`- ${name}: ${why}`, ...(install?.length ? install.map((l) => `  ${l}`) : [])].join('\n');
+}
+
+export async function assertCliPrereqs({ git = false, pnpm = false, codex = false, coderabbit = false } = {}) {
+  const missing = [];
+
+  if (git) {
+    const hasGit = await commandExists('git');
+    if (!hasGit) {
+      const install =
+        process.platform === 'darwin'
+          ? ['Install Xcode Command Line Tools: `xcode-select --install`', 'Or install Git via Homebrew: `brew install git`']
+          : ['Install Git using your package manager (e.g. `apt install git`, `dnf install git`)'];
+      missing.push({
+        name: 'git',
+        why: 'required for cloning + updating PR worktrees',
+        install,
+      });
+    }
+  }
+
+  if (pnpm) {
+    const hasPnpm = await commandExists('pnpm');
+    if (!hasPnpm) {
+      missing.push({
+        name: 'pnpm',
+        why: 'required to install dependencies for Happy Stacks components',
+        install: ['Install it via Corepack: `corepack enable && corepack prepare pnpm@latest --activate`'],
+      });
+    }
+  }
+
+  if (codex) {
+    const hasCodex = await commandExists('codex');
+    if (!hasCodex) {
+      missing.push({
+        name: 'codex',
+        why: 'required to run Codex review',
+        install: [
+          'Install Codex CLI and ensure `codex` is on PATH',
+          'If using a managed install, ensure your PATH includes the Codex binary',
+        ],
+      });
+    }
+  }
+
+  if (coderabbit) {
+    const hasCodeRabbit = await commandExists('coderabbit');
+    if (!hasCodeRabbit) {
+      missing.push({
+        name: 'coderabbit',
+        why: 'required to run CodeRabbit CLI review',
+        install: [
+          'Install CodeRabbit CLI: `curl -fsSL https://cli.coderabbit.ai/install.sh | sh`',
+          'Then authenticate: `coderabbit auth login`',
+        ],
+      });
+    }
+  }
+
+  if (!missing.length) return;
+
+  throw new Error(
+    `[prereqs] missing required tools:\n` +
+      `${missing.map(formatMissingTool).join('\n')}\n\n` +
+      `[prereqs] After installing, re-run the command.`
+  );
+}
+

package/scripts/utils/cli/progress.mjs

@@ -0,0 +1,126 @@
+import { spawn } from 'node:child_process';
+import { createWriteStream } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+ 
+function isTty() {
+  return Boolean(process.stdout.isTTY && process.stderr.isTTY);
+}
+ 
+function spinnerFrames() {
+  return ['|', '/', '-', '\\'];
+}
+ 
+export function createStepPrinter({ enabled = true } = {}) {
+  const tty = enabled && isTty();
+  const frames = spinnerFrames();
+  let timer = null;
+  let idx = 0;
+  let currentLine = '';
+ 
+  const write = (s) => process.stdout.write(s);
+ 
+  const start = (label) => {
+    if (!tty) {
+      write(`- [..] ${label}\n`);
+      return;
+    }
+    currentLine = `- [${frames[idx % frames.length]}] ${label}`;
+    write(currentLine);
+    timer = setInterval(() => {
+      idx++;
+      const next = `- [${frames[idx % frames.length]}] ${label}`;
+      const pad = currentLine.length > next.length ? ' '.repeat(currentLine.length - next.length) : '';
+      currentLine = next;
+      write(`\r${next}${pad}`);
+    }, 120);
+  };
+ 
+  const stop = (result, label) => {
+    if (timer) clearInterval(timer);
+    timer = null;
+    if (!tty) {
+      write(`- [${result}] ${label}\n`);
+      return;
+    }
+    const out = `- [${result}] ${label}`;
+    const pad = currentLine.length > out.length ? ' '.repeat(currentLine.length - out.length) : '';
+    currentLine = '';
+    write(`\r${out}${pad}\n`);
+  };
+ 
+  const info = (line) => {
+    write(`${line}\n`);
+  };
+ 
+  return { start, stop, info };
+}
+ 
+export async function runCommandLogged({
+  label,
+  cmd,
+  args,
+  cwd,
+  env,
+  logPath,
+  showSteps = true,
+  quiet = true,
+}) {
+  const steps = createStepPrinter({ enabled: showSteps });
+  if (quiet) {
+    await mkdir(dirname(logPath), { recursive: true }).catch(() => {});
+  }
+ 
+  steps.start(label);
+ 
+  const child = spawn(cmd, args, {
+    cwd,
+    env,
+    stdio: quiet ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+    shell: false,
+  });
+ 
+  let stdout = '';
+  let stderr = '';
+  let logStream = null;
+  if (quiet) {
+    logStream = createWriteStream(logPath, { flags: 'a' });
+    child.stdout?.on('data', (d) => {
+      const s = d.toString();
+      stdout += s;
+      logStream?.write(s);
+    });
+    child.stderr?.on('data', (d) => {
+      const s = d.toString();
+      stderr += s;
+      logStream?.write(s);
+    });
+  }
+ 
+  const res = await new Promise((resolvePromise, rejectPromise) => {
+    child.on('error', rejectPromise);
+    child.on('close', (code, signal) => resolvePromise({ code: code ?? 1, signal: signal ?? null }));
+  });
+ 
+  try {
+    logStream?.end();
+  } catch {
+    // ignore
+  }
+ 
+  if (res.code === 0) {
+    steps.stop('✓', label);
+    return { ok: true, code: 0, stdout, stderr, logPath };
+  }
+ 
+  steps.stop('x', label);
+  const err = new Error(`${cmd} failed (code=${res.code}${res.signal ? `, sig=${res.signal}` : ''})`);
+  err.code = 'EEXIT';
+  err.exitCode = res.code;
+  err.signal = res.signal;
+  err.stdout = stdout;
+  err.stderr = stderr;
+  err.logPath = logPath;
+  throw err;
+}
+

package/scripts/utils/cli/verbosity.mjs

@@ -0,0 +1,12 @@
+export function getVerbosityLevel(env = process.env) {
+  const raw = (env.HAPPY_STACKS_VERBOSE ?? '').toString().trim();
+  if (!raw) return 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return 1;
+  return Math.max(0, Math.min(3, Math.floor(n)));
+}
+
+export function isVerbose(env = process.env) {
+  return getVerbosityLevel(env) > 0;
+}
+

package/scripts/utils/dev/daemon.mjs

@@ -1,4 +1,5 @@
-import { resolve } from 'node:path';
+import { join, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
 
 import { ensureCliBuilt, ensureDepsInstalled } from '../proc/pm.mjs';
 import { watchDebounced } from '../proc/watch.mjs';
@@ -7,7 +8,26 @@ import { startLocalDaemonWithAuth } from '../../daemon.mjs';
 
 export async function ensureDevCliReady({ cliDir, buildCli }) {
   await ensureDepsInstalled(cliDir, 'happy-cli');
-  return await ensureCliBuilt(cliDir, { buildCli });
+  const res = await ensureCliBuilt(cliDir, { buildCli });
+
+  // Fail closed: dev mode must never start the daemon without a usable happy-cli build output.
+  // Even if the user disabled CLI builds globally (or build mode is "never"), missing dist will
+  // cause an immediate MODULE_NOT_FOUND crash when spawning the daemon.
+  const distEntrypoint = join(cliDir, 'dist', 'index.mjs');
+  if (!existsSync(distEntrypoint)) {
+    // Last-chance recovery: force a build once.
+    await ensureCliBuilt(cliDir, { buildCli: true });
+    if (!existsSync(distEntrypoint)) {
+      throw new Error(
+        `[local] happy-cli build output is missing.\n` +
+          `Expected: ${distEntrypoint}\n` +
+          `Fix: run the component build directly and inspect its output:\n` +
+          `  cd "${cliDir}" && yarn build`
+      );
+    }
+  }
+
+  return res;
 }
 
 export async function prepareDaemonAuthSeed({
@@ -77,8 +97,25 @@ export function watchHappyCliAndRestartDaemon({
   if (!enabled || !startDaemon) return null;
 
   let inFlight = false;
+
+  // IMPORTANT:
+  // Watch only source/config paths, not build outputs. Watching the whole repo can
+  // trigger rebuild loops because `yarn build` writes to `dist/` (and may touch other
+  // generated files), which then retriggers the watcher.
+  const watchPaths = [
+    join(cliDir, 'src'),
+    join(cliDir, 'bin'),
+    join(cliDir, 'codex'),
+    join(cliDir, 'package.json'),
+    join(cliDir, 'tsconfig.json'),
+    join(cliDir, 'tsconfig.build.json'),
+    join(cliDir, 'pkgroll.config.mjs'),
+    join(cliDir, 'yarn.lock'),
+    join(cliDir, 'pnpm-lock.yaml'),
+  ].filter((p) => existsSync(p));
+
   return watchDebounced({
-    paths: [resolve(cliDir)],
+    paths: (watchPaths.length ? watchPaths : [cliDir]).map((p) => resolve(p)),
     debounceMs: 500,
     onChange: async () => {
       if (isShuttingDown?.()) return;
@@ -88,6 +125,13 @@ export function watchHappyCliAndRestartDaemon({
         // eslint-disable-next-line no-console
         console.log('[local] watch: happy-cli changed → rebuilding + restarting daemon...');
         await ensureCliBuilt(cliDir, { buildCli });
+        const distEntrypoint = join(cliDir, 'dist', 'index.mjs');
+        if (!existsSync(distEntrypoint)) {
+          console.warn(
+            `[local] watch: happy-cli build did not produce ${distEntrypoint}; refusing to restart daemon to avoid downtime.`
+          );
+          return;
+        }
         await startLocalDaemonWithAuth({
           cliBin,
           cliHomeDir,

package/scripts/utils/dev/expo_dev.mjs

@@ -0,0 +1,246 @@
+import {
+  ensureExpoIsolationEnv,
+  getExpoStatePaths,
+  isStateProcessRunning,
+  wantsExpoClearCache,
+  writePidState,
+} from '../expo/expo.mjs';
+import { pickExpoDevMetroPort } from '../expo/metro_ports.mjs';
+import { recordStackRuntimeUpdate } from '../stack/runtime_state.mjs';
+import { killProcessGroupOwnedByStack } from '../proc/ownership.mjs';
+import { expoSpawn } from '../expo/command.mjs';
+import { resolveMobileExpoConfig } from '../mobile/config.mjs';
+import { resolveMobileReachableServerUrl } from '../server/mobile_api_url.mjs';
+
+function normalizeExpoHost(raw) {
+  const v = String(raw ?? '').trim().toLowerCase();
+  if (v === 'localhost' || v === 'lan' || v === 'tunnel') return v;
+  return 'lan';
+}
+
+export function resolveExpoDevHost({ env = process.env } = {}) {
+  // Always prefer LAN by default so phones can reach Metro.
+  const raw = (env.HAPPY_STACKS_EXPO_HOST ?? env.HAPPY_LOCAL_EXPO_HOST ?? '').toString();
+  return normalizeExpoHost(raw || 'lan');
+}
+
+export function buildExpoStartArgs({ port, host, wantWeb, wantDevClient, scheme, clearCache }) {
+  const metroPort = Number(port);
+  if (!Number.isFinite(metroPort) || metroPort <= 0) {
+    throw new Error(`[expo] invalid Metro port: ${String(port)}`);
+  }
+  if (!wantWeb && !wantDevClient) {
+    throw new Error('[expo] cannot build Expo args: neither web nor dev-client requested');
+  }
+
+  // IMPORTANT:
+  // - We must only run one Expo per stack.
+  // - Expo dev-client mode is known to still serve web when accessed locally, so when mobile is
+  //   requested we prefer `--dev-client` as the single shared process (no second `--web` process).
+  const args = wantDevClient
+    ? ['start', '--dev-client', '--host', host, '--port', String(metroPort)]
+    : ['start', '--web', '--host', host, '--port', String(metroPort)];
+
+  if (wantDevClient) {
+    const s = String(scheme ?? '').trim();
+    if (s) {
+      args.push('--scheme', s);
+    }
+  }
+
+  if (clearCache && !args.includes('--clear')) {
+    args.push('--clear');
+  }
+
+  return args;
+}
+
+function expoModeLabel({ wantWeb, wantDevClient }) {
+  if (wantWeb && wantDevClient) return 'dev-client+web';
+  if (wantDevClient) return 'dev-client';
+  if (wantWeb) return 'web';
+  return 'disabled';
+}
+
+export async function ensureDevExpoServer({
+  startUi,
+  startMobile,
+  uiDir,
+  autostart,
+  baseEnv,
+  apiServerUrl,
+  restart,
+  stackMode,
+  runtimeStatePath,
+  stackName,
+  envPath,
+  children,
+  spawnOptions = {},
+} = {}) {
+  const wantWeb = Boolean(startUi);
+  const wantDevClient = Boolean(startMobile);
+  if (!wantWeb && !wantDevClient) {
+    return { ok: true, skipped: true, reason: 'disabled' };
+  }
+
+  const env = { ...(baseEnv || process.env) };
+  delete env.CI;
+  // Expo app config: this is what both web + native app use to reach the Happy server.
+  // When dev-client is enabled, `localhost` / `*.localhost` are not reachable from the phone,
+  // so rewrite to LAN IP here (centralized) to avoid relying on call sites.
+  const serverPortFromEnvRaw = (env.HAPPY_STACKS_SERVER_PORT ?? env.HAPPY_LOCAL_SERVER_PORT ?? '').toString().trim();
+  const serverPortFromEnv = serverPortFromEnvRaw ? Number(serverPortFromEnvRaw) : null;
+  const effectiveApiServerUrl = wantDevClient
+    ? resolveMobileReachableServerUrl({
+        env,
+        serverUrl: apiServerUrl,
+        serverPort: Number.isFinite(serverPortFromEnv) ? serverPortFromEnv : null,
+      })
+    : apiServerUrl;
+  env.EXPO_PUBLIC_HAPPY_SERVER_URL = effectiveApiServerUrl;
+  env.EXPO_PUBLIC_DEBUG = env.EXPO_PUBLIC_DEBUG ?? '1';
+
+  // Optional: allow per-stack storage isolation inside a single dev-client build by
+  // scoping app persistence (MMKV / SecureStore) to a stack-specific namespace.
+  //
+  // This stays upstream-safe because the app behavior is unchanged unless the Expo public
+  // env var is explicitly set. Happy Stacks sets it automatically for stack-mode dev-client.
+  if (wantDevClient) {
+    const explicitScope = (
+      env.HAPPY_STACKS_STORAGE_SCOPE ??
+      env.HAPPY_LOCAL_STORAGE_SCOPE ??
+      env.EXPO_PUBLIC_HAPPY_STORAGE_SCOPE ??
+      ''
+    )
+      .toString()
+      .trim();
+    const defaultScope = stackMode && stackName ? String(stackName).trim() : '';
+    const scope = explicitScope || defaultScope;
+    if (scope && !env.EXPO_PUBLIC_HAPPY_STORAGE_SCOPE) {
+      env.EXPO_PUBLIC_HAPPY_STORAGE_SCOPE = scope;
+    }
+  }
+
+  // We own the browser opening behavior in Happy Stacks so we can reliably open the correct origin.
+  env.EXPO_NO_BROWSER = '1';
+  env.BROWSER = 'none';
+
+  // Mobile config is needed for `--scheme` and for the app's environment.
+  let scheme = '';
+  if (wantDevClient) {
+    const cfg = resolveMobileExpoConfig({ env });
+    env.APP_ENV = cfg.appEnv;
+    scheme = cfg.scheme;
+  }
+
+  const paths = getExpoStatePaths({
+    baseDir: autostart.baseDir,
+    kind: 'expo-dev',
+    projectDir: uiDir,
+    stateFileName: 'expo.state.json',
+  });
+  await ensureExpoIsolationEnv({ env, stateDir: paths.stateDir, expoHomeDir: paths.expoHomeDir, tmpDir: paths.tmpDir });
+
+  const running = await isStateProcessRunning(paths.statePath);
+  const alreadyRunning = Boolean(running.running);
+
+  // Always publish runtime metadata when we can.
+  const publishRuntime = async ({ pid, port }) => {
+    if (!stackMode || !runtimeStatePath) return;
+    const nPid = Number(pid);
+    const nPort = Number(port);
+    await recordStackRuntimeUpdate(runtimeStatePath, {
+      processes: { expoPid: Number.isFinite(nPid) && nPid > 1 ? nPid : null },
+      expo: {
+        port: Number.isFinite(nPort) && nPort > 0 ? nPort : null,
+        // For now keep these populated for callers that still expect webPort/mobilePort.
+        webPort: wantWeb && Number.isFinite(nPort) && nPort > 0 ? nPort : null,
+        mobilePort: wantDevClient && Number.isFinite(nPort) && nPort > 0 ? nPort : null,
+        webEnabled: wantWeb,
+        devClientEnabled: wantDevClient,
+        host: resolveExpoDevHost({ env }),
+        scheme: wantDevClient ? scheme : null,
+      },
+    }).catch(() => {});
+  };
+
+  if (alreadyRunning && !restart) {
+    const pid = Number(running.state?.pid);
+    const port = Number(running.state?.port);
+
+    // Capability check: refuse to spawn a second Expo, so if the existing process doesn't match the
+    // requested capabilities we fail closed and instruct a restart with the superset.
+    const stateWeb = Boolean(running.state?.webEnabled);
+    const stateDevClient = Boolean(running.state?.devClientEnabled);
+    const stateHasCaps = 'webEnabled' in (running.state ?? {}) || 'devClientEnabled' in (running.state ?? {});
+    const missingWeb = wantWeb && stateHasCaps && !stateWeb;
+    const missingDevClient = wantDevClient && stateHasCaps && !stateDevClient;
+    if (missingWeb || missingDevClient) {
+      throw new Error(
+        `[expo] Expo already running for stack=${stackName}, but it does not match the requested mode.\n` +
+          `- running: ${expoModeLabel({ wantWeb: stateWeb, wantDevClient: stateDevClient })}\n` +
+          `- wanted:  ${expoModeLabel({ wantWeb, wantDevClient })}\n` +
+          `Fix: re-run with --restart (and include --mobile if you need dev-client).`
+      );
+    }
+
+    await publishRuntime({ pid, port });
+    return {
+      ok: true,
+      skipped: true,
+      reason: 'already_running',
+      pid: Number.isFinite(pid) ? pid : null,
+      port: Number.isFinite(port) ? port : null,
+      mode: expoModeLabel({ wantWeb, wantDevClient }),
+    };
+  }
+
+  const metroPort = await pickExpoDevMetroPort({ env: baseEnv, stackMode, stackName });
+  env.RCT_METRO_PORT = String(metroPort);
+  const host = resolveExpoDevHost({ env });
+  const args = buildExpoStartArgs({
+    port: metroPort,
+    host,
+    wantWeb,
+    wantDevClient,
+    scheme,
+    clearCache: wantsExpoClearCache({ env: baseEnv || process.env }),
+  });
+
+  if (restart && running.state?.pid) {
+    const prevPid = Number(running.state.pid);
+    const res = await killProcessGroupOwnedByStack(prevPid, { stackName, envPath, label: 'expo', json: true });
+    if (!res.killed) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `[local] expo: not stopping existing Expo pid=${prevPid} because it does not look stack-owned.\n` +
+          `[local] expo: continuing by starting a new Expo process on a free port.`
+      );
+    }
+  }
+
+  // eslint-disable-next-line no-console
+  console.log(`[local] expo: starting Expo (${expoModeLabel({ wantWeb, wantDevClient })}, metro port=${metroPort}, host=${host})`);
+  const proc = await expoSpawn({ label: 'expo', dir: uiDir, args, env, options: spawnOptions });
+  children.push(proc);
+
+  await publishRuntime({ pid: proc.pid, port: metroPort });
+
+  try {
+    await writePidState(paths.statePath, {
+      pid: proc.pid,
+      port: metroPort,
+      uiDir,
+      startedAt: new Date().toISOString(),
+      webEnabled: wantWeb,
+      devClientEnabled: wantDevClient,
+      host,
+      scheme: wantDevClient ? scheme : null,
+    });
+  } catch {
+    // ignore
+  }
+
+  return { ok: true, skipped: false, pid: proc.pid, port: metroPort, proc, mode: expoModeLabel({ wantWeb, wantDevClient }) };
+}
+