happy-stacks 0.3.0 → 0.4.0

package/scripts/review_pr.mjs

@@ -0,0 +1,368 @@
+import './utils/env/env.mjs';
+import { spawn } from 'node:child_process';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { getRootDir } from './utils/paths/paths.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { parseArgs } from './utils/cli/args.mjs';
+import { getVerbosityLevel } from './utils/cli/verbosity.mjs';
+import { createStepPrinter } from './utils/cli/progress.mjs';
+import { prompt, promptSelect, withRl } from './utils/cli/wizard.mjs';
+import { assertCliPrereqs } from './utils/cli/prereqs.mjs';
+import { randomToken } from './utils/crypto/tokens.mjs';
+import { inferPrStackBaseName } from './utils/stack/pr_stack_name.mjs';
+import { sanitizeStackName } from './utils/stack/names.mjs';
+import { listReviewPrSandboxes, reviewPrSandboxPrefixPath, writeReviewPrSandboxMeta } from './utils/sandbox/review_pr_sandbox.mjs';
+ 
+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 bold(s) {
+  return supportsAnsi() ? `\x1b[1m${s}\x1b[0m` : String(s);
+}
+
+function dim(s) {
+  return supportsAnsi() ? `\x1b[2m${s}\x1b[0m` : String(s);
+}
+
+function cyan(s) {
+  return supportsAnsi() ? `\x1b[36m${s}\x1b[0m` : String(s);
+}
+
+function usage() {
+  return [
+    '[review-pr] usage:',
+    '  happys review-pr --happy=<pr-url|number> [--happy-cli=<pr-url|number>] [--happy-server=<pr-url|number>|--happy-server-light=<pr-url|number>] [--name=<stack>] [--dev|--start] [--mobile|--no-mobile] [--forks|--upstream] [--seed-auth|--no-seed-auth] [--copy-auth-from=<stack>] [--link-auth|--copy-auth] [--update] [--force] [--keep-sandbox] [--json] [-- <stack dev/start args...>]',
+    '',
+    'What it does:',
+    '- creates a temporary sandbox dir',
+    '- runs `happys setup-pr ...` inside that sandbox (fully isolated state)',
+    '- on exit (including Ctrl+C): stops sandbox processes and deletes the sandbox dir',
+  ].join('\n');
+}
+ 
+function waitForExit(child) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    child.on('error', rejectPromise);
+    child.on('close', (code, signal) => resolvePromise({ code: code ?? 1, signal: signal ?? null }));
+  });
+}
+ 
+async function tryStopSandbox({ rootDir, sandboxDir }) {
+  const bin = join(rootDir, 'bin', 'happys.mjs');
+  const child = spawn(process.execPath, [bin, '--sandbox-dir', sandboxDir, 'stop', '--yes', '--aggressive', '--sweep-owned', '--no-service'], {
+    cwd: rootDir,
+    env: process.env,
+    stdio: 'ignore',
+  });
+  await waitForExit(child);
+}
+ 
+function argvHasFlag(argv, names) {
+  for (const n of names) {
+    if (argv.includes(n)) return true;
+  }
+  return false;
+}
+
+function kvValue(argv, names) {
+  for (const a of argv) {
+    for (const n of names) {
+      if (a === n) {
+        return '';
+      }
+      if (a.startsWith(`${n}=`)) {
+        return a.slice(`${n}=`.length);
+      }
+    }
+  }
+  return null;
+}
+
+async function main() {
+  const rootDir = getRootDir(import.meta.url);
+  const argv = process.argv.slice(2);
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+  const verbosity = getVerbosityLevel(process.env);
+  const steps = createStepPrinter({ enabled: Boolean(process.stdout.isTTY && !json && verbosity === 0) });
+ 
+  if (wantsHelp(argv, { flags })) {
+    printResult({ json, data: { usage: usage() }, text: usage() });
+    return;
+  }
+ 
+  await assertCliPrereqs({ git: true, pnpm: true });
+
+  // Determine a stable base stack name from PR inputs (used for sandbox discovery),
+  // and a per-run unique stack name by default (prevents browser storage collisions across deleted sandboxes).
+  const prHappy = (kvValue(argv, ['--happy']) ?? '').trim();
+  const prCli = (kvValue(argv, ['--happy-cli']) ?? '').trim();
+  const prServer = (kvValue(argv, ['--happy-server']) ?? '').trim();
+  const prServerLight = (kvValue(argv, ['--happy-server-light']) ?? '').trim();
+  const explicitName = (kvValue(argv, ['--name']) ?? '').trim();
+
+  const baseStackName = explicitName
+    ? sanitizeStackName(explicitName, { fallback: 'pr', maxLen: 64 })
+    : inferPrStackBaseName({ happy: prHappy, happyCli: prCli, server: prServer, serverLight: prServerLight, fallback: 'pr' });
+
+  const shouldAutoSuffix = !explicitName;
+  const uniqueSuffix = randomToken(4); // short, URL-safe-ish
+  const newStackName = shouldAutoSuffix
+    ? sanitizeStackName(`${baseStackName}-${uniqueSuffix}`, { fallback: baseStackName, maxLen: 64 })
+    : baseStackName;
+
+  // Look for leftover sandboxes for the same PR base name (typically due to --keep-sandbox / failures).
+  const canPrompt = Boolean(process.stdout.isTTY && process.stdin.isTTY && !json);
+  const existingSandboxes = canPrompt ? await listReviewPrSandboxes({ baseStackName }) : [];
+
+  if (process.stdout.isTTY && !json) {
+    const intro = [
+      '',
+      '',
+      bold(`✨ ${cyan('Happy Stacks')} review-pr ✨`),
+      '',
+      'It will help you review a PR for Happy in a completely isolated environment.',
+      dim('Uses `happy-server-light` (no Redis, no Postgres, no Docker).'),
+      dim('Desktop browser + optional mobile review (Expo dev-client).'),
+      '',
+      bold('What will happen:'),
+      `- ${cyan('sandbox')}: temporary isolated Happy install`,
+      `- ${cyan('components')}: clone/install (inside the sandbox only)`,
+      `- ${cyan('start')}: start the Happy stack in sandbox (server, daemon, web, mobile)`,
+      `- ${cyan('login')}: guide you through Happy login for this sandbox`,
+      `- ${cyan('browser')}: open the Happy web app`,
+      `- ${cyan('mobile')}: start Expo dev-client (optional)`,
+      `- ${cyan('cleanup')}: stop processes + delete sandbox on exit`,
+      '',
+      dim('Everything is deleted automatically when you exit.'),
+      dim('Your main Happy installation remains untouched.'),
+      '',
+      dim('Tips:'),
+      dim('- Add `-v` / `-vv` / `-vvv` to show the full logs'),
+      dim('- Add `--keep-sandbox` to keep the sandbox directory between runs'),
+      '',
+      existingSandboxes.length
+        ? bold('Choose how to proceed') + dim(' (or Ctrl+C to cancel).')
+        : bold('Press Enter to proceed') + dim(' (or Ctrl+C to cancel).'),
+    ].join('\n');
+    // eslint-disable-next-line no-console
+    console.log(intro);
+    if (!existingSandboxes.length) {
+      await withRl(async (rl) => {
+        await prompt(rl, '', { defaultValue: '' });
+      });
+    }
+  }
+
+  let sandboxDir = '';
+  let createdNewSandbox = false;
+  let reusedSandboxMeta = null;
+
+  if (existingSandboxes.length) {
+    const picked = await withRl(async (rl) => {
+      const options = [
+        { label: 'Create a new sandbox (recommended)', value: 'new' },
+        ...existingSandboxes.map((s) => {
+          const stackLabel = s.stackName ? `stack=${s.stackName}` : 'stack=?';
+          return { label: `Reuse existing sandbox (${stackLabel}) — ${s.dir}`, value: s.dir };
+        }),
+      ];
+      return await promptSelect(rl, {
+        title: 'Review-pr sandbox:',
+        options,
+        defaultIndex: 0,
+      });
+    });
+    if (picked === 'new') {
+      steps.start('create temporary sandbox');
+      const prefix = reviewPrSandboxPrefixPath(baseStackName);
+      sandboxDir = resolve(await mkdtemp(prefix));
+      createdNewSandbox = true;
+      steps.stop('✓', 'create temporary sandbox');
+    } else {
+      sandboxDir = resolve(String(picked));
+      reusedSandboxMeta = existingSandboxes.find((s) => resolve(s.dir) === sandboxDir) ?? null;
+    }
+  } else {
+    steps.start('create temporary sandbox');
+    const prefix = reviewPrSandboxPrefixPath(baseStackName);
+    sandboxDir = resolve(await mkdtemp(prefix));
+    createdNewSandbox = true;
+    steps.stop('✓', 'create temporary sandbox');
+  }
+
+  // If we're reusing a sandbox, prefer the stack name recorded in its meta file (keeps hostname stable),
+  // but only when the user did not explicitly pass --name.
+  const effectiveStackName =
+    !explicitName && reusedSandboxMeta?.stackName
+      ? sanitizeStackName(reusedSandboxMeta.stackName, { fallback: baseStackName, maxLen: 64 })
+      : newStackName;
+ 
+  // Safety marker to ensure we only delete what we created.
+  const markerPath = join(sandboxDir, '.happy-stacks-sandbox-marker');
+  // Always ensure the marker exists for safety; write meta only for new sandboxes.
+  try {
+    if (!existsSync(markerPath)) {
+      await writeFile(markerPath, 'review-pr\n', 'utf-8');
+    }
+  } catch {
+    // ignore; deletion guard will fail closed later if marker is missing
+  }
+  if (createdNewSandbox && existsSync(markerPath)) {
+    try {
+      await writeReviewPrSandboxMeta({ sandboxDir, baseStackName, stackName: effectiveStackName, argv });
+    } catch {
+      // ignore
+    }
+  }
+ 
+  const bin = join(rootDir, 'bin', 'happys.mjs');
+ 
+  let child = null;
+  let gotSignal = null;
+  let childExitCode = null;
+ 
+  const forwardSignal = (sig) => {
+    const first = gotSignal == null;
+    gotSignal = gotSignal ?? sig;
+    if (first && process.stdout.isTTY && !json) {
+      // eslint-disable-next-line no-console
+      console.log('\n[review-pr] received Ctrl+C — cleaning up sandbox, please wait...');
+    }
+    try {
+      child?.kill(sig);
+    } catch {
+      // ignore
+    }
+  };
+ 
+  const onSigInt = () => forwardSignal('SIGINT');
+  const onSigTerm = () => forwardSignal('SIGTERM');
+  process.on('SIGINT', onSigInt);
+  process.on('SIGTERM', onSigTerm);
+ 
+  try {
+    const wantsStart = flags.has('--start') || flags.has('--prod');
+    const hasMobileFlag = argv.includes('--mobile') || argv.includes('--with-mobile') || argv.includes('--no-mobile');
+    const argvWithDefaults =
+      process.stdout.isTTY && !json && !wantsStart && !hasMobileFlag ? [...argv, '--mobile'] : argv;
+
+    // If the caller did not explicitly name the stack, make it unique per run.
+    // This prevents browser storage collisions when sandboxes are deleted between runs.
+    const hasNameFlag = argvWithDefaults.some((a) => a === '--name' || a.startsWith('--name='));
+    const argvFinal = hasNameFlag ? argvWithDefaults : [...argvWithDefaults, `--name=${effectiveStackName}`];
+
+    child = spawn(process.execPath, [bin, '--sandbox-dir', sandboxDir, 'setup-pr', ...argvFinal], {
+      cwd: rootDir,
+      env: process.env,
+      stdio: 'inherit',
+    });
+ 
+    const { code } = await waitForExit(child);
+    childExitCode = code;
+    process.exitCode = code;
+  } finally {
+    process.off('SIGINT', onSigInt);
+    process.off('SIGTERM', onSigTerm);
+
+    steps.start('stop sandbox processes (best-effort)');
+    try {
+      // Best-effort stop before deleting the sandbox.
+      await tryStopSandbox({ rootDir, sandboxDir });
+      steps.stop('✓', 'stop sandbox processes (best-effort)');
+    } catch {
+      steps.stop('x', 'stop sandbox processes (best-effort)');
+      // eslint-disable-next-line no-console
+      console.warn(`[review-pr] warning: failed to stop all sandbox processes. Attempting cleanup anyway.`);
+    }
+ 
+    // On failure, offer to keep the sandbox for inspection (TTY only).
+    // - `--keep-sandbox` always wins (no prompt)
+    // - on signals, don't prompt (just follow the normal cleanup rules)
+    const keepSandbox = flags.has('--keep-sandbox');
+    const failed = !json && (childExitCode ?? 0) !== 0;
+    const canPromptKeep =
+      failed &&
+      !keepSandbox &&
+      !gotSignal &&
+      Boolean(process.stdout.isTTY && process.stdin.isTTY) &&
+      !json;
+
+    let keepOnFail = false;
+    if (failed && !keepSandbox && !gotSignal) {
+      if (canPromptKeep) {
+        // Default: keep in verbose mode, delete otherwise.
+        const defaultKeep = getVerbosityLevel(process.env) > 0;
+        keepOnFail = await withRl(async (rl) => {
+          return await promptSelect(rl, {
+            title: 'Review-pr failed. Keep the sandbox for inspection?',
+            options: [
+              { label: 'yes (keep sandbox directory)', value: true },
+              { label: 'no (delete sandbox directory)', value: false },
+            ],
+            defaultIndex: defaultKeep ? 0 : 1,
+          });
+        });
+      } else {
+        // Non-interactive: keep old behavior (verbose keeps, otherwise delete).
+        keepOnFail = getVerbosityLevel(process.env) > 0;
+      }
+    }
+
+    const shouldDeleteSandbox = !keepSandbox && !(failed && keepOnFail);
+
+    steps.start('delete sandbox directory');
+    // Only delete if marker exists (paranoia guard).
+    // Note: if marker is missing, we intentionally leave the sandbox dir on disk.
+    try {
+      if (!existsSync(markerPath)) {
+        throw new Error('missing marker');
+      }
+      if (!shouldDeleteSandbox) {
+        steps.stop('!', 'delete sandbox directory');
+        // eslint-disable-next-line no-console
+        console.warn(`[review-pr] sandbox preserved at: ${sandboxDir}`);
+        if (!json && (childExitCode ?? 0) !== 0) {
+          // eslint-disable-next-line no-console
+          console.warn(`[review-pr] tip: inspect stack wiring with:`);
+          // eslint-disable-next-line no-console
+          console.warn(`  npx happy-stacks --sandbox-dir "${sandboxDir}" stack info ${effectiveStackName}`);
+        }
+      } else {
+        await rm(markerPath, { force: false });
+        await rm(sandboxDir, { recursive: true, force: true });
+        steps.stop('✓', 'delete sandbox directory');
+      }
+    } catch {
+      steps.stop('x', 'delete sandbox directory');
+      // eslint-disable-next-line no-console
+      console.warn(`[review-pr] warning: failed to delete sandbox directory: ${sandboxDir}`);
+      // eslint-disable-next-line no-console
+      console.warn(`[review-pr] you can remove it manually after stopping any remaining processes.`);
+      // Preserve conventional exit codes on signals.
+      if (gotSignal) {
+        const code = gotSignal === 'SIGINT' ? 130 : gotSignal === 'SIGTERM' ? 143 : 1;
+        process.exitCode = process.exitCode ?? code;
+      }
+      return;
+    }
+    // Preserve conventional exit codes on signals.
+    if (gotSignal) {
+      const code = gotSignal === 'SIGINT' ? 130 : gotSignal === 'SIGTERM' ? 143 : 1;
+      process.exitCode = process.exitCode ?? code;
+    }
+  }
+}
+ 
+main().catch((err) => {
+  console.error('[review-pr] failed:', err);
+  process.exit(1);
+});
+ 

