@happier-dev/stack 0.1.0-preview.96.1 → 0.2.0-preview.1775370152.55749

package/scripts/tui.mjs

@@ -1,20 +1,53 @@
 import './utils/env/env.mjs';
 import { spawn } from 'node:child_process';
 import { mkdir } from 'node:fs/promises';
+import * as os from 'node:os';
 import { join, resolve, sep } from 'node:path';
 
 import { printResult } from './utils/cli/cli.mjs';
+import { resolveCommandInvocation } from './utils/process/resolveCommandInvocation.mjs';
 import { readEnvObjectFromFile } from './utils/env/read.mjs';
 import { getComponentDir, getRepoDir, getRootDir, resolveStackEnvPath } from './utils/paths/paths.mjs';
 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 {
+  extractTuiLaunchOptions,
+  inferTuiStackName,
+  isTuiHelpRequest,
+  isTuiRestartableForwardedArgs,
+  isTuiStartLikeForwardedArgs,
+} from './utils/tui/args.mjs';
+import {
+  buildTuiChildArgs,
+  buildTauriPaneEnv,
+  resolveTauriPaneSpawnConfig,
+  shouldStartTauriPane,
+} from './utils/tui/tauri_mode.mjs';
 import { terminateProcessGroup } from './utils/proc/terminate.mjs';
