happy-stacks 0.2.0 → 0.4.0

package/scripts/dev.mjs

@@ -1,36 +1,31 @@
-import './utils/env.mjs';
+import './utils/env/env.mjs';
 import { parseArgs } from './utils/cli/args.mjs';
-import { killProcessTree } from './utils/proc.mjs';
-import { getComponentDir, getDefaultAutostartPaths, getRootDir } from './utils/paths.mjs';
-import { killPortListeners } from './utils/ports.mjs';
-import { getServerComponentName, isHappyServerRunning } from './utils/server.mjs';
-import { requireDir } from './utils/pm.mjs';
+import { killProcessTree } from './utils/proc/proc.mjs';
+import { componentDirEnvKey, getComponentDir, getDefaultAutostartPaths, getRootDir } from './utils/paths/paths.mjs';
+import { killPortListeners } from './utils/net/ports.mjs';
+import { getServerComponentName, isHappyServerRunning } from './utils/server/server.mjs';
+import { requireDir } from './utils/proc/pm.mjs';
 import { join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { homedir } from 'node:os';
 import { isDaemonRunning, stopLocalDaemon } from './daemon.mjs';
 import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
-import { assertServerComponentDirMatches, assertServerPrismaProviderMatches } from './utils/validate.mjs';
-import { getExpoStatePaths, isStateProcessRunning } from './utils/expo.mjs';
-import { isPidAlive, readStackRuntimeStateFile, recordStackRuntimeStart } from './utils/stack_runtime_state.mjs';
-import { resolveStackContext } from './utils/stack_context.mjs';
-import { resolveServerPortFromEnv, resolveServerUrls } from './utils/server_urls.mjs';
-import { ensureDevCliReady, prepareDaemonAuthSeed, startDevDaemon, watchHappyCliAndRestartDaemon } from './utils/dev_daemon.mjs';
-import { startDevServer, watchDevServerAndRestart } from './utils/dev_server.mjs';
-import { startDevExpoWebUi } from './utils/dev_expo_web.mjs';
-import { resolveLocalhostHost } from './utils/localhost_host.mjs';
-import { openUrlInBrowser } from './utils/browser.mjs';
-import { waitForHttpOk } from './utils/server.mjs';
-
-function sanitizeDnsLabel(raw, { fallback = 'stack' } = {}) {
-  const s = String(raw ?? '')
-    .toLowerCase()
-    .replace(/[^a-z0-9-]+/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-+/, '')
-    .replace(/-+$/, '');
-  return s || fallback;
-}
+import { assertServerComponentDirMatches, assertServerPrismaProviderMatches } from './utils/server/validate.mjs';
+import { getExpoStatePaths, isStateProcessRunning } from './utils/expo/expo.mjs';
+import { isPidAlive, readStackRuntimeStateFile, recordStackRuntimeStart } from './utils/stack/runtime_state.mjs';
+import { resolveStackContext } from './utils/stack/context.mjs';
+import { resolveServerPortFromEnv, resolveServerUrls } from './utils/server/urls.mjs';
+import { ensureDevCliReady, prepareDaemonAuthSeed, startDevDaemon, watchHappyCliAndRestartDaemon } from './utils/dev/daemon.mjs';
+import { startDevServer, watchDevServerAndRestart } from './utils/dev/server.mjs';
+import { ensureDevExpoServer } from './utils/dev/expo_dev.mjs';
+import { preferStackLocalhostUrl } from './utils/paths/localhost_host.mjs';
+import { openUrlInBrowser } from './utils/ui/browser.mjs';
+import { waitForHttpOk } from './utils/server/server.mjs';
+import { sanitizeDnsLabel } from './utils/net/dns.mjs';
+import { getAccountCountForServerComponent, resolveAutoCopyFromMainEnabled } from './utils/stack/startup.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';
 
 /**
  * Dev mode stack:
@@ -46,20 +41,38 @@ async function main() {
   if (wantsHelp(argv, { flags })) {
     printResult({
       json,
-      data: { flags: ['--server=happy-server|happy-server-light', '--no-ui', '--no-daemon', '--restart', '--watch', '--no-watch', '--no-browser'], json: true },
+      data: { flags: ['--server=happy-server|happy-server-light', '--no-ui', '--no-daemon', '--restart', '--watch', '--no-watch', '--no-browser', '--mobile'], json: true },
       text: [
         '[dev] usage:',
         '  happys dev [--server=happy-server|happy-server-light] [--restart] [--json]',
         '  happys dev --watch      # rebuild/restart happy-cli daemon on file changes (TTY default)',
         '  happys dev --no-watch   # disable watch mode (always disabled in non-interactive mode)',
         '  happys dev --no-browser # do not open the UI in your browser automatically',
+        '  happys dev --mobile     # also start Expo dev-client Metro for mobile',
         '  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;
   }
   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 serverComponentName = getServerComponentName({ kv });
   if (serverComponentName === 'both') {
     throw new Error(`[local] --server=both is not supported for dev (pick one: happy-server-light or happy-server)`);
@@ -67,6 +80,7 @@ async function main() {
 
   const startUi = !flags.has('--no-ui') && (process.env.HAPPY_LOCAL_UI ?? '1') !== '0';
   const startDaemon = !flags.has('--no-daemon') && (process.env.HAPPY_LOCAL_DAEMON ?? '1') !== '0';
+  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 serverDir = getComponentDir(rootDir, serverComponentName);
@@ -91,7 +105,10 @@ async function main() {
   // - Only the main stack should ever auto-enable (or prefer) Tailscale Serve by default.
   // - Non-main stacks should default to localhost URLs 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 });
   const internalServerUrl = resolvedUrls.internalServerUrl;
   let publicServerUrl = resolvedUrls.publicServerUrl;
@@ -102,6 +119,8 @@ async function main() {
       publicServerUrl = resolvedUrls.defaultPublicUrl;
     }
   }
+  // Expo app config: this is what both web + native app use to reach the Happy server.
+  // LAN rewrite (for dev-client) is centralized in ensureDevExpoServer.
   const uiApiUrl = resolvedUrls.defaultPublicUrl;
   const restart = flags.has('--restart');
   const cliHomeDir = process.env.HAPPY_LOCAL_CLI_HOME_DIR?.trim()
@@ -121,6 +140,7 @@ async function main() {
         internalServerUrl,
         publicServerUrl,
         startUi,
+        startMobile,
         startDaemon,
         cliHomeDir,
       },
@@ -144,13 +164,25 @@ async function main() {
   const serverAlreadyRunning = await isHappyServerRunning(internalServerUrl);
   const daemonAlreadyRunning = startDaemon ? isDaemonRunning(cliHomeDir) : false;
 
-  // UI dev server state (worktree-scoped)
-  const uiPaths = getExpoStatePaths({ baseDir: autostart.baseDir, kind: 'ui-dev', projectDir: uiDir, stateFileName: 'ui.state.json' });
-  const uiRunning = startUi ? await isStateProcessRunning(uiPaths.statePath) : { running: false, state: null };
-  let uiAlreadyRunning = Boolean(uiRunning.running);
-
-  if (!restart && serverAlreadyRunning && (!startDaemon || daemonAlreadyRunning) && (!startUi || uiAlreadyRunning)) {
-    console.log(`[local] dev: stack already running (server=${internalServerUrl}${startDaemon ? ` daemon=${daemonAlreadyRunning ? 'running' : 'stopped'}` : ''}${startUi ? ` ui=${uiAlreadyRunning ? 'running' : 'stopped'}` : ''})`);
+  // Expo dev server state (worktree-scoped): single Expo process per stack/worktree.
+  const startExpo = startUi || startMobile;
+  const expoPaths = getExpoStatePaths({
+    baseDir: autostart.baseDir,
+    kind: 'expo-dev',
+    projectDir: uiDir,
+    stateFileName: 'expo.state.json',
+  });
+  const expoRunning = startExpo ? await isStateProcessRunning(expoPaths.statePath) : { running: false, state: null };
+  let expoAlreadyRunning = Boolean(expoRunning.running);
+
+  if (!restart && serverAlreadyRunning && (!startDaemon || daemonAlreadyRunning) && (!startExpo || expoAlreadyRunning)) {
+    console.log(
+      `[local] dev: stack already running (server=${internalServerUrl}` +
+        `${startDaemon ? ` daemon=${daemonAlreadyRunning ? 'running' : 'stopped'}` : ''}` +
+        `${startUi ? ` ui=${expoAlreadyRunning ? 'running' : 'stopped'}` : ''}` +
+        `${startMobile ? ` mobile=${expoAlreadyRunning ? 'running' : 'stopped'}` : ''}` +
+        `)`
+    );
     return;
   }
 
@@ -202,6 +234,75 @@ async function main() {
   // - Ensure schema exists (server-light: db push; happy-server: migrate deploy if tables missing)
   // - Auto-seed from main only when needed (non-main + non-interactive default, and only if missing creds or 0 accounts)
   const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const accountProbe = await getAccountCountForServerComponent({
+    serverComponentName,
+    serverDir,
+    env: serverEnv,
+    bestEffort: true,
+  });
+  const accountCount = typeof accountProbe.accountCount === 'number' ? accountProbe.accountCount : null;
+  const autoSeedEnabled = resolveAutoCopyFromMainEnabled({ env: baseEnv, stackName, isInteractive });
+
+  let expoResEarly = null;
+  const wantsAuthFlow =
+    (baseEnv.HAPPY_STACKS_AUTH_FLOW ?? baseEnv.HAPPY_LOCAL_AUTH_FLOW ?? '').toString().trim() === '1' ||
+    (baseEnv.HAPPY_STACKS_DAEMON_WAIT_FOR_AUTH ?? baseEnv.HAPPY_LOCAL_DAEMON_WAIT_FOR_AUTH ?? '').toString().trim() === '1';
+
+  // CRITICAL (review-pr / setup-pr guided login):
+  // In background/non-interactive runs, the daemon may block on auth. If we wait to start Expo web
+  // until after the daemon is authenticated, guided login will have no UI origin and will fall back
+  // to the server port (wrong). Start Expo web UI early when running an auth flow.
+  if (wantsAuthFlow && startUi && !expoResEarly) {
+    expoResEarly = await ensureDevExpoServer({
+      startUi,
+      startMobile,
+      uiDir,
+      autostart,
+      baseEnv,
+      apiServerUrl: uiApiUrl,
+      restart,
+      stackMode,
+      runtimeStatePath,
+      stackName,
+      envPath,
+      children,
+      spawnOptions: { stdio: ['ignore', 'ignore', 'ignore'] },
+    });
+  }
+  await maybeRunInteractiveStackAuthSetup({
+    rootDir,
+    // In dev mode, guided login must target the Expo web UI origin (not the server port).
+    // Mark this as an auth-flow so URL resolution fails closed if Expo isn't ready.
+    env: startUi ? { ...baseEnv, HAPPY_STACKS_AUTH_FLOW: '1', HAPPY_LOCAL_AUTH_FLOW: '1' } : baseEnv,
+    stackName,
+    cliHomeDir,
+    accountCount,
+    isInteractive,
+    autoSeedEnabled,
+    beforeLogin: async () => {
+      if (!startUi) {
+        throw new Error(
+          `[local] auth: interactive login requires the web UI.\n` +
+            `Re-run without --no-ui, or set HAPPY_WEBAPP_URL to a reachable Happy UI for this stack.`
+        );
+      }
+      if (expoResEarly) return;
+      expoResEarly = await ensureDevExpoServer({
+        startUi,
+        startMobile,
+        uiDir,
+        autostart,
+        baseEnv,
+        apiServerUrl: uiApiUrl,
+        restart,
+        stackMode,
+        runtimeStatePath,
+        stackName,
+        envPath,
+        children,
+      });
+    },
+  });
   await prepareDaemonAuthSeed({
     rootDir,
     env: baseEnv,
@@ -215,19 +316,35 @@ async function main() {
     quiet: false,
   });
 
-  await startDevDaemon({
-    startDaemon,
-    cliBin,
-    cliHomeDir,
-    internalServerUrl,
-    publicServerUrl,
-    restart,
-    isShuttingDown: () => shuttingDown,
-  });
+  if (startDaemon) {
+    const gate = daemonStartGate({ env: baseEnv, cliHomeDir });
+    if (!gate.ok) {
+      // In orchestrated auth flows (setup-pr/review-pr), we intentionally keep server/UI up
+      // for guided login and start daemon post-auth from the orchestrator.
+      if (gate.reason === 'auth_flow_missing_credentials') {
+        console.log('[local] auth flow: skipping daemon start until credentials exist');
+      } else {
+        const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+        if (!isInteractive) {
+          throw new Error(formatDaemonAuthRequiredError({ stackName, cliHomeDir }));
+        }
+      }
+    } else {
+      await startDevDaemon({
+        startDaemon,
+        cliBin,
+        cliHomeDir,
+        internalServerUrl,
+        publicServerUrl,
+        restart,
+        isShuttingDown: () => shuttingDown,
+      });
+    }
+  }
 
   const cliWatcher = watchHappyCliAndRestartDaemon({
     enabled: watchEnabled,
-    startDaemon,
+    startDaemon: startDaemon && daemonStartGate({ env: baseEnv, cliHomeDir }).ok,
     buildCli,
     cliDir,
     cliBin,
@@ -272,43 +389,52 @@ async function main() {
     );
   }
 
-  const uiRes = await startDevExpoWebUi({
-    startUi,
-    uiDir,
-    autostart,
-    baseEnv,
-    apiServerUrl: uiApiUrl,
-    restart,
-    stackMode,
-    runtimeStatePath,
-    stackName,
-    envPath,
-    children,
-  });
+  const expoRes =
+    expoResEarly ??
+    (await ensureDevExpoServer({
+      startUi,
+      startMobile,
+      uiDir,
+      autostart,
+      baseEnv,
+      apiServerUrl: uiApiUrl,
+      restart,
+      stackMode,
+      runtimeStatePath,
+      stackName,
+      envPath,
+      children,
+    }));
   if (startUi) {
-    const host = resolveLocalhostHost({ stackMode, stackName });
-    if (uiRes?.reason === 'already_running' && uiRes.port) {
-      console.log(`[local] ui already running (pid=${uiRes.pid}, port=${uiRes.port})`);
-      console.log(`[local] ui: open http://${host}:${uiRes.port}`);
-    } else if (uiRes?.skipped === false && uiRes.port) {
-      console.log(`[local] ui: open http://${host}:${uiRes.port}`);
-    } else if (uiRes?.skipped && uiRes?.reason === 'already_running') {
+    const uiPort = expoRes?.port;
+    const uiUrlRaw = uiPort ? `http://localhost:${uiPort}` : '';
+    const uiUrl = uiUrlRaw ? await preferStackLocalhostUrl(uiUrlRaw, { stackName }) : '';
+    if (expoRes?.reason === 'already_running' && expoRes.port) {
+      console.log(`[local] ui already running (pid=${expoRes.pid}, port=${expoRes.port})`);
+      if (uiUrl) console.log(`[local] ui: open ${uiUrl}`);
+    } else if (expoRes?.skipped === false && expoRes.port) {
+      if (uiUrl) console.log(`[local] ui: open ${uiUrl}`);
+    } else if (expoRes?.skipped && expoRes?.reason === 'already_running') {
       console.log('[local] ui already running (skipping Expo start)');
     }
 
     const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-    const shouldOpen = isInteractive && !noBrowser && Boolean(uiRes?.port);
+    const shouldOpen = isInteractive && !noBrowser && Boolean(expoRes?.port);
     if (shouldOpen) {
-      const url = `http://${host}:${uiRes.port}`;
       // Prefer localhost for readiness checks (faster/more reliable), but open the stack-scoped hostname.
-      await waitForHttpOk(`http://localhost:${uiRes.port}`, { timeoutMs: 30_000 }).catch(() => {});
-      const res = await openUrlInBrowser(url);
+      await waitForHttpOk(`http://localhost:${expoRes.port}`, { timeoutMs: 30_000 }).catch(() => {});
+      const res = await openUrlInBrowser(uiUrl);
       if (!res.ok) {
         console.warn(`[local] ui: failed to open browser automatically (${res.error}).`);
       }
     }
   }
 
+  if (startMobile && expoRes?.port) {
+    const metroUrl = await preferStackLocalhostUrl(`http://localhost:${expoRes.port}`, { stackName });
+    console.log(`[local] mobile: metro ${metroUrl}`);
+  }
+
   const shutdown = async () => {
     if (shuttingDown) {
       return;

package/scripts/doctor.mjs

@@ -1,21 +1,24 @@
-import './utils/env.mjs';
+import './utils/env/env.mjs';
 import { parseArgs } from './utils/cli/args.mjs';
-import { pathExists } from './utils/fs.mjs';
-import { runCapture } from './utils/proc.mjs';
-import { getComponentDir, getDefaultAutostartPaths, getHappyStacksHomeDir, getRootDir, getWorkspaceDir, resolveStackEnvPath } from './utils/paths.mjs';
-import { killPortListeners } from './utils/ports.mjs';
-import { getServerComponentName } from './utils/server.mjs';
+import { pathExists } from './utils/fs/fs.mjs';
+import { runCapture } from './utils/proc/proc.mjs';
+import { resolveCommandPath } from './utils/proc/commands.mjs';
+import { getComponentDir, getDefaultAutostartPaths, getHappyStacksHomeDir, getRootDir, getWorkspaceDir, resolveStackEnvPath } from './utils/paths/paths.mjs';
+import { killPortListeners } from './utils/net/ports.mjs';
+import { getServerComponentName } from './utils/server/server.mjs';
+import { fetchHappyHealth } from './utils/server/server.mjs';
 import { daemonStatusSummary } from './daemon.mjs';
 import { tailscaleServeStatus } from './tailscale.mjs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
 import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
-import { getRuntimeDir } from './utils/runtime.mjs';
-import { assertServerComponentDirMatches } from './utils/validate.mjs';
-import { resolveServerPortFromEnv, resolveServerUrls } from './utils/server_urls.mjs';
-import { resolveStackContext } from './utils/stack_context.mjs';
+import { getRuntimeDir } from './utils/paths/runtime.mjs';
+import { assertServerComponentDirMatches } from './utils/server/validate.mjs';
+import { resolveServerPortFromEnv, resolveServerUrls } from './utils/server/urls.mjs';
+import { resolveStackContext } from './utils/stack/context.mjs';
+import { readJsonIfExists } from './utils/fs/json.mjs';
+import { readPackageJsonVersion } from './utils/fs/package_json.mjs';
 
 /**
  * Doctor script for common happy-stacks failure modes.
@@ -43,7 +46,8 @@ async function fetchHealth(url) {
   };
 
   // Prefer /health when available, but fall back to / (matches waitForServerReady).
-  const health = await tryGet('/health');
+  const healthRaw = await fetchHappyHealth(url);
+  const health = { ok: healthRaw.ok, status: healthRaw.status, body: healthRaw.text ? healthRaw.text.trim() : null };
   if (health.ok) {
     return health;
   }
@@ -54,26 +58,6 @@ async function fetchHealth(url) {
   return health.ok ? health : root;
 }
 
-async function readJsonSafe(path) {
-  try {
-    const raw = await readFile(path, 'utf-8');
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-
-async function readPkgVersion(path) {
-  try {
-    const raw = await readFile(path, 'utf-8');
-    const pkg = JSON.parse(raw);
-    const v = String(pkg.version ?? '').trim();
-    return v || null;
-  } catch {
-    return null;
-  }
-}
-
 async function resolveSwiftbarPluginsDir() {
   if (process.platform !== 'darwin') {
     return null;
@@ -114,8 +98,8 @@ async function main() {
   const workspaceDir = getWorkspaceDir(rootDir);
   const updateCachePath = join(homeDir, 'cache', 'update.json');
   const runtimePkgJson = join(runtimeDir, 'node_modules', 'happy-stacks', 'package.json');
-  const runtimeVersion = await readPkgVersion(runtimePkgJson);
-  const updateCache = existsSync(updateCachePath) ? await readJsonSafe(updateCachePath) : null;
+  const runtimeVersion = await readPackageJsonVersion(runtimePkgJson);
+  const updateCache = await readJsonIfExists(updateCachePath, { defaultValue: null });
 
   const autostart = getDefaultAutostartPaths();
   const stackCtx = resolveStackContext({ env: process.env, autostart });
@@ -302,7 +286,7 @@ async function main() {
 
   // happy wrapper
   try {
-    const happyPath = (await runCapture('sh', ['-lc', 'command -v happy'])).trim();
+    const happyPath = await resolveCommandPath('happy');
     if (happyPath) {
       report.checks.happyOnPath = { ok: true, path: happyPath };
       if (!json) console.log(`✅ happy on PATH: ${happyPath}`);
@@ -314,7 +298,7 @@ async function main() {
 
   // happys on PATH
   try {
-    const happysPath = (await runCapture('sh', ['-lc', 'command -v happys'])).trim();
+    const happysPath = await resolveCommandPath('happys');
     if (happysPath) {
       report.checks.happysOnPath = { ok: true, path: happysPath };
       if (!json) console.log(`✅ happys on PATH: ${happysPath}`);