@happier-dev/stack 0.1.0-preview.9.1 → 0.1.0

package/scripts/tui.mjs

@@ -9,12 +9,31 @@ import { getComponentDir, getRepoDir, getRootDir, resolveStackEnvPath } from './
 import { getStackRuntimeStatePath, readStackRuntimeStateFile } from './utils/stack/runtime_state.mjs';
 import { getEnvValueAny } from './utils/env/values.mjs';
 import { padRight, parsePrefixedLabel, stripAnsi } from './utils/ui/text.mjs';
+import { formatBoxLine } from './utils/ui/box_line.mjs';
 import { commandExists } from './utils/proc/commands.mjs';
 import { renderQrAscii } from './utils/ui/qr.mjs';
 import { resolveMobileQrPayload } from './utils/mobile/dev_client_links.mjs';
 import { worktreeSpecFromDir } from './utils/git/worktrees.mjs';
 import { stopStackForTuiExit } from './utils/tui/cleanup.mjs';
+import {
+  inferTuiStackName,
+  isTuiHelpRequest,
+  isTuiRestartableForwardedArgs,
+  isTuiStartLikeForwardedArgs,
+  normalizeTuiForwardedArgs,
+} from './utils/tui/args.mjs';
 import { terminateProcessGroup } from './utils/proc/terminate.mjs';