package/scripts/run.mjs

@@ -2,7 +2,7 @@ import './utils/env/env.mjs';
 import { parseArgs } from './utils/cli/args.mjs';
 import { pathExists } from './utils/fs/fs.mjs';
 import { killProcessTree, runCapture, spawnProc } from './utils/proc/proc.mjs';
-import { getComponentDir, getDefaultAutostartPaths, getRootDir } from './utils/paths/paths.mjs';
+import { componentDirEnvKey, getComponentDir, getDefaultAutostartPaths, getRootDir } from './utils/paths/paths.mjs';
 import { killPortListeners } from './utils/net/ports.mjs';
 import { getServerComponentName, isHappyServerRunning, waitForServerReady } from './utils/server/server.mjs';
 import { ensureCliBuilt, ensureDepsInstalled, pmExecBin, pmSpawnScript, requireDir } from './utils/proc/pm.mjs';
@@ -14,12 +14,16 @@ import { isDaemonRunning, startLocalDaemonWithAuth, stopLocalDaemon } from './da
 import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
 import { assertServerComponentDirMatches, assertServerPrismaProviderMatches } from './utils/server/validate.mjs';
 import { applyHappyServerMigrations, ensureHappyServerManagedInfra } from './utils/server/infra/happy_server_infra.mjs';
