happy-stacks 0.1.0 → 0.2.0

package/scripts/run.mjs

@@ -1,18 +1,25 @@
 import './utils/env.mjs';
-import { parseArgs } from './utils/args.mjs';
+import { parseArgs } from './utils/cli/args.mjs';
 import { pathExists } from './utils/fs.mjs';
-import { killProcessTree, runCapture } from './utils/proc.mjs';
+import { killProcessTree, runCapture, spawnProc } 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 { pmSpawnScript, requireDir } from './utils/pm.mjs';
+import { getServerComponentName, isHappyServerRunning, waitForServerReady } from './utils/server.mjs';
+import { ensureCliBuilt, ensureDepsInstalled, pmExecBin, pmSpawnScript, requireDir } from './utils/pm.mjs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
-import { maybeResetTailscaleServe, resolvePublicServerUrl } from './tailscale.mjs';
-import { startLocalDaemonWithAuth, stopLocalDaemon } from './daemon.mjs';
-import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
-import { assertServerComponentDirMatches } from './utils/validate.mjs';
+import { maybeResetTailscaleServe } from './tailscale.mjs';
+import { isDaemonRunning, startLocalDaemonWithAuth, stopLocalDaemon } from './daemon.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { assertServerComponentDirMatches, assertServerPrismaProviderMatches } from './utils/validate.mjs';
+import { applyHappyServerMigrations, ensureHappyServerManagedInfra } from './utils/happy_server_infra.mjs';
+import { getAccountCountForServerComponent, prepareDaemonAuthSeedIfNeeded } 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/localhost_host.mjs';
+import { openUrlInBrowser } from './utils/browser.mjs';
 
 /**
  * Run the local stack in "production-like" mode:
@@ -30,10 +37,10 @@ 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', '--no-browser'], json: true },
       text: [
         '[start] usage:',
-        '  happys start [--server=happy-server|happy-server-light] [--json]',
+        '  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.',
       ].join('\n'),
@@ -43,17 +50,14 @@ 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 serverPort = resolveServerPortFromEnv({ defaultPort: 3005 });
 
   // Internal URL used by local processes on this machine.
   const internalServerUrl = `http://127.0.0.1:${serverPort}`;
   // Public URL is what you might share/open (e.g. https://<machine>.<tailnet>.ts.net).
   // We auto-prefer the Tailscale HTTPS URL when available, unless explicitly overridden.
-  const defaultPublicUrl = `http://localhost:${serverPort}`;
-  const envPublicUrl = process.env.HAPPY_LOCAL_SERVER_URL?.trim() ? process.env.HAPPY_LOCAL_SERVER_URL.trim() : '';
-  let publicServerUrl = envPublicUrl || defaultPublicUrl;
+  const { defaultPublicUrl, envPublicUrl, publicServerUrl: publicServerUrlPreview } = getPublicServerUrlEnvOverride({ serverPort });
+  let publicServerUrl = publicServerUrlPreview;
 
   const serverComponentName = getServerComponentName({ kv });
   if (serverComponentName === 'both') {
@@ -62,11 +66,13 @@ 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 && serverComponentName === 'happy-server-light';
+  const serveUi = serveUiWanted;
+  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();
   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 enableTailscaleServe = (process.env.HAPPY_LOCAL_TAILSCALE_SERVE ?? '0') === '1';
 
@@ -74,6 +80,7 @@ async function main() {
   const cliDir = getComponentDir(rootDir, 'happy-cli');
 
   assertServerComponentDirMatches({ rootDir, serverComponentName, serverDir });
+  assertServerPrismaProviderMatches({ serverComponentName, serverDir });
 
   await requireDir(serverComponentName, serverDir);
   await requireDir('happy-cli', cliDir);
@@ -82,7 +89,8 @@ async function main() {
 
   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 restart = flags.has('--restart');
 
   if (json) {
     printResult({
@@ -105,30 +113,65 @@ async function main() {
     return;
   }
 
-  if (serveUiWanted && !serveUi) {
-    console.log(`[local] ui serving disabled (requires happy-server-light; you are using ${serverComponentName})`);
-  }
-
   if (serveUi && !(await pathExists(uiBuildDir))) {
-    throw new Error(`[local] UI build directory not found at ${uiBuildDir}. Run: happys build (legacy in a cloned repo: pnpm build)`);
+    if (serverComponentName === 'happy-server-light') {
+      throw new Error(`[local] UI build directory not found at ${uiBuildDir}. Run: happys build (legacy in a cloned repo: pnpm build)`);
+    }
+    // For happy-server, UI serving is optional via the UI gateway.
+    console.log(`[local] UI build directory not found at ${uiBuildDir}; UI gateway will be disabled`);
   }
 
   const children = [];
   let shuttingDown = false;
   const baseEnv = { ...process.env };
+  const stackCtx = resolveStackContext({ env: baseEnv, autostart });
+  const { stackMode, runtimeStatePath, stackName, 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';
+  await ensureCliBuilt(cliDir, { buildCli });
+
+  // Ensure server deps exist before any Prisma/docker work.
+  await ensureDepsInstalled(serverDir, serverComponentName);
+
+  // 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 resolvedUrls = await resolveServerUrls({ env: baseEnv, serverPort, allowEnable: allowEnableTailscale });
+  if (stackMode && stackName !== 'main' && !resolvedUrls.envPublicUrl) {
+    const src = String(resolvedUrls.publicServerUrlSource ?? '');
+    const hasStackScopedTailscale = src.startsWith('tailscale-');
+    publicServerUrl = hasStackScopedTailscale ? resolvedUrls.publicServerUrl : resolvedUrls.defaultPublicUrl;
+  } else {
+    publicServerUrl = resolvedUrls.publicServerUrl;
+  }
 
-  // Public URL automation: auto-prefer https://*.ts.net on every start.
-  const resolved = await resolvePublicServerUrl({
-    internalServerUrl,
-    defaultPublicUrl,
-    envPublicUrl,
-    allowEnable: true,
-  });
-  publicServerUrl = resolved.publicServerUrl;
+  const serverAlreadyRunning = await isHappyServerRunning(internalServerUrl);
+  const daemonAlreadyRunning = startDaemon ? isDaemonRunning(cliHomeDir) : false;
+  if (!restart && serverAlreadyRunning && (!startDaemon || daemonAlreadyRunning)) {
+    console.log(`[local] start: stack already running (server=${internalServerUrl}${startDaemon ? ` daemon=${daemonAlreadyRunning ? 'running' : 'stopped'}` : ''})`);
+    return;
+  }
+
+  // Stack runtime state (stack-scoped commands only): record the runner PID + chosen ports so stop/restart never kills other stacks.
+  if (stackMode && runtimeStatePath) {
+    await recordStackRuntimeStart(runtimeStatePath, {
+      stackName,
+      script: 'run.mjs',
+      ephemeral,
+      ownerPid: process.pid,
+      ports: { server: serverPort },
+    }).catch(() => {});
+  }
 
   // Server
   // If a previous run left a server behind, free the port first (prevents false "ready" checks).
-  await killPortListeners(serverPort, { label: 'server' });
+  // NOTE: In stack mode we avoid killing arbitrary port listeners (fail-closed instead).
+  if ((!serverAlreadyRunning || restart) && !stackMode) {
+    await killPortListeners(serverPort, { label: 'server' });
+  }
 
   const serverEnv = {
     ...baseEnv,
@@ -138,19 +181,120 @@ async function main() {
     // Avoid noisy failures if a previous run left the metrics port busy.
     // You can override with METRICS_ENABLED=true if you want it.
     METRICS_ENABLED: baseEnv.METRICS_ENABLED ?? 'false',
-    ...(serveUi
+    ...(serveUi && serverComponentName === 'happy-server-light'
       ? {
           HAPPY_SERVER_LIGHT_UI_DIR: uiBuildDir,
           HAPPY_SERVER_LIGHT_UI_PREFIX: uiPrefix,
         }
       : {}),
   };
+  let serverLightAccountCount = null;
+  let happyServerAccountCount = null;
+  if (serverComponentName === 'happy-server-light') {
+    const dataDir = baseEnv.HAPPY_SERVER_LIGHT_DATA_DIR?.trim()
+      ? baseEnv.HAPPY_SERVER_LIGHT_DATA_DIR.trim()
+      : join(autostart.baseDir, 'server-light');
+    serverEnv.HAPPY_SERVER_LIGHT_DATA_DIR = dataDir;
+    serverEnv.HAPPY_SERVER_LIGHT_FILES_DIR = baseEnv.HAPPY_SERVER_LIGHT_FILES_DIR?.trim()
+      ? baseEnv.HAPPY_SERVER_LIGHT_FILES_DIR.trim()
+      : join(dataDir, 'files');
+    serverEnv.DATABASE_URL = baseEnv.DATABASE_URL?.trim()
+      ? baseEnv.DATABASE_URL.trim()
+      : `file:${join(dataDir, 'happy-server-light.sqlite')}`;
+
+    // Reliability: ensure DB schema exists before daemon hits /v1/machines (health checks don't cover DB readiness).
+    const acct = await getAccountCountForServerComponent({
+      serverComponentName,
+      serverDir,
+      env: serverEnv,
+      bestEffort: false,
+    });
+    serverLightAccountCount = typeof acct.accountCount === 'number' ? acct.accountCount : null;
+  }
+  let effectiveInternalServerUrl = internalServerUrl;
+  if (serverComponentName === 'happy-server') {
+    const managed = (baseEnv.HAPPY_STACKS_MANAGED_INFRA ?? baseEnv.HAPPY_LOCAL_MANAGED_INFRA ?? '1') !== '0';
+    if (managed) {
+      const envPath = baseEnv.HAPPY_STACKS_ENV_FILE ?? baseEnv.HAPPY_LOCAL_ENV_FILE ?? '';
+      const infra = await ensureHappyServerManagedInfra({
+        stackName: autostart.stackName,
+        baseDir: autostart.baseDir,
+        serverPort,
+        publicServerUrl,
+        envPath,
+        env: baseEnv,
+      });
+
+      // Backend runs on a separate port; gateway owns the public port.
+      const backendPortRaw = (baseEnv.HAPPY_STACKS_HAPPY_SERVER_BACKEND_PORT ?? baseEnv.HAPPY_LOCAL_HAPPY_SERVER_BACKEND_PORT ?? '').trim();
+      const backendPort = backendPortRaw ? Number(backendPortRaw) : serverPort + 10;
+      const backendUrl = `http://127.0.0.1:${backendPort}`;
+      if (!stackMode) {
+        await killPortListeners(backendPort, { label: 'happy-server-backend' });
+      }
+
+      const backendEnv = { ...serverEnv, ...infra.env, PORT: String(backendPort) };
+      const autoMigrate = (baseEnv.HAPPY_STACKS_PRISMA_MIGRATE ?? baseEnv.HAPPY_LOCAL_PRISMA_MIGRATE ?? '1') !== '0';
+      if (autoMigrate) {
+        await applyHappyServerMigrations({ serverDir, env: backendEnv });
+      }
+      // Account probe should use the *actual* DATABASE_URL/infra env (ephemeral stacks do not persist it in env files).
+      const acct = await getAccountCountForServerComponent({
+        serverComponentName,
+        serverDir,
+        env: backendEnv,
+        bestEffort: true,
+      });
+      happyServerAccountCount = typeof acct.accountCount === 'number' ? acct.accountCount : null;
+
+      const backend = await pmSpawnScript({ label: 'server', dir: serverDir, script: 'start', env: backendEnv });
+      children.push(backend);
+      if (stackMode && runtimeStatePath) {
+        await recordStackRuntimeUpdate(runtimeStatePath, {
+          ports: { server: serverPort, backend: backendPort },
+          processes: { happyServerBackendPid: backend.pid },
+        }).catch(() => {});
+      }
+      await waitForServerReady(backendUrl);
+
+      const gatewayArgs = [
+        join(rootDir, 'scripts', 'ui_gateway.mjs'),
+        `--port=${serverPort}`,
+        `--backend-url=${backendUrl}`,
+        `--minio-port=${infra.env.S3_PORT}`,
+        `--bucket=${infra.env.S3_BUCKET}`,
+      ];
+      if (serveUi && (await pathExists(uiBuildDir))) {
+        gatewayArgs.push(`--ui-dir=${uiBuildDir}`);
+      } else {
+        gatewayArgs.push('--no-ui');
+      }
 
-  const server = await pmSpawnScript({ label: 'server', dir: serverDir, script: 'dev', env: serverEnv });
-  children.push(server);
+      const gateway = spawnProc('ui', process.execPath, gatewayArgs, { ...backendEnv, PORT: String(serverPort) }, { cwd: rootDir });
+      children.push(gateway);
+      if (stackMode && runtimeStatePath) {
+        await recordStackRuntimeUpdate(runtimeStatePath, { processes: { uiGatewayPid: gateway.pid } }).catch(() => {});
+      }
+      await waitForServerReady(internalServerUrl);
+      effectiveInternalServerUrl = internalServerUrl;
 
-  await waitForServerReady(internalServerUrl);
-  console.log(`[local] server ready at ${internalServerUrl}`);
+      // Skip default server spawn below
+    }
+  }
+
+  // Default server start (happy-server-light, or happy-server without managed infra).
+  if (!(serverComponentName === 'happy-server' && (baseEnv.HAPPY_STACKS_MANAGED_INFRA ?? baseEnv.HAPPY_LOCAL_MANAGED_INFRA ?? '1') !== '0')) {
+    if (!serverAlreadyRunning || restart) {
+      const server = await pmSpawnScript({ label: 'server', dir: serverDir, script: 'start', env: serverEnv });
+      children.push(server);
+      if (stackMode && runtimeStatePath) {
+        await recordStackRuntimeUpdate(runtimeStatePath, { processes: { serverPid: server.pid } }).catch(() => {});
+      }
+      await waitForServerReady(internalServerUrl);
+    } else {
+      console.log(`[local] server already running at ${internalServerUrl}`);
+    }
+  }
 
   if (enableTailscaleServe) {
     try {
@@ -167,9 +311,9 @@ async function main() {
   }
 
   if (serveUi) {
-    const localUi = internalServerUrl.replace(/\/+$/, '') + '/';
+    const localUi = effectiveInternalServerUrl.replace(/\/+$/, '') + '/';
     console.log(`[local] ui served locally at ${localUi}`);
-    if (publicServerUrl && publicServerUrl !== internalServerUrl && publicServerUrl !== localUi && publicServerUrl !== defaultPublicUrl) {
+    if (publicServerUrl && publicServerUrl !== effectiveInternalServerUrl && publicServerUrl !== localUi && publicServerUrl !== defaultPublicUrl) {
       const pubUi = publicServerUrl.replace(/\/+$/, '') + '/';
       console.log(`[local] public url: ${pubUi}`);
     }
@@ -179,20 +323,55 @@ async function main() {
 
     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` +
+      `export HAPPY_SERVER_URL=\"${effectiveInternalServerUrl}\"\n` +
       `export HAPPY_HOME_DIR=\"${cliHomeDir}\"\n` +
       `export HAPPY_WEBAPP_URL=\"${publicServerUrl}\"\n`
     );
+
+    // 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 res = await openUrlInBrowser(openUrl);
+      if (!res.ok) {
+        console.warn(`[local] ui: failed to open browser automatically (${res.error}).`);
+      }
+    }
   }
 
   // Daemon
   if (startDaemon) {
+    const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    if (serverComponentName === 'happy-server' && happyServerAccountCount == null) {
+      const acct = await getAccountCountForServerComponent({
+        serverComponentName,
+        serverDir,
+        env: serverEnv,
+        bestEffort: true,
+      });
+      happyServerAccountCount = typeof acct.accountCount === 'number' ? acct.accountCount : null;
+    }
+    const accountCount =
+      serverComponentName === 'happy-server-light' ? serverLightAccountCount : happyServerAccountCount;
+    await prepareDaemonAuthSeedIfNeeded({
+      rootDir,
+      env: baseEnv,
+      stackName: autostart.stackName,
+      cliHomeDir,
+      startDaemon,
+      isInteractive,
+      accountCount,
+      quiet: false,
+    });
     await startLocalDaemonWithAuth({
       cliBin,
       cliHomeDir,
-      internalServerUrl,
+      internalServerUrl: effectiveInternalServerUrl,
       publicServerUrl,
       isShuttingDown: () => shuttingDown,
+      forceRestart: restart,
     });
   }
 
@@ -204,7 +383,7 @@ async function main() {
     console.log('\n[local] shutting down...');
 
     if (startDaemon) {
-      await stopLocalDaemon({ cliBin, internalServerUrl, cliHomeDir });
+        await stopLocalDaemon({ cliBin, internalServerUrl: effectiveInternalServerUrl, cliHomeDir });
     }
 
     for (const child of children) {

package/scripts/self.mjs

@@ -2,20 +2,16 @@ import './utils/env.mjs';
 
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-import { parseArgs } from './utils/args.mjs';
+import { parseArgs } from './utils/cli/args.mjs';
 import { pathExists } from './utils/fs.mjs';
 import { run, runCapture } from './utils/proc.mjs';
+import { expandHome } from './utils/canonical_home.mjs';
 import { getHappyStacksHomeDir, getRootDir } from './utils/paths.mjs';
-import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
 import { getRuntimeDir } from './utils/runtime.mjs';
 
-function expandHome(p) {
-  return p.replace(/^~(?=\/)/, homedir());
-}
-
 function cachePaths() {
   const home = getHappyStacksHomeDir();
   return {

package/scripts/server_flavor.mjs

@@ -1,10 +1,10 @@
 import './utils/env.mjs';
-import { parseArgs } from './utils/args.mjs';
+import { parseArgs } from './utils/cli/args.mjs';
 import { getRootDir } from './utils/paths.mjs';
 import { ensureEnvFileUpdated } from './utils/env_file.mjs';
 import { resolveUserConfigEnvPath } from './utils/config.mjs';
-import { isTty, promptSelect, withRl } from './utils/wizard.mjs';
-import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+import { isTty, promptSelect, withRl } from './utils/cli/wizard.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
 
 const FLAVORS = [
   { label: 'happy-server-light (recommended default, serves UI)', value: 'happy-server-light' },