happy-stacks 0.2.0 → 0.4.0

package/scripts/build.mjs

@@ -1,11 +1,15 @@
-import './utils/env.mjs';
+import './utils/env/env.mjs';
 import { parseArgs } from './utils/cli/args.mjs';
-import { getComponentDir, getDefaultAutostartPaths, getRootDir } from './utils/paths.mjs';
-import { ensureDepsInstalled, pmExecBin, requireDir } from './utils/pm.mjs';
+import { componentDirEnvKey, getComponentDir, getDefaultAutostartPaths, getRootDir } from './utils/paths/paths.mjs';
+import { ensureDepsInstalled, pmExecBin, requireDir } from './utils/proc/pm.mjs';
+import { resolveServerPortFromEnv } from './utils/server/urls.mjs';
 import { dirname, join } from 'node:path';
 import { readFile, rm, mkdir, writeFile } from 'node:fs/promises';
 import { tailscaleServeHttpsUrl } from './tailscale.mjs';
 import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { ensureExpoIsolationEnv, getExpoStatePaths, wantsExpoClearCache } from './utils/expo/expo.mjs';
+import { expoExec } from './utils/expo/command.mjs';
+import { getInvokedCwd, inferComponentFromCwd } from './utils/cli/cwd_scope.mjs';
 
 /**
  * Build a lightweight static web UI bundle (no Expo dev server).
@@ -28,12 +32,29 @@ async function main() {
         '  happys build [--tauri] [--json]',
         '  (legacy in a cloned repo): pnpm build [-- --tauri] [--json]',
         '  node scripts/build.mjs [--tauri|--no-tauri] [--no-ui] [--json]',
+        '',
+        'note:',
+        '  If run from inside the Happy UI checkout/worktree, the build uses that checkout.',
       ].join('\n'),
     });
     return;
   }
   const rootDir = getRootDir(import.meta.url);
 
+  // If invoked from inside the Happy UI checkout/worktree, prefer that directory without requiring `happys wt use ...`.
+  const inferred = inferComponentFromCwd({
+    rootDir,
+    invokedCwd: getInvokedCwd(process.env),
+    components: ['happy'],
+  });
+  if (inferred?.component === 'happy') {
+    const stacksKey = componentDirEnvKey('happy');
+    const legacyKey = stacksKey.replace(/^HAPPY_STACKS_/, 'HAPPY_LOCAL_');
+    if (!(process.env[stacksKey] ?? '').toString().trim() && !(process.env[legacyKey] ?? '').toString().trim()) {
+      process.env[stacksKey] = inferred.repoDir;
+    }
+  }
+
   // Optional: skip building the web UI bundle.
   //
   // This is useful for evidence capture flows that validate non-UI components (e.g. `happy-cli`)
@@ -43,9 +64,7 @@ async function main() {
   const uiDir = getComponentDir(rootDir, 'happy');
   await requireDir('happy', uiDir);
 
-  const serverPort = process.env.HAPPY_LOCAL_SERVER_PORT
-    ? parseInt(process.env.HAPPY_LOCAL_SERVER_PORT, 10)
-    : 3005;
+  const serverPort = resolveServerPortFromEnv({ env: process.env, defaultPort: 3005 });
 
   // For Tauri builds we embed an explicit API base URL (tauri:// origins cannot use window.location.origin).
   const internalServerUrl = `http://127.0.0.1:${serverPort}`;
@@ -88,7 +107,17 @@ async function main() {
   };
 
   // Expo CLI is available via node_modules/.bin once dependencies are installed.
-  await pmExecBin({ dir: uiDir, bin: 'expo', args: ['export', '--platform', 'web', '--output-dir', outDir], env });
+  {
+    const paths = getExpoStatePaths({
+      baseDir: getDefaultAutostartPaths().baseDir,
+      kind: 'ui-export',
+      projectDir: uiDir,
+      stateFileName: 'ui.export.state.json',
+    });
+    await ensureExpoIsolationEnv({ env, stateDir: paths.stateDir, expoHomeDir: paths.expoHomeDir, tmpDir: paths.tmpDir });
+    const args = ['export', '--platform', 'web', '--output-dir', outDir, ...(wantsExpoClearCache({ env }) ? ['-c'] : [])];
+    await expoExec({ dir: uiDir, args, env, ensureDepsLabel: 'happy' });
+  }
 
   if (json) {
     printResult({ json, data: { ok: true, outDir, tauriBuilt: false } });
@@ -147,13 +176,30 @@ async function main() {
   };
   delete tauriEnv.EXPO_PUBLIC_WEB_BASE_URL;
 
-  await pmExecBin({
+  {
+    const paths = getExpoStatePaths({
+      baseDir: getDefaultAutostartPaths().baseDir,
+      kind: 'ui-export-tauri',
+      projectDir: uiDir,
+      stateFileName: 'ui.export.tauri.state.json',
+    });
+    await ensureExpoIsolationEnv({ env: tauriEnv, stateDir: paths.stateDir, expoHomeDir: paths.expoHomeDir, tmpDir: paths.tmpDir });
+  }
+
+  await expoExec({
     dir: uiDir,
-    bin: 'expo',
-    // Important: clear bundler cache so EXPO_PUBLIC_* inlining doesn't reuse
-    // the previous (web) export's transform results.
-    args: ['export', '--platform', 'web', '--output-dir', tauriDistDir, '-c'],
+    args: [
+      'export',
+      '--platform',
+      'web',
+      '--output-dir',
+      tauriDistDir,
+      // Important: clear bundler cache so EXPO_PUBLIC_* inlining doesn't reuse
+      // the previous (web) export's transform results.
+      '-c',
+    ],
     env: tauriEnv,
+    ensureDepsLabel: 'happy',
   });
 
   // Build the Tauri app using a generated config that skips upstream beforeBuildCommand (which uses yarn).

package/scripts/cli-link.mjs

@@ -1,7 +1,7 @@
-import './utils/env.mjs';
+import './utils/env/env.mjs';
 import { parseArgs } from './utils/cli/args.mjs';
-import { getComponentDir, getRootDir } from './utils/paths.mjs';
-import { ensureCliBuilt, ensureHappyCliLocalNpmLinked } from './utils/pm.mjs';
+import { getComponentDir, getRootDir } from './utils/paths/paths.mjs';
+import { ensureCliBuilt, ensureHappyCliLocalNpmLinked } from './utils/proc/pm.mjs';
 import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
 
 /**

package/scripts/completion.mjs

@@ -1,4 +1,4 @@
-import './utils/env.mjs';
+import './utils/env/env.mjs';
 
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
@@ -7,11 +7,11 @@ import { join } from 'node:path';
 
 import { parseArgs } from './utils/cli/args.mjs';
 import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
-import { runCapture } from './utils/proc.mjs';
+import { runCapture } from './utils/proc/proc.mjs';
 import { getHappysRegistry } from './utils/cli/cli_registry.mjs';
-import { expandHome } from './utils/canonical_home.mjs';
-import { getHappyStacksHomeDir, getRootDir } from './utils/paths.mjs';
-import { isSandboxed, sandboxAllowsGlobalSideEffects } from './utils/sandbox.mjs';
+import { expandHome } from './utils/paths/canonical_home.mjs';
+import { getHappyStacksHomeDir, getRootDir } from './utils/paths/paths.mjs';
+import { isSandboxed, sandboxAllowsGlobalSideEffects } from './utils/env/sandbox.mjs';
 
 function detectShell() {
   const raw = (process.env.SHELL ?? '').toLowerCase();

package/scripts/daemon.mjs

@@ -1,12 +1,16 @@
-import { spawnProc, run, runCapture } from './utils/proc.mjs';
-import { resolveAuthSeedFromEnv } from './utils/stack_startup.mjs';
-import { getStacksStorageRoot } from './utils/paths.mjs';
-import { isSandboxed, sandboxAllowsGlobalSideEffects } from './utils/sandbox.mjs';
+import { spawnProc, run, runCapture } from './utils/proc/proc.mjs';
+import { resolveAuthSeedFromEnv, resolveAutoCopyFromMainEnabled } from './utils/stack/startup.mjs';
+import { getStacksStorageRoot } from './utils/paths/paths.mjs';
+import { isSandboxed, sandboxAllowsGlobalSideEffects } from './utils/env/sandbox.mjs';
+import { runCaptureIfCommandExists } from './utils/proc/commands.mjs';
+import { readLastLines } from './utils/fs/tail.mjs';
+import { ensureCliBuilt } from './utils/proc/pm.mjs';
 import { existsSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
 import { chmod, copyFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { homedir } from 'node:os';
+import { getRootDir } from './utils/paths/paths.mjs';
 
 /**
  * Daemon lifecycle helpers for happy-stacks.
@@ -28,7 +32,7 @@ export async function cleanupStaleDaemonState(homeDir) {
 
   const lsofHasPath = async (pid, pathNeedle) => {
     try {
-      const out = await runCapture('sh', ['-lc', `command -v lsof >/dev/null 2>&1 && lsof -nP -p ${pid} 2>/dev/null || true`]);
+      const out = await runCaptureIfCommandExists('lsof', ['-nP', '-p', String(pid)]);
       return out.includes(pathNeedle);
     } catch {
       return false;
@@ -173,16 +177,46 @@ function getLatestDaemonLogPath(homeDir) {
   }
 }
 
-function readLastLines(path, lines = 60) {
+function resolveHappyCliDistEntrypoint(cliBin) {
+  const bin = String(cliBin ?? '').trim();
+  if (!bin) return null;
+  // In component checkouts/worktrees we launch via <cliDir>/bin/happy.mjs, which expects dist output.
+  // Use this to protect restarts from bricking the running daemon if dist disappears mid-build.
   try {
-    const content = readFileSync(path, 'utf-8');
-    const parts = content.split('\n');
-    return parts.slice(Math.max(0, parts.length - lines)).join('\n');
+    const binDir = dirname(bin);
+    return join(binDir, '..', 'dist', 'index.mjs');
   } catch {
     return null;
   }
 }
 
+async function ensureHappyCliDistExists({ cliBin }) {
+  const distEntrypoint = resolveHappyCliDistEntrypoint(cliBin);
+  if (!distEntrypoint) return { ok: false, distEntrypoint: null, built: false, reason: 'unknown_cli_bin' };
+  if (existsSync(distEntrypoint)) return { ok: true, distEntrypoint, built: false, reason: 'exists' };
+
+  // Try to recover automatically: missing dist is a common first-run worktree issue.
+  // We build in-place using the cliDir that owns this cliBin (../ from bin/).
+  const cliDir = join(dirname(cliBin), '..');
+  const buildCli =
+    (process.env.HAPPY_STACKS_CLI_BUILD ?? process.env.HAPPY_LOCAL_CLI_BUILD ?? '1').toString().trim() !== '0';
+  if (!buildCli) {
+    return { ok: false, distEntrypoint, built: false, reason: 'build_disabled' };
+  }
+
+  try {
+    // eslint-disable-next-line no-console
+    console.warn(`[local] happy-cli build output missing; rebuilding (${cliDir})...`);
+    await ensureCliBuilt(cliDir, { buildCli: true });
+  } catch (e) {
+    return { ok: false, distEntrypoint, built: false, reason: String(e?.message ?? e) };
+  }
+
+  return existsSync(distEntrypoint)
+    ? { ok: true, distEntrypoint, built: true, reason: 'rebuilt' }
+    : { ok: false, distEntrypoint, built: true, reason: 'rebuilt_but_missing' };
+}
+
 function excerptIndicatesMissingAuth(excerpt) {
   if (!excerpt) return false;
   return (
@@ -191,6 +225,24 @@ function excerptIndicatesMissingAuth(excerpt) {
   );
 }
 
+function excerptIndicatesInvalidAuth(excerpt) {
+  if (!excerpt) return false;
+  return (
+    excerpt.includes('Auth failed - invalid token') ||
+    excerpt.includes('Request failed with status code 401') ||
+    excerpt.includes('"status":401') ||
+    excerpt.includes('[DAEMON RUN][FATAL]') && excerpt.includes('status code 401')
+  );
+}
+
+function allowDaemonWaitForAuthWithoutTty() {
+  const raw = (process.env.HAPPY_STACKS_DAEMON_WAIT_FOR_AUTH ?? process.env.HAPPY_LOCAL_DAEMON_WAIT_FOR_AUTH ?? '')
+    .toString()
+    .trim()
+    .toLowerCase();
+  return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'y';
+}
+
 function authLoginHint() {
   const stackName = (process.env.HAPPY_STACKS_STACK ?? process.env.HAPPY_LOCAL_STACK ?? '').trim() || 'main';
   return stackName === 'main' ? 'happys auth login' : `happys stack auth ${stackName} login`;
@@ -203,6 +255,27 @@ function authCopyFromSeedHint() {
   return `happys stack auth ${stackName} copy-from ${seed}`;
 }
 
+async function maybeAutoReseedInvalidAuth({ stackName, quiet = false }) {
+  if (stackName === 'main') return { ok: false, skipped: true, reason: 'main' };
+  const env = process.env;
+  const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const enabled = resolveAutoCopyFromMainEnabled({ env, stackName, isInteractive });
+  if (!enabled) return { ok: false, skipped: true, reason: 'disabled' };
+
+  const seed = resolveAuthSeedFromEnv(env);
+  if (!quiet) {
+    console.log(`[local] auth: invalid token detected; re-seeding ${stackName} from ${seed}...`);
+  }
+  const rootDir = getRootDir(import.meta.url);
+
+  // Use stack-scoped auth copy so env/database resolution is correct for the target stack.
+  await run(process.execPath, [join(rootDir, 'scripts', 'stack.mjs'), 'auth', stackName, '--', 'copy-from', seed], {
+    cwd: rootDir,
+    env,
+  });
+  return { ok: true, skipped: false, seed };
+}
+
 async function seedCredentialsIfMissing({ cliHomeDir }) {
   const stacksRoot = getStacksStorageRoot();
   const allowGlobal = sandboxAllowsGlobalSideEffects();
@@ -297,7 +370,7 @@ async function killDaemonFromLockFile({ cliHomeDir }) {
   // We do this by checking that `lsof -p <pid>` includes the lock path (or state file path).
   let ownsLock = false;
   try {
-    const out = await runCapture('sh', ['-lc', `command -v lsof >/dev/null 2>&1 && lsof -nP -p ${pid} 2>/dev/null || true`]);
+    const out = await runCaptureIfCommandExists('lsof', ['-nP', '-p', String(pid)]);
     ownsLock = out.includes(lockPath) || out.includes(join(cliHomeDir, 'daemon.state.json')) || out.includes(join(cliHomeDir, 'logs'));
   } catch {
     ownsLock = false;
@@ -381,11 +454,27 @@ export async function startLocalDaemonWithAuth({
   publicServerUrl,
   isShuttingDown,
   forceRestart = false,
+  env = process.env,
+  stackName = null,
 }) {
-  const stackName = (process.env.HAPPY_STACKS_STACK ?? process.env.HAPPY_LOCAL_STACK ?? '').trim() || 'main';
-  const baseEnv = { ...process.env };
+  const resolvedStackName =
+    (stackName ?? '').toString().trim() ||
+    (env.HAPPY_STACKS_STACK ?? env.HAPPY_LOCAL_STACK ?? '').toString().trim() ||
+    'main';
+  const baseEnv = { ...env };
   const daemonEnv = getDaemonEnv({ baseEnv, cliHomeDir, internalServerUrl, publicServerUrl });
 
+  const distEntrypoint = resolveHappyCliDistEntrypoint(cliBin);
+  const distCheck = await ensureHappyCliDistExists({ cliBin });
+  if (!distCheck.ok) {
+    throw new Error(
+      `[local] happy-cli dist entrypoint is missing (${distEntrypoint}).\n` +
+        `[local] Refusing to start/restart daemon because it would crash with MODULE_NOT_FOUND.\n` +
+        `[local] Fix: rebuild happy-cli in the active checkout/worktree.\n` +
+        (distCheck.reason ? `[local] Detail: ${distCheck.reason}\n` : '')
+    );
+  }
+
   // If this is a migrated/new stack home dir, seed credentials from the user's existing login (best-effort)
   // to avoid requiring an interactive auth flow under launchd.
   const migrateCreds = (baseEnv.HAPPY_STACKS_MIGRATE_CREDENTIALS ?? baseEnv.HAPPY_LOCAL_MIGRATE_CREDENTIALS ?? '1').trim() !== '0';
@@ -394,6 +483,20 @@ export async function startLocalDaemonWithAuth({
   }
 
   const existing = checkDaemonState(cliHomeDir);
+  // If the daemon is already running and we're restarting it, refuse to stop it unless the
+  // happy-cli dist entrypoint exists. Otherwise a rebuild (rm -rf dist) can brick the stack.
+  if (
+    distEntrypoint &&
+    !existsSync(distEntrypoint) &&
+    (existing.status === 'running' || existing.status === 'starting')
+  ) {
+    console.warn(
+      `[local] happy-cli dist entrypoint is missing (${distEntrypoint}).\n` +
+        `[local] Refusing to restart daemon to avoid downtime. Rebuild happy-cli first.`
+    );
+    return;
+  }
+
   if (!forceRestart && (existing.status === 'running' || existing.status === 'starting')) {
     const pid = existing.pid;
     const matches = await daemonEnvMatches({ pid, cliHomeDir, internalServerUrl, publicServerUrl });
@@ -427,7 +530,7 @@ export async function startLocalDaemonWithAuth({
   }
 
   // Best-effort: for the main stack, also stop the legacy global daemon home (~/.happy) to prevent legacy overlap.
-  if (stackName === 'main' && (!isSandboxed() || sandboxAllowsGlobalSideEffects())) {
+  if (resolvedStackName === 'main' && (!isSandboxed() || sandboxAllowsGlobalSideEffects())) {
     const legacyEnv = { ...daemonEnv, HAPPY_HOME_DIR: join(homedir(), '.happy') };
     try {
       await new Promise((resolve) => {
@@ -460,10 +563,20 @@ export async function startLocalDaemonWithAuth({
       return { ok: true, exitCode, excerpt: null, logPath: null };
     }
 
+    // Some daemon versions (or transient races) can return non-zero even if the daemon
+    // is already running / starting for this stack home dir (e.g. "lock already held").
+    // In those cases, fail-open and keep the stack running; callers can still surface
+    // daemon status separately.
+    await delay(500);
+    const stateAfter = checkDaemonState(cliHomeDir);
+    if (stateAfter.status === 'running' || stateAfter.status === 'starting') {
+      return { ok: true, exitCode, excerpt: null, logPath: null };
+    }
+
     const logPath =
       getLatestDaemonLogPath(cliHomeDir) ||
       ((!isSandboxed() || sandboxAllowsGlobalSideEffects()) ? getLatestDaemonLogPath(join(homedir(), '.happy')) : null);
-    const excerpt = logPath ? readLastLines(logPath, 120) : null;
+    const excerpt = logPath ? await readLastLines(logPath, 120) : null;
     return { ok: false, exitCode, excerpt, logPath };
   };
 
@@ -476,21 +589,32 @@ export async function startLocalDaemonWithAuth({
     }
 
     if (excerptIndicatesMissingAuth(first.excerpt)) {
+      const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY) || allowDaemonWaitForAuthWithoutTty();
       const copyHint = authCopyFromSeedHint();
-      console.error(
+      const hint =
         `[local] daemon is not authenticated yet (expected on first run).\n` +
-        `[local] Keeping the server running so you can login.\n` +
         `[local] In another terminal, run:\n` +
         `${authLoginHint()}\n` +
-        (copyHint ? `[local] Or (recommended if main is already logged in):\n${copyHint}\n` : '') +
-        `[local] Waiting for credentials at ${credentialsPath}...`
-      );
+        (copyHint ? `[local] Or (recommended if main is already logged in):\n${copyHint}\n` : '');
+      if (!isInteractive) {
+        throw new Error(`${hint}[local] Non-interactive mode: refusing to wait for credentials.`);
+      }
+
+      console.error(`${hint}[local] Keeping the server running so you can login.\n[local] Waiting for credentials at ${credentialsPath}...`);
 
       const ok = await waitForCredentialsFile({ path: credentialsPath, timeoutMs: 10 * 60_000, isShuttingDown });
       if (!ok) {
         throw new Error('Timed out waiting for daemon credentials (auth login not completed)');
       }
 
+      // If a daemon start attempt was already in-flight (or a previous daemon is already running),
+      // avoid a second concurrent start and treat it as success.
+      await delay(500);
+      const stateAfterCreds = checkDaemonState(cliHomeDir);
+      if (stateAfterCreds.status === 'running' || stateAfterCreds.status === 'starting') {
+        return;
+      }
+
       console.log('[local] credentials detected, retrying daemon start...');
       const second = await startOnce();
       if (!second.ok) {
@@ -499,6 +623,30 @@ export async function startLocalDaemonWithAuth({
         }
         throw new Error('Failed to start daemon (after credentials were created)');
       }
+    } else if (excerptIndicatesInvalidAuth(first.excerpt)) {
+      // Credentials exist but are rejected by this server (common when a stack's env/DB was reset,
+      // or credentials were copied from a different stack identity).
+      try {
+        await maybeAutoReseedInvalidAuth({ stackName });
+      } catch (e) {
+        const copyHint = authCopyFromSeedHint();
+        console.error(
+          `[local] daemon credentials were rejected by the server (401).\n` +
+            `[local] Fix:\n` +
+            (copyHint ? `- ${copyHint}\n` : '') +
+            `- ${authLoginHint()}`
+        );
+        throw e;
+      }
+
+      console.log('[local] auth re-seeded, retrying daemon start...');
+      const second = await startOnce();
+      if (!second.ok) {
+        if (second.excerpt) {
+          console.error(`[local] daemon still failed to start; last daemon log (${second.logPath}):\n${second.excerpt}`);
+        }
+        throw new Error('Failed to start daemon (after auth re-seed)');
+      }
     } else {
       const copyHint = authCopyFromSeedHint();
       console.error(