-import { getAccountCountForServerComponent, prepareDaemonAuthSeedIfNeeded } from './utils/stack/startup.mjs';
+import { getAccountCountForServerComponent, prepareDaemonAuthSeedIfNeeded, resolveAutoCopyFromMainEnabled } from './utils/stack/startup.mjs';
 import { recordStackRuntimeStart, recordStackRuntimeUpdate } from './utils/stack/runtime_state.mjs';
 import { resolveStackContext } from './utils/stack/context.mjs';
 import { getPublicServerUrlEnvOverride, resolveServerPortFromEnv, resolveServerUrls } from './utils/server/urls.mjs';
-import { resolveLocalhostHost } from './utils/paths/localhost_host.mjs';
+import { preferStackLocalhostUrl } from './utils/paths/localhost_host.mjs';
 import { openUrlInBrowser } from './utils/ui/browser.mjs';
+import { ensureDevExpoServer } from './utils/dev/expo_dev.mjs';
+import { maybeRunInteractiveStackAuthSetup } from './utils/auth/interactive_stack_auth.mjs';
+import { getInvokedCwd, inferComponentFromCwd } from './utils/cli/cwd_scope.mjs';
+import { daemonStartGate, formatDaemonAuthRequiredError } from './utils/auth/daemon_gate.mjs';
 
 /**
  * Run the local stack in "production-like" mode:
@@ -27,7 +31,7 @@ import { openUrlInBrowser } from './utils/ui/browser.mjs';
  * - happy-cli daemon
  * - serve prebuilt UI via happy-server-light (/)
  *
- * No Expo dev server.
+ * Optional: Expo dev-client Metro for mobile reviewers (`--mobile`).
  */
 
 async function main() {
@@ -37,12 +41,15 @@ async function main() {
   if (wantsHelp(argv, { flags })) {
     printResult({
       json,
-      data: { flags: ['--server=happy-server|happy-server-light', '--no-ui', '--no-daemon', '--restart', '--no-browser'], json: true },
+      data: { flags: ['--server=happy-server|happy-server-light', '--no-ui', '--no-daemon', '--restart', '--no-browser', '--mobile'], json: true },
       text: [
         '[start] usage:',
         '  happys start [--server=happy-server|happy-server-light] [--restart] [--json]',
         '  (legacy in a cloned repo): pnpm start [-- --server=happy-server|happy-server-light] [--json]',
         '  note: --json prints the resolved config (dry-run) and exits.',
+        '',
+        'note:',
+        '  If run from inside a component checkout/worktree, that checkout is used for this run (without requiring `happys wt use`).',
       ].join('\n'),
     });
     return;
@@ -50,6 +57,20 @@ async function main() {
 
   const rootDir = getRootDir(import.meta.url);
 
+  const inferred = inferComponentFromCwd({
+    rootDir,
+    invokedCwd: getInvokedCwd(process.env),
+    components: ['happy', 'happy-cli', 'happy-server-light', 'happy-server'],
+  });
+  if (inferred) {
+    const stacksKey = componentDirEnvKey(inferred.component);
+    const legacyKey = stacksKey.replace(/^HAPPY_STACKS_/, 'HAPPY_LOCAL_');
+    // Stack env should win. Only infer from CWD when the component dir isn't already configured.
+    if (!(process.env[stacksKey] ?? '').toString().trim() && !(process.env[legacyKey] ?? '').toString().trim()) {
+      process.env[stacksKey] = inferred.repoDir;
+    }
+  }
+
   const serverPort = resolveServerPortFromEnv({ defaultPort: 3005 });
 
   // Internal URL used by local processes on this machine.
@@ -67,6 +88,7 @@ async function main() {
   const startDaemon = !flags.has('--no-daemon') && (process.env.HAPPY_LOCAL_DAEMON ?? '1') !== '0';
   const serveUiWanted = !flags.has('--no-ui') && (process.env.HAPPY_LOCAL_SERVE_UI ?? '1') !== '0';
   const serveUi = serveUiWanted;
+  const startMobile = flags.has('--mobile') || flags.has('--with-mobile');
   const noBrowser = flags.has('--no-browser') || (process.env.HAPPY_STACKS_NO_BROWSER ?? process.env.HAPPY_LOCAL_NO_BROWSER ?? '').toString().trim() === '1';
   const uiPrefix = process.env.HAPPY_LOCAL_UI_PREFIX?.trim() ? process.env.HAPPY_LOCAL_UI_PREFIX.trim() : '/';
   const autostart = getDefaultAutostartPaths();
@@ -78,12 +100,16 @@ async function main() {
 
   const serverDir = getComponentDir(rootDir, serverComponentName);
   const cliDir = getComponentDir(rootDir, 'happy-cli');
+  const uiDir = getComponentDir(rootDir, 'happy');
 
   assertServerComponentDirMatches({ rootDir, serverComponentName, serverDir });
   assertServerPrismaProviderMatches({ serverComponentName, serverDir });
 
   await requireDir(serverComponentName, serverDir);
   await requireDir('happy-cli', cliDir);
+  if (startMobile) {
+    await requireDir('happy', uiDir);
+  }
 
   const cliBin = join(cliDir, 'bin', 'happy.mjs');
 
@@ -99,12 +125,14 @@ async function main() {
         mode: 'start',
         serverComponentName,
         serverDir,
+        uiDir,
         cliDir,
         serverPort,
         internalServerUrl,
         publicServerUrl,
         startDaemon,
         serveUi,
+        startMobile,
         uiPrefix,
         uiBuildDir,
         cliHomeDir,
@@ -125,7 +153,7 @@ async function main() {
   let shuttingDown = false;
   const baseEnv = { ...process.env };
   const stackCtx = resolveStackContext({ env: baseEnv, autostart });
-  const { stackMode, runtimeStatePath, stackName, ephemeral } = stackCtx;
+  const { stackMode, runtimeStatePath, stackName, envPath, ephemeral } = stackCtx;
 
   // Ensure happy-cli is install+build ready before starting the daemon.
   const buildCli = (baseEnv.HAPPY_STACKS_CLI_BUILD ?? baseEnv.HAPPY_LOCAL_CLI_BUILD ?? '1').toString().trim() !== '0';
@@ -133,12 +161,18 @@ async function main() {
 
   // Ensure server deps exist before any Prisma/docker work.
   await ensureDepsInstalled(serverDir, serverComponentName);
+  if (startMobile) {
+    await ensureDepsInstalled(uiDir, 'happy');
+  }
 
   // Public URL automation:
   // - Only the main stack should ever auto-enable Tailscale Serve by default.
   // - Non-main stacks default to localhost unless the user explicitly configured a public URL
   //   OR Tailscale Serve is already configured for this stack's internal URL (status matches).
-  const allowEnableTailscale = !stackMode || stackName === 'main';
+  const allowEnableTailscale =
+    !stackMode ||
+    stackName === 'main' ||
+    (baseEnv.HAPPY_STACKS_TAILSCALE_SERVE ?? baseEnv.HAPPY_LOCAL_TAILSCALE_SERVE ?? '0').toString().trim() === '1';
   const resolvedUrls = await resolveServerUrls({ env: baseEnv, serverPort, allowEnable: allowEnableTailscale });
   if (stackMode && stackName !== 'main' && !resolvedUrls.envPublicUrl) {
     const src = String(resolvedUrls.publicServerUrlSource ?? '');
@@ -331,9 +365,8 @@ async function main() {
     // Auto-open UI (interactive only) using the stack-scoped hostname when applicable.
     const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
     if (isInteractive && !noBrowser) {
-      const host = resolveLocalhostHost({ stackMode, stackName: autostart.stackName });
       const prefix = uiPrefix.startsWith('/') ? uiPrefix : `/${uiPrefix}`;
-      const openUrl = `http://${host}:${serverPort}${prefix}`;
+      const openUrl = await preferStackLocalhostUrl(`http://localhost:${serverPort}${prefix}`, { stackName: autostart.stackName });
       const res = await openUrlInBrowser(openUrl);
       if (!res.ok) {
         console.warn(`[local] ui: failed to open browser automatically (${res.error}).`);
@@ -343,6 +376,16 @@ async function main() {
 
   // Daemon
   if (startDaemon) {
+    const gate = daemonStartGate({ env: baseEnv, cliHomeDir });
+    if (!gate.ok) {
+      const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+      // In orchestrated auth flows, keep server/UI up and let the orchestrator start daemon post-auth.
+      if (gate.reason === 'auth_flow_missing_credentials') {
+        console.log('[local] auth flow: skipping daemon start until credentials exist');
+      } else if (!isInteractive) {
+        throw new Error(formatDaemonAuthRequiredError({ stackName: autostart.stackName, cliHomeDir }));
+      }
+    } else {
     const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
     if (serverComponentName === 'happy-server' && happyServerAccountCount == null) {
       const acct = await getAccountCountForServerComponent({
@@ -355,6 +398,16 @@ async function main() {
     }
     const accountCount =
       serverComponentName === 'happy-server-light' ? serverLightAccountCount : happyServerAccountCount;
+    const autoSeedEnabled = resolveAutoCopyFromMainEnabled({ env: baseEnv, stackName: autostart.stackName, isInteractive });
+    await maybeRunInteractiveStackAuthSetup({
+      rootDir,
+      env: baseEnv,
+      stackName: autostart.stackName,
+      cliHomeDir,
+      accountCount,
+      isInteractive,
+      autoSeedEnabled,
+    });
     await prepareDaemonAuthSeedIfNeeded({
       rootDir,
       env: baseEnv,
@@ -372,6 +425,27 @@ async function main() {
       publicServerUrl,
       isShuttingDown: () => shuttingDown,
       forceRestart: restart,
+        env: baseEnv,
+        stackName: autostart.stackName,
+    });
+    }
+  }
+
+  // Optional: start Expo dev-client Metro for mobile reviewers.
+  if (startMobile) {
+    await ensureDevExpoServer({
+      startUi: false,
+      startMobile: true,
+      uiDir,
+      autostart,
+      baseEnv,
+      apiServerUrl: publicServerUrl,
+      restart,
+      stackMode,
+      runtimeStatePath,
+      stackName,
+      envPath,
+      children,
     });
   }
 

package/scripts/service.mjs

@@ -1,6 +1,6 @@
 import './utils/env/env.mjs';
 import { run, runCapture } from './utils/proc/proc.mjs';
-import { getDefaultAutostartPaths, getRootDir, resolveStackEnvPath } from './utils/paths/paths.mjs';
+import { getComponentDir, getDefaultAutostartPaths, getRootDir, resolveStackEnvPath } from './utils/paths/paths.mjs';
 import { getInternalServerUrl, getPublicServerUrlEnvOverride } from './utils/server/urls.mjs';
 import { ensureMacAutostartDisabled, ensureMacAutostartEnabled } from './utils/service/autostart_darwin.mjs';
 import { getCanonicalHomeDir } from './utils/env/config.mjs';
@@ -278,7 +278,7 @@ async function postStartDiagnostics() {
   }
   const { publicServerUrl: publicUrl } = getPublicServerUrlEnvOverride({ env: process.env, serverPort: port });
 
-  const cliDir = join(rootDir, 'components', 'happy-cli');
+  const cliDir = getComponentDir(rootDir, 'happy-cli');
   const cliBin = join(cliDir, 'bin', 'happy.mjs');
 
   const accessKey = join(cliHomeDir, 'access.key');