happy-stacks 0.1.0 → 0.2.0

package/scripts/dev.mjs

@@ -1,17 +1,36 @@
 import './utils/env.mjs';
-import { parseArgs } from './utils/args.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, waitForServerReady } from './utils/server.mjs';
-import { ensureDepsInstalled, pmSpawnScript, requireDir } from './utils/pm.mjs';
+import { getServerComponentName, isHappyServerRunning } from './utils/server.mjs';
+import { requireDir } from './utils/pm.mjs';
 import { join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { homedir } from 'node:os';
-import { startLocalDaemonWithAuth, stopLocalDaemon } from './daemon.mjs';
-import { resolvePublicServerUrl } from './tailscale.mjs';
-import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
-import { assertServerComponentDirMatches } from './utils/validate.mjs';
+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;
+}
 
 /**
  * Dev mode stack:
@@ -27,10 +46,13 @@ async function main() {
   if (wantsHelp(argv, { flags })) {
     printResult({
       json,
-      data: { flags: ['--server=happy-server|happy-server-light', '--no-ui', '--no-daemon'], json: true },
+      data: { flags: ['--server=happy-server|happy-server-light', '--no-ui', '--no-daemon', '--restart', '--watch', '--no-watch', '--no-browser'], json: true },
       text: [
         '[dev] usage:',
-        '  happys dev [--server=happy-server|happy-server-light] [--json]',
+        '  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',
         '  note: --json prints the resolved config (dry-run) and exits.',
       ].join('\n'),
     });
@@ -38,21 +60,6 @@ async function main() {
   }
   const rootDir = getRootDir(import.meta.url);
 
-  const serverPort = process.env.HAPPY_LOCAL_SERVER_PORT
-    ? parseInt(process.env.HAPPY_LOCAL_SERVER_PORT, 10)
-    : 3005;
-
-  const internalServerUrl = `http://127.0.0.1:${serverPort}`;
-  const defaultPublicUrl = `http://localhost:${serverPort}`;
-  const envPublicUrl = process.env.HAPPY_LOCAL_SERVER_URL?.trim() ? process.env.HAPPY_LOCAL_SERVER_URL.trim() : '';
-  const resolved = await resolvePublicServerUrl({
-    internalServerUrl,
-    defaultPublicUrl,
-    envPublicUrl,
-    allowEnable: true,
-  });
-  const publicServerUrl = resolved.publicServerUrl;
-
   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)`);
@@ -60,21 +67,46 @@ 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 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);
   const uiDir = getComponentDir(rootDir, 'happy');
   const cliDir = getComponentDir(rootDir, 'happy-cli');
 
   assertServerComponentDirMatches({ rootDir, serverComponentName, serverDir });
+  assertServerPrismaProviderMatches({ serverComponentName, serverDir });
 
   await requireDir(serverComponentName, serverDir);
   await requireDir('happy', uiDir);
   await requireDir('happy-cli', cliDir);
 
   const cliBin = join(cliDir, 'bin', 'happy.mjs');
+  const autostart = getDefaultAutostartPaths();
+  const baseEnv = { ...process.env };
+  const stackCtx = resolveStackContext({ env: baseEnv, autostart });
+  const { stackMode, runtimeStatePath, stackName, envPath, ephemeral } = stackCtx;
+
+  const serverPort = resolveServerPortFromEnv({ env: baseEnv, defaultPort: 3005 });
+  // IMPORTANT:
+  // - 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 resolvedUrls = await resolveServerUrls({ env: baseEnv, serverPort, allowEnable: allowEnableTailscale });
+  const internalServerUrl = resolvedUrls.internalServerUrl;
+  let publicServerUrl = resolvedUrls.publicServerUrl;
+  if (stackMode && stackName !== 'main' && !resolvedUrls.envPublicUrl) {
+    const src = String(resolvedUrls.publicServerUrlSource ?? '');
+    const hasStackScopedTailscale = src.startsWith('tailscale-');
+    if (!hasStackScopedTailscale) {
+      publicServerUrl = resolvedUrls.defaultPublicUrl;
+    }
+  }
+  const uiApiUrl = resolvedUrls.defaultPublicUrl;
+  const restart = flags.has('--restart');
   const cliHomeDir = process.env.HAPPY_LOCAL_CLI_HOME_DIR?.trim()
     ? process.env.HAPPY_LOCAL_CLI_HOME_DIR.trim().replace(/^~(?=\/)/, homedir())
-    : join(getDefaultAutostartPaths().baseDir, 'cli');
+    : join(autostart.baseDir, 'cli');
 
   if (json) {
     printResult({
@@ -98,23 +130,67 @@ async function main() {
 
   const children = [];
   let shuttingDown = false;
-  const baseEnv = { ...process.env };
 
-  // Start server
-  await killPortListeners(serverPort, { label: 'server' });
-  const serverEnv = {
-    ...baseEnv,
-    PORT: String(serverPort),
-    PUBLIC_URL: publicServerUrl,
-    // Avoid noisy failures if a previous run left the metrics port busy.
-    METRICS_ENABLED: baseEnv.METRICS_ENABLED ?? 'false',
-  };
-  await ensureDepsInstalled(serverDir, serverComponentName);
-  const server = await pmSpawnScript({ label: 'server', dir: serverDir, script: 'dev', env: serverEnv });
-  children.push(server);
+  // Ensure happy-cli is install+build ready before starting the daemon.
+  // Worktrees often don't have dist/ built yet, which causes MODULE_NOT_FOUND on dist/index.mjs.
+  const buildCli = (baseEnv.HAPPY_STACKS_CLI_BUILD ?? baseEnv.HAPPY_LOCAL_CLI_BUILD ?? '1').toString().trim() !== '0';
+  await ensureDevCliReady({ cliDir, buildCli });
 
-  await waitForServerReady(internalServerUrl);
-  console.log(`[local] server ready at ${internalServerUrl}`);
+  // Watch mode (interactive only by default): rebuild happy-cli and restart daemon when code changes.
+  const watchEnabled =
+    flags.has('--watch') || (!flags.has('--no-watch') && Boolean(process.stdin.isTTY && process.stdout.isTTY));
+  const watchers = [];
+
+  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'}` : ''})`);
+    return;
+  }
+
+  if (stackMode && runtimeStatePath) {
+    await recordStackRuntimeStart(runtimeStatePath, {
+      stackName,
+      script: 'dev.mjs',
+      ephemeral,
+      ownerPid: process.pid,
+      ports: { server: serverPort },
+    }).catch(() => {});
+  }
+
+  // Start server (only if not already healthy)
+  // NOTE: In stack mode we avoid killing arbitrary port listeners (fail-closed instead).
+  if ((!serverAlreadyRunning || restart) && !stackMode) {
+    await killPortListeners(serverPort, { label: 'server' });
+  }
+
+  const { serverEnv, serverScript, serverProc } = await startDevServer({
+    serverComponentName,
+    serverDir,
+    autostart,
+    baseEnv,
+    serverPort,
+    internalServerUrl,
+    publicServerUrl,
+    envPath,
+    stackMode,
+    runtimeStatePath,
+    serverAlreadyRunning,
+    restart,
+    children,
+  });
+
+  if (!serverAlreadyRunning || restart) {
+    console.log(`[local] server ready at ${internalServerUrl}`);
+  } else {
+    console.log(`[local] server already running at ${internalServerUrl}`);
+  }
   console.log(
     `[local] tip: to run 'happy' from your terminal *against this local server* (and have sessions show up in the UI), use:\n` +
     `export HAPPY_SERVER_URL=\"${internalServerUrl}\"\n` +
@@ -122,26 +198,115 @@ async function main() {
     `export HAPPY_WEBAPP_URL=\"${publicServerUrl}\"\n`
   );
 
-  // Start daemon (detached daemon process managed by happy-cli)
-  if (startDaemon) {
-    await startLocalDaemonWithAuth({
-      cliBin,
-      cliHomeDir,
-      internalServerUrl,
-      publicServerUrl,
-      isShuttingDown: () => shuttingDown,
-    });
+  // Reliability before daemon start:
+  // - 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);
+  await prepareDaemonAuthSeed({
+    rootDir,
+    env: baseEnv,
+    stackName,
+    cliHomeDir,
+    startDaemon,
+    isInteractive,
+    serverComponentName,
+    serverDir,
+    serverEnv,
+    quiet: false,
+  });
+
+  await startDevDaemon({
+    startDaemon,
+    cliBin,
+    cliHomeDir,
+    internalServerUrl,
+    publicServerUrl,
+    restart,
+    isShuttingDown: () => shuttingDown,
+  });
+
+  const cliWatcher = watchHappyCliAndRestartDaemon({
+    enabled: watchEnabled,
+    startDaemon,
+    buildCli,
+    cliDir,
+    cliBin,
+    cliHomeDir,
+    internalServerUrl,
+    publicServerUrl,
+    isShuttingDown: () => shuttingDown,
+  });
+  if (cliWatcher) watchers.push(cliWatcher);
+
+  const serverProcRef = { current: serverProc };
+  if (stackMode && runtimeStatePath && !serverProcRef.current?.pid) {
+    // If the server was already running when we started dev, `startDevServer` won't spawn a new process
+    // (and therefore we don't have a ChildProcess handle). For safe watch/restart we need a PID.
+    const state = await readStackRuntimeStateFile(runtimeStatePath);
+    const pid = state?.processes?.serverPid;
+    if (isPidAlive(pid)) {
+      serverProcRef.current = { pid: Number(pid), exitCode: null };
+    }
+  }
+  const serverWatcher = watchDevServerAndRestart({
+    enabled: watchEnabled && Boolean(serverProcRef.current?.pid),
+    stackMode,
+    serverComponentName,
+    serverDir,
+    serverPort,
+    internalServerUrl,
+    serverScript,
+    serverEnv,
+    runtimeStatePath,
+    stackName,
+    envPath,
+    children,
+    serverProcRef,
+    isShuttingDown: () => shuttingDown,
+  });
+  if (serverWatcher) watchers.push(serverWatcher);
+  if (watchEnabled && stackMode && serverComponentName === 'happy-server' && !serverWatcher) {
+    console.warn(
+      `[local] watch: server restart is disabled because the running server PID is unknown.\n` +
+        `[local] watch: fix: re-run with --restart so Happy Stacks can (re)spawn the server and track its PID.`
+    );
   }
 
-  // Start UI (Expo web dev server)
+  const uiRes = await startDevExpoWebUi({
+    startUi,
+    uiDir,
+    autostart,
+    baseEnv,
+    apiServerUrl: uiApiUrl,
+    restart,
+    stackMode,
+    runtimeStatePath,
+    stackName,
+    envPath,
+    children,
+  });
   if (startUi) {
-    await ensureDepsInstalled(uiDir, 'happy');
-    const uiEnv = { ...baseEnv };
-    delete uiEnv.CI;
-    uiEnv.EXPO_PUBLIC_HAPPY_SERVER_URL = publicServerUrl;
-    uiEnv.EXPO_PUBLIC_DEBUG = uiEnv.EXPO_PUBLIC_DEBUG ?? '1';
-    const ui = await pmSpawnScript({ label: 'ui', dir: uiDir, script: 'web', env: uiEnv });
-    children.push(ui);
+    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') {
+      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);
+    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);
+      if (!res.ok) {
+        console.warn(`[local] ui: failed to open browser automatically (${res.error}).`);
+      }
+    }
   }
 
   const shutdown = async () => {
@@ -151,6 +316,14 @@ async function main() {
     shuttingDown = true;
     console.log('\n[local] shutting down...');
 
+    for (const w of watchers) {
+      try {
+        w.close();
+      } catch {
+        // ignore
+      }
+    }
+
     if (startDaemon) {
       await stopLocalDaemon({ cliBin, internalServerUrl, cliHomeDir });
     }

package/scripts/doctor.mjs

@@ -1,19 +1,21 @@
 import './utils/env.mjs';
-import { parseArgs } from './utils/args.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 { daemonStatusSummary } from './daemon.mjs';
-import { tailscaleServeStatus, resolvePublicServerUrl } from './tailscale.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.mjs';
+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';
 
 /**
  * Doctor script for common happy-stacks failure modes.
@@ -115,27 +117,23 @@ async function main() {
   const runtimeVersion = await readPkgVersion(runtimePkgJson);
   const updateCache = existsSync(updateCachePath) ? await readJsonSafe(updateCachePath) : null;
 
-  const serverPort = process.env.HAPPY_LOCAL_SERVER_PORT?.trim() ? Number(process.env.HAPPY_LOCAL_SERVER_PORT) : 3005;
-  const internalServerUrl = `http://127.0.0.1:${serverPort}`;
+  const autostart = getDefaultAutostartPaths();
+  const stackCtx = resolveStackContext({ env: process.env, autostart });
+  const stackMode = stackCtx.stackMode;
 
-  const defaultPublicUrl = `http://localhost:${serverPort}`;
-  const envPublicUrl = process.env.HAPPY_LOCAL_SERVER_URL?.trim() ? process.env.HAPPY_LOCAL_SERVER_URL.trim() : '';
-  const resolved = await resolvePublicServerUrl({
-    internalServerUrl,
-    defaultPublicUrl,
-    envPublicUrl,
-    allowEnable: false,
-  });
-  const publicServerUrl = resolved.publicServerUrl;
+  const serverPort = resolveServerPortFromEnv({ defaultPort: 3005 });
+  const resolvedUrls = await resolveServerUrls({ serverPort, allowEnable: false });
+  const internalServerUrl = resolvedUrls.internalServerUrl;
+  const publicServerUrl = resolvedUrls.publicServerUrl;
 
   const cliHomeDir = process.env.HAPPY_LOCAL_CLI_HOME_DIR?.trim()
     ? process.env.HAPPY_LOCAL_CLI_HOME_DIR.trim().replace(/^~(?=\/)/, homedir())
-    : join(getDefaultAutostartPaths().baseDir, 'cli');
+    : join(autostart.baseDir, 'cli');
 
   const serveUi = (process.env.HAPPY_LOCAL_SERVE_UI ?? '1') !== '0';
   const uiBuildDir = process.env.HAPPY_LOCAL_UI_BUILD_DIR?.trim()
     ? process.env.HAPPY_LOCAL_UI_BUILD_DIR.trim()
-    : join(getDefaultAutostartPaths().baseDir, 'ui');
+    : join(autostart.baseDir, 'ui');
 
   const serverComponentName = getServerComponentName({ kv });
   if (serverComponentName === 'both') {
@@ -206,8 +204,15 @@ async function main() {
     report.checks.serverHealth = { ok: false };
     if (!json) console.log(`❌ server health: unreachable (${internalServerUrl})`);
     if (fix) {
-      if (!json) console.log(`↪ attempting fix: freeing tcp:${serverPort}`);
-      await killPortListeners(serverPort, { label: 'doctor' });
+      if (stackMode) {
+        if (!json) {
+          console.log(`↪ fix skipped: refusing to kill unknown port listeners in stack mode.`);
+          console.log(`↪ Fix: use stack-safe controls instead: happys stack stop ${process.env.HAPPY_STACKS_STACK ?? process.env.HAPPY_LOCAL_STACK ?? 'main'} --aggressive`);
+        }
+      } else {
+        if (!json) console.log(`↪ attempting fix: freeing tcp:${serverPort}`);
+        await killPortListeners(serverPort, { label: 'doctor' });
+      }
     }
   }
 
@@ -304,7 +309,7 @@ async function main() {
     }
   } catch {
     report.checks.happyOnPath = { ok: false };
-    if (!json) console.log('ℹ️ happy on PATH: not found (run: happys init --install-path, or add ~/.happy-stacks/bin to PATH)');
+    if (!json) console.log(`ℹ️ happy on PATH: not found (run: happys init --install-path, or add ${join(getHappyStacksHomeDir(), 'bin')} to PATH)`);
   }
 
   // happys on PATH
@@ -316,7 +321,7 @@ async function main() {
     }
   } catch {
     report.checks.happysOnPath = { ok: false };
-    if (!json) console.log('ℹ️ happys on PATH: not found (run: happys init --install-path, or add ~/.happy-stacks/bin to PATH)');
+    if (!json) console.log(`ℹ️ happys on PATH: not found (run: happys init --install-path, or add ${join(getHappyStacksHomeDir(), 'bin')} to PATH)`);
   }
 
   if (!json) {
@@ -326,7 +331,7 @@ async function main() {
       console.log('- Install a stable runtime (recommended for SwiftBar/services): happys self update');
     }
     if (!report.checks.happysOnPath?.ok) {
-      console.log('- Add shims to PATH: export PATH="$HOME/.happy-stacks/bin:$PATH" (or: happys init --install-path)');
+      console.log(`- Add shims to PATH: export PATH="${join(getHappyStacksHomeDir(), 'bin')}:$PATH" (or: happys init --install-path)`);
     }
     console.log('');
   }