happy-stacks 0.3.0 → 0.4.0

package/scripts/dev.mjs

@@ -1,7 +1,7 @@
 import './utils/env/env.mjs';
 import { parseArgs } from './utils/cli/args.mjs';
 import { killProcessTree } 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 } from './utils/server/server.mjs';
 import { requireDir } from './utils/proc/pm.mjs';
@@ -17,11 +17,15 @@ 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/paths/localhost_host.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:
@@ -37,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)`);
@@ -58,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);
@@ -82,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;
@@ -93,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()
@@ -112,6 +140,7 @@ async function main() {
         internalServerUrl,
         publicServerUrl,
         startUi,
+        startMobile,
         startDaemon,
         cliHomeDir,
       },
@@ -135,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;
   }
 
@@ -193,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,
@@ -206,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,
@@ -263,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/edison.mjs

@@ -8,7 +8,7 @@ import { readTextOrEmpty } from './utils/fs/ops.mjs';
 import { readJsonIfExists } from './utils/fs/json.mjs';
 import { isPidAlive } from './utils/proc/pids.mjs';
 import { run, runCapture } from './utils/proc/proc.mjs';
-import { resolveLocalhostHost } from './utils/paths/localhost_host.mjs';
+import { preferStackLocalhostHost, resolveLocalhostHost } from './utils/paths/localhost_host.mjs';
 import { sanitizeStackName } from './utils/stack/names.mjs';
 import { join } from 'node:path';
 import { spawn } from 'node:child_process';
@@ -1781,7 +1781,9 @@ async function main() {
   env.HAPPY_STACKS_EDISON_WRAPPER = '1';
   // Provide a stack-scoped localhost hostname for validators and browser flows.
   // This ensures origin isolation even if ports are reused later (common with ephemeral ports).
-  const localhostHost = resolveLocalhostHost({ stackMode: Boolean(stackName), stackName: stackName || 'main' });
+  const localhostHost = Boolean(stackName)
+    ? await preferStackLocalhostHost({ stackName })
+    : resolveLocalhostHost({ stackMode: false, stackName: 'main' });
   env.HAPPY_STACKS_LOCALHOST_HOST = localhostHost;
   env.HAPPY_LOCAL_LOCALHOST_HOST = localhostHost;
 

package/scripts/init.mjs

@@ -199,7 +199,9 @@ async function main() {
   const storageDirRaw = parseArgValue(argv, 'storage-dir');
   const storageDirOverride = expandHome((storageDirRaw ?? '').trim());
   if (storageDirOverride) {
-    process.env.HAPPY_STACKS_STORAGE_DIR = process.env.HAPPY_STACKS_STORAGE_DIR ?? storageDirOverride;
+    // In sandbox mode, storage dir MUST be isolated and must override any pre-existing env.
+    process.env.HAPPY_STACKS_STORAGE_DIR = isSandboxed() ? storageDirOverride : (process.env.HAPPY_STACKS_STORAGE_DIR ?? storageDirOverride);
+    process.env.HAPPY_LOCAL_STORAGE_DIR = process.env.HAPPY_LOCAL_STORAGE_DIR ?? process.env.HAPPY_STACKS_STORAGE_DIR;
   }
 
   const cliRootDirRaw = parseArgValue(argv, 'cli-root-dir');

package/scripts/install.mjs

@@ -1,7 +1,7 @@
 import './utils/env/env.mjs';
 import { parseArgs } from './utils/cli/args.mjs';
 import { pathExists } from './utils/fs/fs.mjs';
-import { run } from './utils/proc/proc.mjs';
+import { run, runCapture } from './utils/proc/proc.mjs';
 import { getComponentDir, getRootDir } from './utils/paths/paths.mjs';
 import { getServerComponentName } from './utils/server/server.mjs';
 import { ensureCliBuilt, ensureDepsInstalled, ensureHappyCliLocalNpmLinked } from './utils/proc/pm.mjs';
@@ -24,8 +24,10 @@ import { isSandboxed, sandboxAllowsGlobalSideEffects } from './utils/env/sandbox
 
 const DEFAULT_FORK_REPOS = {
   serverLight: 'https://github.com/leeroybrun/happy-server-light.git',
-  // We don't currently maintain a separate fork for full happy-server; default to upstream.
-  serverFull: 'https://github.com/slopus/happy-server.git',
+  // Both server flavors live as branches in the same fork repo:
+  // - happy-server-light (sqlite)
+  // - happy-server (full)
+  serverFull: 'https://github.com/leeroybrun/happy-server-light.git',
   cli: 'https://github.com/leeroybrun/happy-cli.git',
   ui: 'https://github.com/leeroybrun/happy.git',
 };
@@ -44,7 +46,8 @@ function repoUrlsFromOwners({ forkOwner, upstreamOwner }) {
   return {
     forks: {
       serverLight: fork('happy-server-light'),
-      serverFull: fork('happy-server') /* best-effort; user can override */,
+      // Fork convention: server full is a branch in happy-server-light repo (not a separate repo).
+      serverFull: fork('happy-server-light'),
       cli: fork('happy-cli'),
       ui: fork('happy'),
     },
@@ -86,6 +89,51 @@ function getRepoUrls({ repoSource }) {
   };
 }
 
+async function ensureGitBranchCheckedOut({ repoDir, branch, label }) {
+  if (!(await pathExists(join(repoDir, '.git')))) return;
+  const b = String(branch ?? '').trim();
+  if (!b) return;
+
+  try {
+    const head = (await runCapture('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: repoDir })).trim();
+    if (head && head === b) return;
+  } catch {
+    // ignore
+  }
+
+  // Ensure branch exists locally, otherwise fetch it from origin.
+  let hasLocal = true;
+  try {
+    await run('git', ['show-ref', '--verify', '--quiet', `refs/heads/${b}`], { cwd: repoDir });
+  } catch {
+    hasLocal = false;
+  }
+  if (!hasLocal) {
+    try {
+      await run('git', ['fetch', '--quiet', 'origin', b], { cwd: repoDir });
+    } catch {
+      throw new Error(
+        `[local] ${label}: expected branch "${b}" to exist in ${repoDir}.\n` +
+          `[local] Fix: use --forks for happy-server-light (sqlite), or use --server=happy-server with --upstream.`
+      );
+    }
+  }
+
+  try {
+    await run('git', ['checkout', '-q', b], { cwd: repoDir });
+  } catch {
+    // If remote-tracking branch exists but local doesn't, create it.
+    try {
+      await run('git', ['checkout', '-q', '-B', b, `origin/${b}`], { cwd: repoDir });
+    } catch {
+      throw new Error(
+        `[local] ${label}: failed to checkout branch "${b}" in ${repoDir}.\n` +
+          `[local] Fix: re-run with --force in worktree flows, or delete the checkout and re-run install/bootstrap.`
+      );
+    }
+  }
+}
+
 async function ensureComponentPresent({ dir, label, repoUrl, allowClone }) {
   if (await pathExists(dir)) {
     return;
@@ -201,7 +249,22 @@ async function main() {
   if (wantsHelp(argv, { flags })) {
     printResult({
       json,
-      data: { flags: ['--forks', '--upstream', '--clone', '--no-clone', '--autostart', '--no-autostart', '--server=...'], json: true },
+      data: {
+        flags: [
+          '--forks',
+          '--upstream',
+          '--clone',
+          '--no-clone',
+          '--autostart',
+          '--no-autostart',
+          '--server=...',
+          '--no-ui-build',
+          '--no-ui-deps',
+          '--no-cli-deps',
+          '--no-cli-build',
+        ],
+        json: true,
+      },
       text: [
         '[bootstrap] usage:',
         '  happys bootstrap [--forks|--upstream] [--server=happy-server|happy-server-light|both] [--json]',
@@ -270,6 +333,17 @@ async function main() {
   const disableAutostart = flags.has('--no-autostart');
 
   const serverComponentName = (wizard?.serverComponentName ?? getServerComponentName({ kv })).trim();
+  // Safety: upstream server-light is not a separate upstream repo/branch today.
+  // Upstream slopus/happy-server is Postgres-only, while happy-server-light requires sqlite.
+  if (repoSource === 'upstream' && (serverComponentName === 'happy-server-light' || serverComponentName === 'both')) {
+    throw new Error(
+      `[bootstrap] --upstream is not supported for happy-server-light (sqlite).\n` +
+        `Reason: upstream ${DEFAULT_UPSTREAM_REPOS.serverLight} does not provide a happy-server-light branch.\n` +
+        `Fix:\n` +
+        `- use --forks (recommended), OR\n` +
+        `- use --server=happy-server with --upstream`
+    );
+  }
   const serverLightDir = getComponentDir(rootDir, 'happy-server-light');
   const serverFullDir = getComponentDir(rootDir, 'happy-server');
   const cliDir = getComponentDir(rootDir, 'happy-cli');
@@ -305,35 +379,57 @@ async function main() {
     allowClone,
   });
 
+  // Ensure expected branches are checked out for server flavors (avoids "server-light directory contains full server" mistakes).
+  if (serverComponentName === 'both' || serverComponentName === 'happy-server-light') {
+    await ensureGitBranchCheckedOut({ repoDir: serverLightDir, branch: 'happy-server-light', label: 'SERVER' });
+  }
+  if (serverComponentName === 'both' || serverComponentName === 'happy-server') {
+    // In fork mode, full server is a branch in the fork server repo. In upstream mode, use upstream main.
+    const serverFullBranch = repoSource === 'upstream' ? 'main' : 'happy-server';
+    await ensureGitBranchCheckedOut({ repoDir: serverFullDir, branch: serverFullBranch, label: 'SERVER_FULL' });
+  }
+
   const cliDirFinal = cliDir;
   const uiDirFinal = uiDir;
 
   // Install deps
+  const skipUiDeps = flags.has('--no-ui-deps') || (process.env.HAPPY_STACKS_INSTALL_NO_UI_DEPS ?? '').trim() === '1';
+  const skipCliDeps = flags.has('--no-cli-deps') || (process.env.HAPPY_STACKS_INSTALL_NO_CLI_DEPS ?? '').trim() === '1';
   if (serverComponentName === 'both' || serverComponentName === 'happy-server-light') {
     await ensureDepsInstalled(serverLightDir, 'happy-server-light');
   }
   if (serverComponentName === 'both' || serverComponentName === 'happy-server') {
     await ensureDepsInstalled(serverFullDir, 'happy-server');
   }
-  await ensureDepsInstalled(uiDirFinal, 'happy');
-  await ensureDepsInstalled(cliDirFinal, 'happy-cli');
+  if (!skipUiDeps) {
+    await ensureDepsInstalled(uiDirFinal, 'happy');
+  }
+  if (!skipCliDeps) {
+    await ensureDepsInstalled(cliDirFinal, 'happy-cli');
+  }
 
   // CLI build + link
-  const buildCli = (process.env.HAPPY_LOCAL_CLI_BUILD ?? '1') !== '0';
-  const npmLinkCli = (process.env.HAPPY_LOCAL_NPM_LINK ?? '1') !== '0';
-  await ensureCliBuilt(cliDirFinal, { buildCli });
-  await ensureHappyCliLocalNpmLinked(rootDir, { npmLinkCli });
+  const skipCliBuild = flags.has('--no-cli-build') || (process.env.HAPPY_STACKS_INSTALL_NO_CLI_BUILD ?? '').trim() === '1';
+  if (!skipCliBuild) {
+    const buildCli = (process.env.HAPPY_LOCAL_CLI_BUILD ?? '1') !== '0';
+    const npmLinkCli = (process.env.HAPPY_LOCAL_NPM_LINK ?? '1') !== '0';
+    await ensureCliBuilt(cliDirFinal, { buildCli });
+    await ensureHappyCliLocalNpmLinked(rootDir, { npmLinkCli });
+  }
 
   // Build UI (so run works without expo dev server)
+  const skipUiBuild = flags.has('--no-ui-build') || (process.env.HAPPY_STACKS_INSTALL_NO_UI_BUILD ?? '').trim() === '1';
   const buildArgs = [join(rootDir, 'scripts', 'build.mjs')];
   // Tauri builds are opt-in (slow + requires additional toolchain).
   const buildTauri = wizard?.buildTauri ?? (flags.has('--tauri') && !flags.has('--no-tauri'));
-  if (buildTauri) {
-    buildArgs.push('--tauri');
-  } else if (flags.has('--no-tauri')) {
-    buildArgs.push('--no-tauri');
+  if (!skipUiBuild) {
+    if (buildTauri) {
+      buildArgs.push('--tauri');
+    } else if (flags.has('--no-tauri')) {
+      buildArgs.push('--no-tauri');
+    }
+    await run(process.execPath, buildArgs, { cwd: rootDir });
   }
-  await run(process.execPath, buildArgs, { cwd: rootDir });
 
   // Optional autostart (macOS)
   if (disableAutostart) {

package/scripts/lint.mjs

@@ -1,11 +1,12 @@
 import './utils/env/env.mjs';
 import { parseArgs } from './utils/cli/args.mjs';
 import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
-import { getComponentDir, getRootDir } from './utils/paths/paths.mjs';
+import { componentDirEnvKey, getComponentDir, getRootDir } from './utils/paths/paths.mjs';
 import { ensureDepsInstalled } from './utils/proc/pm.mjs';
 import { pathExists } from './utils/fs/fs.mjs';
 import { run } from './utils/proc/proc.mjs';
 import { detectPackageManagerCmd, pickFirstScript, readPackageJsonScripts } from './utils/proc/package_scripts.mjs';
+import { getInvokedCwd, inferComponentFromCwd } from './utils/cli/cwd_scope.mjs';
 
 const DEFAULT_COMPONENTS = ['happy', 'happy-cli', 'happy-server-light', 'happy-server'];
 
@@ -40,18 +41,37 @@ async function main() {
         'examples:',
         '  happys lint',
         '  happys lint happy happy-cli',
+        '',
+        'note:',
+        '  If run from inside a component checkout/worktree and no components are provided, defaults to that component.',
       ].join('\n'),
     });
     return;
   }
 
+  const rootDir = getRootDir(import.meta.url);
+
   const positionals = argv.filter((a) => !a.startsWith('--'));
-  const requested = positionals.length ? positionals : ['all'];
+  const inferred =
+    positionals.length === 0
+      ? inferComponentFromCwd({
+          rootDir,
+          invokedCwd: getInvokedCwd(process.env),
+          components: DEFAULT_COMPONENTS,
+        })
+      : null;
+  if (inferred) {
+    const stacksKey = componentDirEnvKey(inferred.component);
+    const legacyKey = stacksKey.replace(/^HAPPY_STACKS_/, 'HAPPY_LOCAL_');
+    if (!(process.env[stacksKey] ?? '').toString().trim() && !(process.env[legacyKey] ?? '').toString().trim()) {
+      process.env[stacksKey] = inferred.repoDir;
+    }
+  }
+
+  const requested = positionals.length ? positionals : inferred ? [inferred.component] : ['all'];
   const wantAll = requested.includes('all');
   const components = wantAll ? DEFAULT_COMPONENTS : requested;
 
-  const rootDir = getRootDir(import.meta.url);
-
   const results = [];
   for (const component of components) {
     if (!DEFAULT_COMPONENTS.includes(component)) {