+import { getInvokedCwd, inferComponentFromCwd } from './utils/cli/cwd_scope.mjs';
+import { mergeEnvForTuiSummary } from './utils/tui/summary_env.mjs';
+import { hasStackCredentials } from './utils/auth/daemon_gate.mjs';
+import { applyTuiStackAuthScopeEnv } from './utils/tui/stack_scope_env.mjs';
+import { buildDaemonAuthNotice, parseStartDaemonFlagFromEnv } from './utils/tui/daemon_auth_notice.mjs';
+import { detachTuiStdinForChild, waitForEnter } from './utils/tui/stdin_handoff.mjs';
+import { waitForHappierHealthOk } from './utils/server/server.mjs';
+import { buildTuiAuthArgs, buildTuiDaemonStartArgs, shouldHoldAfterAuthExit } from './utils/tui/actions.mjs';
+import { shouldAttemptTuiDaemonAutostart } from './utils/tui/daemon_autostart.mjs';
+import { reconcileDaemonPaneAfterDaemonStarts } from './utils/tui/daemon_pane_reconcile.mjs';
+import { buildScriptPtyArgs } from './utils/tui/script_pty_command.mjs';
 
 function nowTs() {
   const d = new Date();
@@ -32,10 +51,34 @@ function cyan(s) {
   return supportsAnsi() ? `\x1b[36m${s}\x1b[0m` : String(s);
 }
 
+function redBold(s) {
+  return supportsAnsi() ? `\x1b[1;31m${s}\x1b[0m` : String(s);
+}
+
+function yellowBold(s) {
+  return supportsAnsi() ? `\x1b[1;33m${s}\x1b[0m` : String(s);
+}
+
+function greenBold(s) {
+  return supportsAnsi() ? `\x1b[1;32m${s}\x1b[0m` : String(s);
+}
+
 function clamp(n, lo, hi) {
   return Math.max(lo, Math.min(hi, n));
 }
 
+function styleDaemonNoticeLines(lines) {
+  const raw = Array.isArray(lines) ? lines : [];
+  return raw.map((line) => {
+    const s = String(line ?? '');
+    if (s.toLowerCase().includes('sign-in required')) return yellowBold(s);
+    if (s.startsWith('Without daemon sign-in')) return yellowBold(s);
+    if (s.startsWith('press "a"')) return greenBold(s);
+    if (s.startsWith('action: press "a"')) return greenBold(s);
+    return s;
+  });
+}
+
 function mkPane(id, title, { visible = true, kind = 'log' } = {}) {
   return { id, title, kind, visible, lines: [], scroll: 0 };
 }
@@ -53,7 +96,7 @@ function getPaneHeightForLines(lines, { min = 3, max = 16 } = {}) {
   return clamp(n + 2, min, max);
 }
 
-function drawBox({ x, y, w, h, title, lines, scroll, active = false }) {
+function drawBox({ x, y, w, h, title, lines, scroll, active = false, allowAnsi = false }) {
   const top = y;
   const bottom = y + h - 1;
   const left = x;
@@ -93,35 +136,32 @@ function drawBox({ x, y, w, h, title, lines, scroll, active = false }) {
   const start = Math.max(0, lines.length - innerH - s);
   const slice = lines.slice(start, start + innerH);
   for (let i = 0; i < innerH; i++) {
-    const line = stripAnsi(slice[i] ?? '');
-    out.push({ row: top + 1 + i, col: left + 1, text: padRight(line, innerW) });
+    const raw = slice[i] ?? '';
+    const formatted = formatBoxLine({
+      text: raw,
+      width: innerW,
+      allowAnsi: Boolean(allowAnsi && supportsAnsi()),
+    });
+    out.push({ row: top + 1 + i, col: left + 1, text: formatted });
   }
 
   return { out, maxScroll };
 }
 
-function isTuiHelp(argv) {
-  if (!argv.length) return true;
-  if (argv.length === 1 && (argv[0] === '--help' || argv[0] === 'help')) return true;
-  return false;
-}
-
-function inferStackNameFromForwardedArgs(args) {
-  // Primary: stack-scoped usage: `hstack tui stack <subcmd> <name> ...`
-  const i = args.indexOf('stack');
-  if (i >= 0) {
-    const name = args[i + 2];
-    if (name && !name.startsWith('-')) return name;
+function resolveStacklessSummaryEnv({ rootDir }) {
+  const invokedCwd = getInvokedCwd(process.env);
+  const inferred = inferComponentFromCwd({
+    rootDir,
+    invokedCwd,
+    components: ['happier-ui', 'happier-cli', 'happier-server-light', 'happier-server'],
+  });
+  if (!inferred?.repoDir) {
+    return { env: process.env, invokedCwd };
   }
-  // Fallback: use current environment stack (or main).
-  return (process.env.HAPPIER_STACK_STACK ?? '').trim() || 'main';
-}
-
-function isStackStartLikeForwardedArgs(args) {
-  const i = args.indexOf('stack');
-  if (i < 0) return false;
-  const subcmd = (args[i + 1] ?? '').toString().trim();
-  return subcmd === 'dev' || subcmd === 'start';
+  return {
+    env: { ...process.env, HAPPIER_STACK_REPO_DIR: inferred.repoDir },
+    invokedCwd,
+  };
 }
 
 const readEnvObject = readEnvObjectFromFile;
@@ -228,8 +268,49 @@ function formatRepoRef({ rootDir, dir }) {
 }
 
 async function buildStackSummaryLines({ rootDir, stackName }) {
+  if (!stackName) {
+    const { env, invokedCwd } = resolveStacklessSummaryEnv({ rootDir });
+    const serverComponent =
+      getEnvValueAny(env, ['HAPPIER_STACK_SERVER_COMPONENT']) || 'happier-server-light';
+
+    const lines = [];
+    lines.push('stack: (stackless)');
+    lines.push(`server: ${serverComponent}`);
+    lines.push(`invokedCwd: ${invokedCwd}`);
+    lines.push('runtime: (stackless)');
+
+    lines.push('');
+    lines.push('ports:');
+    lines.push('  server: (stackless)');
+
+    lines.push('');
+    lines.push('pids:');
+
+    lines.push('');
+    lines.push('dirs:');
+    const repoRoot = getRepoDir(rootDir, env);
+    lines.push(`  ${padRight('repo', 16)} ${formatRepoRef({ rootDir, dir: repoRoot })}`);
+    const uiDir = getComponentDir(rootDir, 'happier-ui', env);
+    const cliDir = getComponentDir(rootDir, 'happier-cli', env);
+    const serverDir = getComponentDir(rootDir, serverComponent, env);
+    const relOrAbs = (absPath) => {
+      const p = resolve(String(absPath ?? '').trim());
+      const repo = resolve(String(repoRoot ?? '').trim());
+      if (!repo) return p;
+      const prefix = repo.endsWith(sep) ? repo : repo + sep;
+      return p === repo ? '.' : p.startsWith(prefix) ? p.slice(prefix.length) : p;
+    };
+    lines.push(`  ${padRight('ui', 16)} ${relOrAbs(uiDir)}`);
+    lines.push(`  ${padRight('cli', 16)} ${relOrAbs(cliDir)}`);
+    lines.push(`  ${padRight('server', 16)} ${relOrAbs(serverDir)}`);
+
+    return lines;
+  }
+
   const { envPath, baseDir } = resolveStackEnvPath(stackName);
-  const env = await readEnvObject(envPath);
+  const envFromFile = await readEnvObject(envPath);
+  const env = mergeEnvForTuiSummary({ stackEnvFromFile: envFromFile, processEnv: process.env });
+  const authScopeEnv = applyTuiStackAuthScopeEnv({ env, stackName });
   const runtimePath = getStackRuntimeStatePath(stackName);
   const runtime = await readStackRuntimeStateFile(runtimePath);
 
@@ -242,6 +323,15 @@ async function buildStackSummaryLines({ rootDir, stackName }) {
   const expoDevClientEnabled = Boolean(expo?.devClientEnabled);
   const processes = runtime?.processes && typeof runtime.processes === 'object' ? runtime.processes : {};
 
+  const serverPort = Number(ports?.server);
+  const internalServerUrl =
+    Number.isFinite(serverPort) && serverPort > 0 ? `http://127.0.0.1:${serverPort}` : '';
+  const cliHomeDir = join(baseDir, 'cli');
+  const authed = internalServerUrl
+    ? hasStackCredentials({ cliHomeDir, serverUrl: internalServerUrl, env: authScopeEnv })
+    : hasStackCredentials({ cliHomeDir, serverUrl: '', env: authScopeEnv });
+  const startDaemon = parseStartDaemonFlagFromEnv(env);
+
   const lines = [];
   lines.push(`stack: ${stackName}`);
   lines.push(`server: ${serverComponent}`);
@@ -252,6 +342,19 @@ async function buildStackSummaryLines({ rootDir, stackName }) {
   if (runtime?.updatedAt) lines.push(`updatedAt: ${runtime.updatedAt}`);
   if (runtime?.ownerPid) lines.push(`ownerPid: ${runtime.ownerPid}`);
 
+  // Make daemon auth issues obvious even if the user never focuses the daemon pane.
+  const notice = buildDaemonAuthNotice({
+    stackName,
+    internalServerUrl,
+    daemonPid: processes?.daemonPid ?? null,
+    authed,
+    startDaemon,
+  });
+  if (notice.show) {
+    lines.push('');
+    for (const l of styleDaemonNoticeLines(notice.summaryLines)) lines.push(l);
+  }
+
   lines.push('');
   lines.push('ports:');
   lines.push(`  server: ${ports?.server ?? '(unknown)'}`);
@@ -296,6 +399,9 @@ async function buildStackSummaryLines({ rootDir, stackName }) {
 }
 
 async function buildExpoQrPaneLines({ stackName }) {
+  if (!stackName) {
+    return { visible: false, lines: [] };
+  }
   const runtimePath = getStackRuntimeStatePath(stackName);
   const runtime = await readStackRuntimeStateFile(runtimePath);
   const expo = runtime?.expo && typeof runtime.expo === 'object' ? runtime.expo : {};
@@ -319,15 +425,19 @@ async function buildExpoQrPaneLines({ stackName }) {
 }
 
 async function main() {
-  const argv = process.argv.slice(2);
+  const argvRaw = process.argv.slice(2);
+  const argv = normalizeTuiForwardedArgs(argvRaw);
 
-  if (isTuiHelp(argv)) {
+  if (isTuiHelpRequest(argvRaw)) {
     printResult({
       json: false,
-      data: { usage: 'hstack tui <hstack args...>', json: false },
+      data: { usage: 'hstack tui [<hstack args...>]', json: false, defaultCommand: 'dev' },
       text: [
         '[tui] usage:',
-        '  hstack tui <hstack args...>',
+        '  hstack tui [<hstack args...>]',
+        '',
+        'defaults:',
+        '  hstack tui                 => hstack tui dev',
         '',
         'examples:',
         '  hstack tui stack dev resume-upstream',
@@ -348,6 +458,9 @@ async function main() {
         '  p               : pause/resume rendering',
         '  ↑/↓, PgUp/PgDn   : scroll focused pane',
         '  Home/End        : jump bottom/top (focused pane)',
+        '  a               : run stack auth login (when stack context exists)',
+        '  A               : run stack auth login --force',
+        '  r               : restart stack processes (dev/start only)',
         '  q / Ctrl+C      : quit (sends SIGINT to child)',
         '',
         'panes (default):',
@@ -365,12 +478,13 @@ async function main() {
   const happysBin = join(rootDir, 'bin', 'hstack.mjs');
   const forwarded = argv;
 
-  const stackName = inferStackNameFromForwardedArgs(forwarded);
-  const { envPath: stackEnvPath } = resolveStackEnvPath(stackName);
+  const stackName = inferTuiStackName(forwarded, process.env);
+  const stackEnvPath = stackName ? resolveStackEnvPath(stackName).envPath : null;
+  const summaryTitle = stackName ? `stack summary (${stackName})` : 'session summary (stackless)';
 
   const panes = [
     mkPane('orch', 'orchestration', { visible: true, kind: 'log' }),
-    mkPane('summary', `stack summary (${stackName})`, { visible: true, kind: 'summary' }),
+    mkPane('summary', summaryTitle, { visible: true, kind: 'summary' }),
     // Data-only pane: we render QR inside the Expo pane (no separate box).
     mkPane('qr', 'expo QR', { visible: false, kind: 'qr' }),
     mkPane('local', 'local', { visible: true, kind: 'log' }),
@@ -415,6 +529,9 @@ async function main() {
   let focused = paneIndexById.get('local'); // default focus
   let paused = false;
   let renderScheduled = false;
+  let sawDaemonAuthRequired = false;
+  let daemonAutostartInProgress = false;
+  let daemonAutostartLastAttemptAtMs = 0;
 
   const wantsPty = process.platform !== 'win32' && (await commandExists('script', { cwd: rootDir }));
   // In TUI mode, we intentionally do not forward keyboard input to the child process (stdin is ignored),
@@ -426,54 +543,69 @@ async function main() {
     // Avoid Corepack mutating package.json automatically.
     COREPACK_ENABLE_AUTO_PIN: '0',
   };
-  const child = wantsPty
-    ? // Use a pseudo-terminal so tools like Expo print QR/status output that they hide in non-TTY mode.
-      // `script` is available by default on macOS (and common on Linux).
-      spawn('script', ['-q', '/dev/null', process.execPath, happysBin, ...forwarded], {
-        cwd: rootDir,
-        env: childEnv,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        detached: process.platform !== 'win32',
-      })
-    : spawn(process.execPath, [happysBin, ...forwarded], {
-        cwd: rootDir,
-        env: childEnv,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        detached: process.platform !== 'win32',
-      });
+  let child = null;
+
+  const spawnForwardedChild = () => {
+    const pty = wantsPty
+      ? buildScriptPtyArgs({
+          platform: process.platform,
+          file: '/dev/null',
+          command: [process.execPath, happysBin, ...forwarded],
+        })
+      : null;
+    const proc = wantsPty
+      ? // Use a pseudo-terminal so tools like Expo print QR/status output that they hide in non-TTY mode.
+        // `script` is available by default on macOS (and common on Linux).
+        spawn(pty.cmd, pty.args, {
+          cwd: rootDir,
+          env: childEnv,
+          stdio: ['ignore', 'pipe', 'pipe'],
+          detached: process.platform !== 'win32',
+        })
+      : spawn(process.execPath, [happysBin, ...forwarded], {
+          cwd: rootDir,
+          env: childEnv,
+          stdio: ['ignore', 'pipe', 'pipe'],
+          detached: process.platform !== 'win32',
+        });
 
-  logOrch(
-    `spawned: ${wantsPty ? 'script -q /dev/null ' : ''}node ${happysBin} ${forwarded.join(' ')} (pid=${child.pid})`
-  );
-
-  const buf = { out: '', err: '' };
-  const flush = (kind) => {
-    const key = kind === 'stderr' ? 'err' : 'out';
-    let b = buf[key];
-    while (true) {
-      const idx = nextLineBreakIndex(b);
-      if (idx < 0) break;
-      const line = b.slice(0, idx);
-      b = consumeLineBreak(b.slice(idx));
-      routeLine(line);
-    }
-    buf[key] = b;
+    logOrch(
+      `spawned: ${wantsPty ? `${pty.cmd} ${pty.args.join(' ')} ` : ''}node ${happysBin} ${forwarded.join(' ')} (pid=${proc.pid})`
+    );
+
+    const buf = { out: '', err: '' };
+    const flush = (kind) => {
+      const key = kind === 'stderr' ? 'err' : 'out';
+      let b = buf[key];
+      while (true) {
+        const idx = nextLineBreakIndex(b);
+        if (idx < 0) break;
+        const line = b.slice(0, idx);
+        b = consumeLineBreak(b.slice(idx));
+        routeLine(line);
+      }
+      buf[key] = b;
+    };
+
+    proc.stdout?.on('data', (d) => {
+      buf.out += d.toString();
+      flush('stdout');
+      scheduleRender();
+    });
+    proc.stderr?.on('data', (d) => {
+      buf.err += d.toString();
+      flush('stderr');
+      scheduleRender();
+    });
+    proc.on('exit', (code, sig) => {
+      logOrch(`child exited (code=${code}, sig=${sig ?? 'null'})`);
+      scheduleRender();
+    });
+
+    return proc;
   };
 
-  child.stdout?.on('data', (d) => {
-    buf.out += d.toString();
-    flush('stdout');
-    scheduleRender();
-  });
-  child.stderr?.on('data', (d) => {
-    buf.err += d.toString();
-    flush('stderr');
-    scheduleRender();
-  });
-  child.on('exit', (code, sig) => {
-    logOrch(`child exited (code=${code}, sig=${sig ?? 'null'})`);
-    scheduleRender();
-  });
+  child = spawnForwardedChild();
 
   async function refreshSummary() {
     const idx = paneIndexById.get('summary');
@@ -484,6 +616,137 @@ async function main() {
       panes[idx].lines = [`summary error: ${e instanceof Error ? e.message : String(e)}`];
     }
 
+	    // Daemon pane (best-effort): show sign-in guidance when credentials are missing,
+	    // and clear stale guidance once the daemon starts.
+	    try {
+	      const daemonIdx = paneIndexById.get('daemon');
+	      if (stackName) {
+	        const runtimePath = getStackRuntimeStatePath(stackName);
+	        const runtime = await readStackRuntimeStateFile(runtimePath);
+	        const daemonPid = Number(runtime?.processes?.daemonPid);
+
+	        const { baseDir } = resolveStackEnvPath(stackName);
+	        const serverPort = Number(runtime?.ports?.server);
+	        const internalServerUrl =
+	          Number.isFinite(serverPort) && serverPort > 0 ? `http://127.0.0.1:${serverPort}` : '';
+	        const cliHomeDir = join(baseDir, 'cli');
+
+	        const scopedEnv = applyTuiStackAuthScopeEnv({ env: process.env, stackName });
+	        const authed = internalServerUrl
+	          ? hasStackCredentials({ cliHomeDir, serverUrl: internalServerUrl, env: scopedEnv })
+	          : hasStackCredentials({ cliHomeDir, serverUrl: '', env: scopedEnv });
+
+	        const startDaemon = parseStartDaemonFlagFromEnv(process.env);
+	        const notice = buildDaemonAuthNotice({
+	          stackName,
+	          internalServerUrl,
+	          daemonPid: Number.isFinite(daemonPid) && daemonPid > 1 ? daemonPid : null,
+	          authed,
+	          startDaemon,
+	        });
+
+	        if (notice.show) {
+	          panes[daemonIdx].visible = true;
+	          panes[daemonIdx].title = notice.paneTitle || panes[daemonIdx].title;
+	          const preserve =
+	            daemonAutostartInProgress ||
+	            (daemonAutostartLastAttemptAtMs > 0 && Date.now() - daemonAutostartLastAttemptAtMs < 6_000);
+	          if (!preserve || panes[daemonIdx].lines.length === 0) {
+	            panes[daemonIdx].lines = styleDaemonNoticeLines(notice.paneLines || panes[daemonIdx].lines);
+	          }
+	          if (!sawDaemonAuthRequired && notice.paneTitle === 'daemon (SIGN-IN REQUIRED)') {
+	            sawDaemonAuthRequired = true;
+	            if (focused === paneIndexById.get('local')) {
+	              focused = daemonIdx;
+	            }
+	          }
+	        } else {
+	          const reconciled = reconcileDaemonPaneAfterDaemonStarts({
+	            title: panes[daemonIdx].title,
+	            lines: panes[daemonIdx].lines,
+	            daemonPid,
+	          });
+	          panes[daemonIdx].title = reconciled.title;
+	          panes[daemonIdx].lines = reconciled.lines;
+	        }
+
+	        const isStartLike = isTuiStartLikeForwardedArgs(forwarded);
+	        const minIntervalRaw = (process.env.HAPPIER_STACK_TUI_DAEMON_AUTOSTART_MIN_INTERVAL_MS ?? '').toString().trim();
+	        const minIntervalMs = minIntervalRaw ? Number(minIntervalRaw) : 12_000;
+	        const shouldAutostart = shouldAttemptTuiDaemonAutostart({
+	          stackName,
+	          isStartLike,
+	          startDaemon,
+	          internalServerUrl,
+	          authed,
+	          daemonPid: Number.isFinite(daemonPid) && daemonPid > 1 ? daemonPid : null,
+	          inProgress: daemonAutostartInProgress,
+	          lastAttemptAtMs: daemonAutostartLastAttemptAtMs,
+	          nowMs: Date.now(),
+	          minIntervalMs,
+	        });
+
+	        if (shouldAutostart) {
+	          daemonAutostartInProgress = true;
+	          daemonAutostartLastAttemptAtMs = Date.now();
+	          panes[daemonIdx].visible = true;
+	          panes[daemonIdx].title = 'daemon (STARTING)';
+	          pushLine(panes[daemonIdx], 'starting daemon...');
+	          scheduleRender();
+
+	          void (async () => {
+	            try {
+	              await waitForHappierHealthOk(internalServerUrl, { timeoutMs: 10_000, intervalMs: 250 });
+
+	              const daemonArgs = buildTuiDaemonStartArgs({ happysBin, stackName });
+	              const attemptLines = [];
+	              await new Promise((resolvePromise) => {
+	                const proc = spawn(process.execPath, daemonArgs, {
+	                  cwd: rootDir,
+	                  env: { ...process.env, HAPPIER_STACK_TUI: '1' },
+	                  stdio: ['ignore', 'pipe', 'pipe'],
+	                });
+
+	                const write = (chunk) => {
+	                  const s = String(chunk ?? '');
+	                  for (const line of s.split(/\r?\n/)) {
+	                    if (!line.trim()) continue;
+	                    attemptLines.push(line);
+	                    pushLine(panes[daemonIdx], line);
+	                  }
+	                  scheduleRender();
+	                };
+
+	                proc.stdout?.on('data', write);
+	                proc.stderr?.on('data', write);
+	                proc.on('exit', () => resolvePromise());
+	                proc.on('error', () => resolvePromise());
+	              });
+
+	              const combined = attemptLines.join('\n').toLowerCase();
+	              if (combined.includes('already running')) {
+	                panes[daemonIdx].title = 'daemon (ALREADY RUNNING)';
+	                pushLine(panes[daemonIdx], 'daemon already running; no action needed');
+	              } else {
+	                panes[daemonIdx].title = 'daemon (STARTED)';
+	                pushLine(panes[daemonIdx], 'daemon start completed');
+	              }
+	              scheduleRender();
+	            } finally {
+	              daemonAutostartInProgress = false;
+	              try {
+	                await refreshSummary();
+	              } catch {
+	                // ignore
+	              }
+	            }
+	          })();
+	        }
+	      }
+	    } catch {
+	      // ignore
+	    }
+
     // QR pane: driven by runtime state (expo port) and rendered independently of logs.
     try {
       const qrIdx = paneIndexById.get('qr');
@@ -499,11 +762,230 @@ async function main() {
     scheduleRender();
   }
 
-  const summaryTimer = setInterval(() => {
-    if (!paused) {
-      void refreshSummary();
+  let summaryTimer = null;
+  const startSummaryTimer = () => {
+    if (summaryTimer) clearInterval(summaryTimer);
+    summaryTimer = setInterval(() => {
+      if (!paused) {
+        void refreshSummary();
+      }
+    }, 1000);
+  };
+  startSummaryTimer();
+
+  async function runAuthLoginFromTui({ force = false } = {}) {
+    if (!stackName) {
+      logOrch('auth: no stack context; use `hstack stack auth <name> login`');
+      scheduleRender();
+      return;
+    }
+
+    const authArgs = buildTuiAuthArgs({ happysBin, stackName, force });
+
+    if (summaryTimer) clearInterval(summaryTimer);
+    paused = true;
+    process.stdout.write('\x1b[2J\x1b[H\x1b[?25h');
+
+    // In TUI-driven dev/start flows, the stack server is usually still starting when users press "a".
+    // Waiting here avoids triggering auth's "start the stack in background" prompt, which would
+    // try to start a second stack instance and confuse users.
+    const runtimePath = getStackRuntimeStatePath(stackName);
+    const waitTimeoutRaw = (process.env.HAPPIER_STACK_TUI_AUTH_WAIT_TIMEOUT_MS ?? '').toString().trim();
+    const waitTimeoutMs = waitTimeoutRaw ? Number(waitTimeoutRaw) : 45_000;
+    const deadline = Date.now() + (Number.isFinite(waitTimeoutMs) && waitTimeoutMs > 0 ? waitTimeoutMs : 45_000);
+    let internalServerUrl = '';
+    while (Date.now() < deadline) {
+      // eslint-disable-next-line no-await-in-loop
+      const runtime = await readStackRuntimeStateFile(runtimePath);
+      const port = Number(runtime?.ports?.server);
+      if (Number.isFinite(port) && port > 0) {
+        internalServerUrl = `http://127.0.0.1:${port}`;
+        break;
+      }
+      process.stdout.write('.');
+      // eslint-disable-next-line no-await-in-loop
+      await new Promise((r) => setTimeout(r, 250));
+    }
+    process.stdout.write('\n');
+    if (!internalServerUrl) {
+      process.stdout.write(
+        `[auth] waiting for the stack server timed out (${Math.round((Number.isFinite(waitTimeoutMs) ? waitTimeoutMs : 45_000) / 1000)}s).\n` +
+          `[auth] The stack may still be starting. Check the "local" / "server" panes, then press "a" again.\n\n` +
+          `Press Enter to return to TUI...`
+      );
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+        // ignore
+      }
+      try {
+        process.stdin.resume();
+      } catch {
+        // ignore
+      }
+      await waitForEnter({ stdin: process.stdin, timeoutMs: 120_000 });
+      paused = false;
+      startSummaryTimer();
+      await refreshSummary();
+      scheduleRender();
+      return;
     }
-  }, 1000);
+
+    process.stdout.write('[auth] waiting for server health');
+    const healthOk = await waitForHappierHealthOk(internalServerUrl, { timeoutMs: 45_000, intervalMs: 300 });
+    process.stdout.write(healthOk ? ' ✓\n' : ' (timeout)\n');
+    if (!healthOk) {
+      process.stdout.write(
+        `[auth] server did not become healthy in time.\n` +
+          `[auth] Check the "local" / "server" panes, then press "a" again.\n\n` +
+          `Press Enter to return to TUI...`
+      );
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+        // ignore
+      }
+      try {
+        process.stdin.resume();
+      } catch {
+        // ignore
+      }
+      await waitForEnter({ stdin: process.stdin, timeoutMs: 120_000 });
+      paused = false;
+      startSummaryTimer();
+      await refreshSummary();
+      scheduleRender();
+      return;
+    }
+
+    const handoff = detachTuiStdinForChild({ stdin: process.stdin, onData });
+
+    const authResult = await new Promise((resolvePromise) => {
+      const proc = spawn(process.execPath, authArgs, { cwd: rootDir, env: process.env, stdio: 'inherit' });
+      proc.on('exit', (code, signal) => resolvePromise({ code, signal }));
+      proc.on('error', () => resolvePromise({ code: 1, signal: null }));
+    });
+
+    let hold = shouldHoldAfterAuthExit(authResult);
+
+    // If auth succeeded and daemon is expected, start it automatically so the UI immediately shows a machine.
+    if (!hold) {
+      try {
+        const { envPath } = resolveStackEnvPath(stackName);
+        const envFromFile = await readEnvObject(envPath).catch(() => ({}));
+        const startDaemon = parseStartDaemonFlagFromEnv({ ...process.env, ...envFromFile });
+
+        if (startDaemon) {
+          const runtime = await readStackRuntimeStateFile(runtimePath);
+          const daemonPid = Number(runtime?.processes?.daemonPid);
+          const daemonRunning = Number.isFinite(daemonPid) && daemonPid > 1;
+          if (!daemonRunning) {
+            process.stdout.write(`\n[daemon] starting...\n`);
+            const daemonArgs = buildTuiDaemonStartArgs({ happysBin, stackName });
+            const daemonRes = await new Promise((resolvePromise) => {
+              const proc = spawn(process.execPath, daemonArgs, { cwd: rootDir, env: process.env, stdio: 'inherit' });
+              proc.on('exit', (code, signal) => resolvePromise({ code, signal }));
+              proc.on('error', () => resolvePromise({ code: 1, signal: null }));
+            });
+            hold = hold || shouldHoldAfterAuthExit(daemonRes);
+          }
+        }
+      } catch {
+        // ignore
+      }
+    }
+
+    if (hold) {
+      try {
+        process.stdout.write(
+          `\n[auth] finished (code=${authResult?.code ?? 'null'}, sig=${authResult?.signal ?? 'null'}). Press Enter to return to TUI...`
+        );
+        // Re-enable stdin reads (in cooked mode) for the one-line prompt.
+        try {
+          process.stdin.setRawMode(false);
+        } catch {
+          // ignore
+        }
+        try {
+          process.stdin.resume();
+        } catch {
+          // ignore
+        }
+        await waitForEnter({ stdin: process.stdin, timeoutMs: 120_000 });
+      } catch {
+        // ignore
+      }
+    }
+
+    paused = false;
+    handoff.restoreForTui();
+
+    // Restart summary refresh.
+    startSummaryTimer();
+
+    await refreshSummary();
+    scheduleRender();
+  }
+
+  async function restartStackFromTui() {
+    if (!stackName || !isTuiRestartableForwardedArgs(forwarded)) {
+      logOrch('restart: only supported for dev/start commands with an active stack context');
+      scheduleRender();
+      return;
+    }
+
+    if (summaryTimer) clearInterval(summaryTimer);
+    paused = true;
+    const handoff = detachTuiStdinForChild({ stdin: process.stdin, onData });
+    process.stdout.write('\x1b[2J\x1b[H\x1b[?25h');
+    process.stdout.write(`[restart] stopping stack processes...\n`);
+
+    const childPid = Number(child?.pid);
+    if (child && child.exitCode == null && Number.isFinite(childPid) && childPid > 1) {
+      await terminateProcessGroup(childPid, { graceMs: 900 });
+    }
+
+    try {
+      await stopStackForTuiExit({ rootDir, stackName, json: false, noDocker: false });
+    } catch (e) {
+      process.stdout.write(`[restart] stop failed: ${e instanceof Error ? e.message : String(e)}\n`);
+      process.stdout.write(`Press Enter to return to TUI...`);
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+        // ignore
+      }
+      try {
+        process.stdin.resume();
+      } catch {
+        // ignore
+      }
+      await waitForEnter({ stdin: process.stdin, timeoutMs: 120_000 });
+      handoff.restoreForTui();
+      paused = false;
+      startSummaryTimer();
+      await refreshSummary();
+      scheduleRender();
+      return;
+    }
+
+    // Clear log panes so old output doesn't get mixed with the new run.
+    for (const p of panes) {
+      if (p.kind === 'summary') continue;
+      if (p.id === 'orch') continue;
+      p.lines = [];
+      p.scroll = 0;
+    }
+
+    process.stdout.write(`[restart] starting stack...\n\n`);
+    child = spawnForwardedChild();
+
+    paused = false;
+    handoff.restoreForTui();
+    startSummaryTimer();
+    await refreshSummary();
+    scheduleRender();
+  }
 
   function scheduleRender() {
     if (paused) return;
@@ -594,6 +1076,7 @@ async function main() {
         lines: pane.lines,
         scroll: pane.scroll,
         active: true,
+        allowAnsi: pane.id === 'summary' || pane.id === 'daemon',
       });
       pane.scroll = clamp(pane.scroll, 0, box.maxScroll);
       drawWrites.push(...box.out);
@@ -613,6 +1096,7 @@ async function main() {
         lines: leftPane.lines,
         scroll: leftPane.scroll,
         active: focused === paneIndexById.get('orch'),
+        allowAnsi: leftPane.id === 'summary' || leftPane.id === 'daemon',
       });
       leftPane.scroll = clamp(leftPane.scroll, 0, leftBox.maxScroll);
       drawWrites.push(...leftBox.out);
@@ -626,6 +1110,7 @@ async function main() {
         lines: rightPane.lines,
         scroll: rightPane.scroll,
         active: focused === (paneIndexById.get(rightPane.id) ?? focused),
+        allowAnsi: rightPane.id === 'summary' || rightPane.id === 'daemon',
       });
       rightPane.scroll = clamp(rightPane.scroll, 0, rightBox.maxScroll);
       drawWrites.push(...rightBox.out);
@@ -659,6 +1144,7 @@ async function main() {
           lines: pane.lines,
           scroll: pane.scroll,
           active: paneIndexById.get(pane.id) === focused,
+          allowAnsi: pane.id === 'summary' || pane.id === 'daemon',
         });
         pane.scroll = clamp(pane.scroll, 0, box.maxScroll);
         drawWrites.push(...box.out);
@@ -724,6 +1210,7 @@ async function main() {
                   lines: pane.lines,
                   scroll: pane.scroll,
                   active: paneIndexById.get(pane.id) === focused,
+                  allowAnsi: pane.id === 'summary' || pane.id === 'daemon',
                 });
                 pane.scroll = clamp(pane.scroll, 0, logBox.maxScroll);
                 drawWrites.push(...logBox.out);
@@ -737,6 +1224,7 @@ async function main() {
                   lines: qrLines,
                   scroll: 0,
                   active: paneIndexById.get(pane.id) === focused,
+                  allowAnsi: false,
                 });
                 drawWrites.push(...qrBox.out);
               } else {
@@ -750,6 +1238,7 @@ async function main() {
                   lines: pane.lines,
                   scroll: pane.scroll,
                   active: paneIndexById.get(pane.id) === focused,
+                  allowAnsi: pane.id === 'summary' || pane.id === 'daemon',
                 });
                 pane.scroll = clamp(pane.scroll, 0, box.maxScroll);
                 drawWrites.push(...box.out);
@@ -764,6 +1253,7 @@ async function main() {
                 lines: pane.lines,
                 scroll: pane.scroll,
                 active: paneIndexById.get(pane.id) === focused,
+                allowAnsi: pane.id === 'summary' || pane.id === 'daemon',
               });
               pane.scroll = clamp(pane.scroll, 0, box.maxScroll);
               drawWrites.push(...box.out);
@@ -778,6 +1268,7 @@ async function main() {
               lines: pane.lines,
               scroll: pane.scroll,
               active: paneIndexById.get(pane.id) === focused,
+              allowAnsi: pane.id === 'summary' || pane.id === 'daemon',
             });
             pane.scroll = clamp(pane.scroll, 0, box.maxScroll);
             drawWrites.push(...box.out);
@@ -794,8 +1285,20 @@ async function main() {
       process.stdout.write(`\x1b[${w.row + 1};${w.col + 1}H${w.text}`);
     }
 
-    const footer =
-      'tab:next  shift+tab:prev  1..9:jump  v:layout  m:toggle-pane  c:clear  p:pause  arrows:scroll  q/Ctrl+C:quit';
+    const footerParts = [
+      'tab:next',
+      'shift+tab:prev',
+      '1..9:jump',
+      'v:layout',
+      'm:toggle-pane',
+      'c:clear',
+      'p:pause',
+      'arrows:scroll',
+      stackName ? 'a/A:auth' : null,
+      stackName && isTuiRestartableForwardedArgs(forwarded) ? 'r:restart' : null,
+      'q/Ctrl+C:quit',
+    ].filter(Boolean);
+    const footer = footerParts.join('  ');
     process.stdout.write(`\x1b[${footerY + 1};1H` + padRight(footer, cols));
     process.stdout.write('\x1b[?25h');
   }
@@ -805,7 +1308,7 @@ async function main() {
     if (exiting) return;
     exiting = true;
 
-    clearInterval(summaryTimer);
+    if (summaryTimer) clearInterval(summaryTimer);
     try {
       process.stdin.setRawMode(false);
     } catch {
@@ -823,10 +1326,10 @@ async function main() {
       await terminateProcessGroup(childPid, { graceMs: 900 });
     }
 
-    // Best-effort cleanup: when the TUI runs a long-lived `stack dev/start` command, ensure all
+    // Best-effort cleanup: when the TUI runs a long-lived `dev/start` command, ensure all
     // stack-owned infra processes are stopped (server/expo/daemon) even if the child exits early.
     let cleanupError = null;
-    if (isStackStartLikeForwardedArgs(forwarded)) {
+    if (stackName && isTuiStartLikeForwardedArgs(forwarded)) {
       try {
         await stopStackForTuiExit({ rootDir, stackName, json: false, noDocker: false });
       } catch (e) {
@@ -857,12 +1360,24 @@ async function main() {
 
   process.stdin.setRawMode(true);
   process.stdin.resume();
-  process.stdin.on('data', (d) => {
+  const onData = (d) => {
     const s = d.toString('utf-8');
     if (s === '\u0003' || s === 'q') {
       shutdown();
       return;
     }
+    if (s === 'a') {
+      void runAuthLoginFromTui({ force: false });
+      return;
+    }
+    if (s === 'A') {
+      void runAuthLoginFromTui({ force: true });
+      return;
+    }
+    if (s === 'r') {
+      void restartStackFromTui();
+      return;
+    }
     if (s === '\t') return focusNext(+1);
     if (s === '\x1b[Z') return focusNext(-1);
     if (s >= '1' && s <= '9') {
@@ -901,7 +1416,8 @@ async function main() {
       scheduleRender();
       return;
     }
-  });
+  };
+  process.stdin.on('data', onData);
 
   await refreshSummary();
   render();