+import { getProcessGroupId } from './utils/proc/ownership.mjs';
+import { killPid } from './utils/expo/expo.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';
+import { resolveTuiChildTerminationPlan } from './utils/tui/child_termination_plan.mjs';
+import { installTuiStdinErrorGuard } from './utils/tui/stdin_error_guard.mjs';
+import { checkDaemonState } from './daemon.mjs';
+import { getObservedStackDaemon } from './utils/stack/runtime_daemon_state.mjs';
 
 function nowTs() {
   const d = new Date();
@@ -32,10 +65,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 +110,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 +150,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;
@@ -162,12 +216,16 @@ async function preflightCorepackYarnForStack({ envPath }) {
   await mkdir(env.COREPACK_HOME, { recursive: true }).catch(() => {});
 
   await new Promise((resolvePromise) => {
-    const proc = spawn('yarn', ['--version'], {
+    const invocation = resolveCommandInvocation({ command: 'yarn', args: ['--version'], env });
+    const proc = spawn(invocation.command, invocation.args, {
       env,
       cwd: baseDir,
       // Non-tty stdio: Corepack typically won't prompt; if it does, we still provide "y\n".
       stdio: ['pipe', 'ignore', 'ignore'],
       shell: false,
+      ...(process.platform === 'win32'
+        ? { windowsHide: true, windowsVerbatimArguments: invocation.windowsVerbatimArguments }
+        : null),
     });
     try {
       proc.stdin?.write('y\n');
@@ -228,8 +286,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 +341,23 @@ 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 observedDaemon = getObservedStackDaemon({
+    cliHomeDir,
+    internalServerUrl,
+    runtimeDaemonPid: processes?.daemonPid ?? null,
+    env: authScopeEnv,
+  }, {
+    checkDaemonStateImpl: checkDaemonState,
+  });
+
   const lines = [];
   lines.push(`stack: ${stackName}`);
   lines.push(`server: ${serverComponent}`);
@@ -252,6 +368,20 @@ 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: observedDaemon.pid,
+    daemonRunning: observedDaemon.running,
+    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)'}`);
@@ -270,7 +400,7 @@ async function buildStackSummaryLines({ rootDir, stackName }) {
   lines.push('pids:');
   if (processes?.serverPid) lines.push(`  serverPid: ${processes.serverPid}`);
   if (processes?.expoPid) lines.push(`  expoPid: ${processes.expoPid}`);
-  if (processes?.daemonPid) lines.push(`  daemonPid: ${processes.daemonPid}`);
+  if (observedDaemon.pid) lines.push(`  daemonPid: ${observedDaemon.pid}`);
   if (processes?.uiGatewayPid) lines.push(`  uiGatewayPid: ${processes.uiGatewayPid}`);
 
   lines.push('');
@@ -296,6 +426,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 +452,23 @@ async function buildExpoQrPaneLines({ stackName }) {
 }
 
 async function main() {
-  const argv = process.argv.slice(2);
+  const argvRaw = process.argv.slice(2);
+  const { forwardedArgs: rawForwardedArgs, withTauri } = extractTuiLaunchOptions(argvRaw);
+  const forwarded = rawForwardedArgs;
+  const childForwarded = buildTuiChildArgs({ forwardedArgs: forwarded, withTauri });
 
-  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...>] [--tauri]',
+        '',
+        'defaults:',
+        '  hstack tui                 => hstack tui dev',
+        '  hstack tui --tauri         => hstack tui dev with a Tauri pane',
+        '  hstack tui --tauri --mobile => hstack tui dev --mobile with a Tauri pane',
         '',
         'examples:',
         '  hstack tui stack dev resume-upstream',
@@ -348,6 +489,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):',
@@ -363,14 +507,14 @@ async function main() {
 
   const rootDir = getRootDir(import.meta.url);
   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' }),
+    mkPane('tauri', 'tauri', { visible: withTauri, kind: 'log' }),
     // 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' }),
@@ -407,6 +551,16 @@ async function main() {
     pushLine(panes[paneIndexById.get('orch')], `[${nowTs()}] ${msg}`);
   };
 
+  // Prevent rare TTY `read EIO` crashes during restart/shutdown transitions.
+  // Without an 'error' listener, Node treats stdin errors as unhandled and aborts the TUI.
+  installTuiStdinErrorGuard({
+    stdin: process.stdin,
+    onError: (err) => {
+      const code = err && typeof err === 'object' ? String(err.code ?? '') : '';
+      logOrch(`stdin error ignored${code ? ` (${code})` : ''}`);
+    },
+  });
+
   // Preflight Yarn/Corepack for this stack before spawning the pty child.
   // This prevents Corepack "download yarn? [Y/n]" prompts from deadlocking the TUI.
   await preflightCorepackYarnForStack({ envPath: stackEnvPath });
@@ -415,65 +569,129 @@ 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),
   // so any interactive prompts inside the child would deadlock.
   // Mark the child env so dependency installers can auto-approve safe prompts (Corepack yarn downloads).
-  const childEnv = {
-    ...process.env,
-    HAPPIER_STACK_TUI: '1',
-    // Avoid Corepack mutating package.json automatically.
-    COREPACK_ENABLE_AUTO_PIN: '0',
+  const childEnv = buildTauriPaneEnv({ env: process.env });
+  let child = null;
+
+  const spawnForwardedChild = () => {
+    const pty = wantsPty
+      ? buildScriptPtyArgs({
+          platform: process.platform,
+          file: '/dev/null',
+          command: [process.execPath, happysBin, ...childForwarded],
+        })
+      : 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, ...childForwarded], {
+          cwd: rootDir,
+          env: childEnv,
+          stdio: ['ignore', 'pipe', 'pipe'],
+          detached: process.platform !== 'win32',
+        });
+
+    logOrch(
+      `spawned: ${wantsPty ? `${pty.cmd} ${pty.args.join(' ')} ` : ''}node ${happysBin} ${childForwarded.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;
   };
-  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',
-      });
 
-  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;
+  const spawnTauriChild = () => {
+    if (!withTauri || !shouldStartTauriPane(rawForwardedArgs)) {
+      return null;
+    }
+
+    const { invocation, env: tauriEnv } = resolveTauriPaneSpawnConfig({
+      rootDir,
+      env: childEnv,
+      resolveUserHomeDir: () => {
+        try {
+          return String(os.userInfo()?.homedir ?? '').trim();
+        } catch {
+          return String(os.homedir() ?? '').trim();
+        }
+      },
+    });
+    const proc = spawn(invocation.command, invocation.args, {
+      cwd: invocation.cwd,
+      env: tauriEnv,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: process.platform !== 'win32',
+      ...(process.platform === 'win32' ? { windowsHide: true, windowsVerbatimArguments: invocation.windowsVerbatimArguments } : null),
+    });
+
+    logOrch(`spawned: node apps/stack/scripts/tauri_dev.mjs (pid=${proc.pid})`);
+    const tauriIdx = paneIndexById.get('tauri');
+    const tauriPane = panes[tauriIdx];
+    const write = (chunk) => {
+      const s = String(chunk ?? '');
+      for (const line of s.split(/\r?\n/)) {
+        if (!line.trim()) continue;
+        pushLine(tauriPane, line);
+      }
+      scheduleRender();
+    };
+
+    proc.stdout?.on('data', write);
+    proc.stderr?.on('data', write);
+    proc.on('exit', (code, sig) => {
+      pushLine(tauriPane, `tauri exited (code=${code}, sig=${sig ?? 'null'})`);
+      scheduleRender();
+    });
+    proc.on('error', (error) => {
+      pushLine(tauriPane, `tauri error: ${error instanceof Error ? error.message : String(error)}`);
+      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();
+  let tauriChild = spawnTauriChild();
 
   async function refreshSummary() {
     const idx = paneIndexById.get('summary');
@@ -484,6 +702,147 @@ 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 { 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 observedDaemon = getObservedStackDaemon({
+		          cliHomeDir,
+		          internalServerUrl,
+		          runtimeDaemonPid: runtime?.processes?.daemonPid ?? null,
+		          env: scopedEnv,
+		        }, {
+		          checkDaemonStateImpl: checkDaemonState,
+		        });
+
+		        const startDaemon = parseStartDaemonFlagFromEnv(process.env);
+		        const notice = buildDaemonAuthNotice({
+		          stackName,
+		          internalServerUrl,
+		          daemonPid: observedDaemon.pid,
+		          daemonRunning: observedDaemon.running,
+		          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: observedDaemon.pid,
+		            daemonRunning: observedDaemon.running,
+		          });
+		          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: observedDaemon.pid,
+		          daemonRunning: observedDaemon.running,
+		          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 +858,254 @@ 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;
     }
-  }, 1000);
+
+    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;
+    }
+
+    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 observedDaemon = getObservedStackDaemon({
+            cliHomeDir: join(resolveStackEnvPath(stackName).baseDir, 'cli'),
+            internalServerUrl,
+            runtimeDaemonPid: runtime?.processes?.daemonPid ?? null,
+            env: { ...process.env, ...envFromFile },
+          }, {
+            checkDaemonStateImpl: checkDaemonState,
+          });
+          const daemonRunning = observedDaemon.running;
+          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) {
+      const [childPgid, selfPgid] = await Promise.all([getProcessGroupId(childPid), getProcessGroupId(process.pid)]);
+      const plan = resolveTuiChildTerminationPlan({ childPid, childPgid, selfPgid });
+      if (plan.strategy === 'pgid') {
+        await terminateProcessGroup(plan.target, { graceMs: 900 });
+      } else if (plan.strategy === 'pid') {
+        await killPid(plan.target);
+      }
+    }
+    const tauriPid = Number(tauriChild?.pid);
+    if (tauriChild && tauriChild.exitCode == null && Number.isFinite(tauriPid) && tauriPid > 1) {
+      const [tauriPgid, selfPgid] = await Promise.all([getProcessGroupId(tauriPid), getProcessGroupId(process.pid)]);
+      const plan = resolveTuiChildTerminationPlan({ childPid: tauriPid, childPgid: tauriPgid, selfPgid });
+      if (plan.strategy === 'pgid') {
+        await terminateProcessGroup(plan.target, { graceMs: 900 });
+      } else if (plan.strategy === 'pid') {
+        await killPid(plan.target);
+      }
+    }
+
+    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();
+    tauriChild = spawnTauriChild();
+
+    paused = false;
+    handoff.restoreForTui();
+    startSummaryTimer();
+    await refreshSummary();
+    scheduleRender();
+  }
 
   function scheduleRender() {
     if (paused) return;
@@ -571,7 +1173,7 @@ async function main() {
 
     const focusPane = panes[focused];
     const focusLabel = focusPane ? `${focusPane.id} (${focusPane.title})` : String(focused);
-    const header = `hstack tui | ${forwarded.join(' ')} | layout=${layout} | focus=${focusLabel}`;
+    const header = `hstack tui | ${forwarded.join(' ')}${withTauri ? ' +tauri' : ''} | layout=${layout} | focus=${focusLabel}`;
     process.stdout.write(padRight(header, cols) + '\n');
 
     const bodyY = 1;
@@ -594,6 +1196,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 +1216,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 +1230,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 +1264,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 +1330,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 +1344,7 @@ async function main() {
                   lines: qrLines,
                   scroll: 0,
                   active: paneIndexById.get(pane.id) === focused,
+                  allowAnsi: false,
                 });
                 drawWrites.push(...qrBox.out);
               } else {
@@ -750,6 +1358,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 +1373,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 +1388,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 +1405,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 +1428,7 @@ async function main() {
     if (exiting) return;
     exiting = true;
 
-    clearInterval(summaryTimer);
+    if (summaryTimer) clearInterval(summaryTimer);
     try {
       process.stdin.setRawMode(false);
     } catch {
@@ -820,13 +1443,29 @@ async function main() {
     if (child.exitCode == null && Number.isFinite(childPid) && childPid > 1) {
       // Ensure the child is actually gone before stack infra cleanup, otherwise a still-running
       // watch process can immediately respawn server/daemon and re-lock the DB.
-      await terminateProcessGroup(childPid, { graceMs: 900 });
+      const [childPgid, selfPgid] = await Promise.all([getProcessGroupId(childPid), getProcessGroupId(process.pid)]);
+      const plan = resolveTuiChildTerminationPlan({ childPid, childPgid, selfPgid });
+      if (plan.strategy === 'pgid') {
+        await terminateProcessGroup(plan.target, { graceMs: 900 });
+      } else if (plan.strategy === 'pid') {
+        await killPid(plan.target);
+      }
+    }
+    const tauriPid = Number(tauriChild?.pid);
+    if (tauriChild && tauriChild.exitCode == null && Number.isFinite(tauriPid) && tauriPid > 1) {
+      const [tauriPgid, selfPgid] = await Promise.all([getProcessGroupId(tauriPid), getProcessGroupId(process.pid)]);
+      const plan = resolveTuiChildTerminationPlan({ childPid: tauriPid, childPgid: tauriPgid, selfPgid });
+      if (plan.strategy === 'pgid') {
+        await terminateProcessGroup(plan.target, { graceMs: 900 });
+      } else if (plan.strategy === 'pid') {
+        await killPid(plan.target);
+      }
     }
 
-    // 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 +1496,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 +1552,8 @@ async function main() {
       scheduleRender();
       return;
     }
-  });
+  };
+  process.stdin.on('data', onData);
 
   await refreshSummary();
   render();