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

package/scripts/tui_args_default_cmd.test.mjs

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+
+function runNode(args, { cwd, env }) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(process.execPath, args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => (stdout += String(d)));
+    proc.stderr.on('data', (d) => (stderr += String(d)));
+    proc.on('error', reject);
+    proc.on('exit', (code, signal) => resolve({ code: code ?? (signal ? 1 : 0), signal, stdout, stderr }));
+  });
+}
+
+test('tui without args defaults to command execution path (non-tty requires tty)', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const packageRoot = dirname(scriptsDir); // apps/stack
+  const repoRoot = dirname(dirname(packageRoot)); // repo root
+  const tuiScript = join(packageRoot, 'scripts', 'tui.mjs');
+
+  const res = await runNode([tuiScript], { cwd: repoRoot, env: process.env });
+  assert.equal(res.code, 1);
+  assert.match(res.stderr, /\[tui\] failed: Error: \[tui\] requires a TTY/);
+});
+
+test('tui help remains explicit', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const packageRoot = dirname(scriptsDir); // apps/stack
+  const repoRoot = dirname(dirname(packageRoot)); // repo root
+  const tuiScript = join(packageRoot, 'scripts', 'tui.mjs');
+
+  const res = await runNode([tuiScript, '--help'], { cwd: repoRoot, env: process.env });
+  assert.equal(res.code, 0);
+  assert.match(res.stdout, /\[tui\] usage:/);
+  assert.match(res.stdout, /hstack tui \[\<hstack args\.\.\.\>\]/);
+  assert.match(res.stdout, /hstack tui\s+=> hstack tui dev/);
+});

package/scripts/utils/auth/auth_force_flag.mjs

@@ -0,0 +1,14 @@
+export function resolveAuthForceFlag({ flags, kv } = {}) {
+  const fromFlag = Boolean(flags && typeof flags.has === 'function' && flags.has('--force'));
+  const fromKv = String(kv && typeof kv.get === 'function' ? (kv.get('--force') ?? '') : '')
+    .trim()
+    .toLowerCase();
+  return fromFlag || fromKv === '1' || fromKv === 'true' || fromKv === 'yes';
+}
+
+export function applyAuthForceEnv(env, force) {
+  const base = env && typeof env === 'object' ? env : {};
+  if (!force) return base;
+  return { ...base, HAPPIER_AUTH_FORCE: '1' };
+}
+

package/scripts/utils/auth/credentials_paths.mjs

@@ -8,12 +8,12 @@ function normalizeServerUrl(url) {
   return String(url ?? '').trim().replace(/\/+$/, '');
 }
 
-function sanitizeServerIdForFilesystem(raw, fallback = 'cloud') {
+function sanitizeServerIdForFilesystem(raw, fallback = 'default') {
   const value = String(raw ?? '').trim();
-  if (!value) return String(fallback ?? '').trim() || 'cloud';
-  if (value === '.' || value === '..') return String(fallback ?? '').trim() || 'cloud';
-  if (value.includes('/') || value.includes('\\')) return String(fallback ?? '').trim() || 'cloud';
-  if (!SERVER_ID_SAFE_RE.test(value)) return String(fallback ?? '').trim() || 'cloud';
+  if (!value) return String(fallback ?? '').trim() || 'default';
+  if (value === '.' || value === '..') return String(fallback ?? '').trim() || 'default';
+  if (value.includes('/') || value.includes('\\')) return String(fallback ?? '').trim() || 'default';
+  if (!SERVER_ID_SAFE_RE.test(value)) return String(fallback ?? '').trim() || 'default';
   return value;
 }
 
@@ -46,8 +46,8 @@ export function resolveStackCredentialPaths({ cliHomeDir, serverUrl = '', env =
   const legacyPath = join(home, 'access.key');
   const normalizedServerUrl = normalizeServerUrl(serverUrl);
   const urlHashServerId = sanitizeServerIdForFilesystem(
-    normalizedServerUrl ? deriveServerIdFromUrl(normalizedServerUrl) : 'cloud',
-    'cloud'
+    normalizedServerUrl ? deriveServerIdFromUrl(normalizedServerUrl) : 'default',
+    'default'
   );
   const overrideServerId = resolveActiveServerIdOverride(env);
   const activeServerId = overrideServerId || urlHashServerId;
@@ -71,8 +71,8 @@ export function resolveStackDaemonStatePaths({ cliHomeDir, serverUrl = '', env =
   const home = requireCliHomeDir(cliHomeDir);
   const normalizedServerUrl = normalizeServerUrl(serverUrl);
   const urlHashServerId = sanitizeServerIdForFilesystem(
-    normalizedServerUrl ? deriveServerIdFromUrl(normalizedServerUrl) : 'cloud',
-    'cloud'
+    normalizedServerUrl ? deriveServerIdFromUrl(normalizedServerUrl) : 'default',
+    'default'
   );
   const overrideServerId = resolveActiveServerIdOverride(env);
   const activeServerId = overrideServerId || urlHashServerId;

package/scripts/utils/auth/credentials_paths.test.mjs

@@ -22,6 +22,14 @@ test('resolveStackCredentialPaths returns legacy + server-scoped paths', async (
   assert.deepEqual(out.paths, [out.serverScopedPath, out.legacyPath]);
 });
 
+test('resolveStackCredentialPaths uses a neutral default server id when serverUrl is empty', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'happy-stacks-cred-paths-'));
+  const out = resolveStackCredentialPaths({ cliHomeDir: dir, serverUrl: '' });
+  assert.equal(out.urlHashServerId, 'default');
+  assert.equal(out.activeServerId, 'default');
+  assert.ok(out.serverScopedPath.endsWith('/servers/default/access.key'));
+});
+
 test('findExistingStackCredentialPath prefers server-scoped credentials', async () => {
   const dir = await mkdtemp(join(tmpdir(), 'happy-stacks-cred-paths-'));
   const serverUrl = 'http://127.0.0.1:3009';

package/scripts/utils/auth/orchestrated_stack_auth_flow.mjs

@@ -19,15 +19,76 @@ function appendCauseText(baseMessage, cause) {
   return `${msg}\n\n[auth] Cause: ${c}`;
 }
 
+async function readTextWithTimeout(path, { timeoutMs = 1200 } = {}) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const res = await fetch(path, { signal: controller.signal });
+    clearTimeout(timer);
+    return { ok: res.ok, status: res.status };
+  } catch (error) {
+    return { ok: false, status: 0, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function formatPidStatus(label, pidRaw) {
+  const pid = Number(pidRaw);
+  if (!Number.isFinite(pid) || pid <= 1) return `[auth] ${label}: unavailable`;
+  return `[auth] ${label}: ${pid} (${isPidAlive(pid) ? 'alive' : 'stale/dead'})`;
+}
+
+function formatLogPath(label, logPath) {
+  const p = String(logPath ?? '').trim();
+  return p ? `[auth] ${label}: ${p}` : `[auth] ${label}: unavailable`;
+}
+
+async function appendRuntimeHealthDiagnostics(message, stackName) {
+  const name = String(stackName ?? '').trim() || 'main';
+  const statePath = getStackRuntimeStatePath(name);
+
+  const state = await readStackRuntimeStateFile(statePath).catch(() => null);
+  if (!state || typeof state !== 'object') {
+    return `${message}\n\n[auth] Stack runtime state unavailable: ${statePath}`;
+  }
+
+  const serverPort = Number(state?.ports?.server);
+  let serverHealth = 'not configured';
+  if (Number.isFinite(serverPort) && serverPort > 0) {
+    const probe = await readTextWithTimeout(`http://127.0.0.1:${serverPort}/health`, { timeoutMs: 1200 });
+    if (probe.ok) {
+      serverHealth = `HTTP ${probe.status}`;
+    } else if (probe.error) {
+      serverHealth = probe.error;
+    } else {
+      serverHealth = `HTTP ${probe.status}`;
+    }
+  }
+
+  const runtimeSummary = [
+    `[auth] Stack runtime path: ${statePath}`,
+    formatPidStatus('ownerPid', state?.ownerPid),
+    formatPidStatus('serverPid', state?.processes?.serverPid),
+    formatPidStatus('expoPid', state?.processes?.expoPid),
+    formatPidStatus('expoTailscaleForwarderPid', state?.processes?.expoTailscaleForwarderPid),
+    `[auth] server port: ${Number.isFinite(serverPort) && serverPort > 0 ? serverPort : 'unconfigured'}`,
+    `[auth] server health: ${serverHealth}`,
+    formatLogPath('runner log', state?.logs?.runner),
+    formatLogPath('cli log', state?.logs?.cli),
+  ].join('\n');
+
+  return `${String(message ?? '').trim()}\n\n${runtimeSummary}`;
+}
+
 async function appendRunnerLogTailDiagnostics({ message, stackName, lines = 140 }) {
   const base = String(message ?? '').trim();
   const logPath = await resolveRunnerLogPathFromRuntime({ stackName, waitMs: 1000, pollMs: 100 }).catch(() => '');
-  if (!logPath) return base;
+  const withState = await appendRuntimeHealthDiagnostics(base, stackName).catch(() => base);
+  if (!logPath) return withState;
   const tail = await readLastLines(logPath, lines).catch(() => null);
   if (!tail || !String(tail).trim()) {
-    return `${base}\n\n[auth] Stack runner log: ${logPath}`;
+    return `${withState}\n\n[auth] Stack runner log: ${logPath}`;
   }
-  return `${base}\n\n[auth] Stack runner log: ${logPath}\n\n[auth] Last runner log lines:\n${String(tail).trimEnd()}`;
+  return `${withState}\n\n[auth] Stack runner log: ${logPath}\n\n[auth] Last runner log lines:\n${String(tail).trimEnd()}`;
 }
 
 async function tryStartStackUiInBackgroundForAuth({ rootDir, stackName, env = process.env } = {}) {

package/scripts/utils/auth/stable_scope_id.mjs

@@ -50,7 +50,7 @@ export function buildStackStableScopeId({ stackName = 'main', cliIdentity = 'def
   if (isScopeIdSafe(compact)) return compact;
 
   const fallback = `stack_${hash}`;
-  return isScopeIdSafe(fallback) ? fallback : 'cloud';
+  return isScopeIdSafe(fallback) ? fallback : 'stack-default';
 }
 
 export function isStableScopeDisabled(env = process.env) {

package/scripts/utils/auth/stack_guided_login.mjs

@@ -5,7 +5,6 @@ import { setTimeout as delay } from 'node:timers/promises';
 
 import { run, runCapture } from '../proc/proc.mjs';
 import { preferStackLocalhostUrl } from '../paths/localhost_host.mjs';
-import { guidedStackWebSignupThenLogin } from './guided_stack_web_login.mjs';
 import { getComponentDir, resolveStackEnvPath } from '../paths/paths.mjs';
 import { getExpoStatePaths, isStateProcessRunning, looksLikeExpoMetro } from '../expo/expo.mjs';
 import { resolveLocalhostHost } from '../paths/localhost_host.mjs';
@@ -411,11 +410,6 @@ export async function guidedStackAuthLoginNow({ rootDir, stackName, env = proces
     await assertExpoWebappBundlesOrThrow({ rootDir, stackName: name, webappUrl: resolved });
   }
 
-  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-  if (interactive) {
-    await guidedStackWebSignupThenLogin({ webappUrl: resolved, stackName: name });
-  }
-
   const preparedEnv = await prepareCoreAuthEnv({ stackName: name, webappUrl: resolved, env });
   const inv = buildStackAuthLoginInvocation({ rootDir, stackName: name, webappUrl: resolved, env: preparedEnv });
   await run(process.execPath, inv.args, { cwd: rootDir, env: inv.env });

package/scripts/utils/cli/cli_registry.mjs

@@ -226,7 +226,7 @@ export function gethstackRegistry() {
       name: 'tui',
       kind: 'node',
       scriptRelPath: 'scripts/tui.mjs',
-      rootUsage: 'hstack tui <hstack args...> [--json]',
+      rootUsage: 'hstack tui [<hstack args...>] [--json]',
       description: 'Run hstack commands in a split-pane TUI',
     },
     {
@@ -244,6 +244,27 @@ export function gethstackRegistry() {
       rootUsage: 'hstack self-host install|status|update|rollback|uninstall [--json]',
       description: 'Happier Self-Host guided install and lifecycle',
     },
+    {
+      name: 'remote',
+      kind: 'node',
+      scriptRelPath: 'scripts/remote_cmd.mjs',
+      rootUsage:
+        [
+          'hstack remote daemon setup --ssh <user@host> [--preview|--stable] [--channel <stable|preview>] [--service <user|none>] [--server-url=<url>] [--webapp-url=<url>] [--public-server-url=<url>] [--json]',
+          'hstack remote server setup --ssh <user@host> [--preview|--stable] [--channel <stable|preview>] [--mode <user|system>] [--env KEY=VALUE]... [--json]',
+        ],
+      description: 'Remote setup helpers (SSH daemon/server setup)',
+    },
+    {
+      name: 'providers',
+      kind: 'node',
+      scriptRelPath: 'scripts/providers_cmd.mjs',
+      rootUsage: [
+        'hstack providers list [--json]',
+        'hstack providers install --providers=<id1,id2> [--dry-run] [--force] [--json]',
+      ],
+      description: 'Install and manage provider CLIs',
+    },
     {
       name: 'auth',
       kind: 'node',
@@ -301,6 +322,13 @@ export function gethstackRegistry() {
       rootUsage: 'hstack service <install|uninstall|status|start|stop|restart|enable|disable|logs|tail>',
       description: 'LaunchAgent service management',
     },
+    {
+      name: 'logs',
+      kind: 'node',
+      scriptRelPath: 'scripts/logs.mjs',
+      rootUsage: 'hstack logs [--component=auto|all|runner|server|expo|ui|daemon|service] [--lines N] [--follow]',
+      description: 'View stack logs (runner/server/expo/daemon/service)',
+    },
     {
       name: 'menubar',
       kind: 'node',
@@ -321,8 +349,7 @@ export function gethstackRegistry() {
     { name: 'stack:fix', kind: 'node', scriptRelPath: 'scripts/doctor.mjs', argsFromRest: (rest) => ['--fix', ...rest], hidden: true },
 
     { name: 'cli:link', kind: 'node', scriptRelPath: 'scripts/cli-link.mjs', hidden: true },
-    { name: 'logs', kind: 'node', scriptRelPath: 'scripts/service.mjs', argsFromRest: (rest) => ['logs', ...rest], hidden: true },
-    { name: 'logs:tail', kind: 'node', scriptRelPath: 'scripts/service.mjs', argsFromRest: (rest) => ['tail', ...rest], hidden: true },
+    { name: 'logs:tail', kind: 'node', scriptRelPath: 'scripts/logs.mjs', argsFromRest: (rest) => ['tail', ...rest], hidden: true },
 
     {
       name: 'service:status',

package/scripts/utils/cli/normalize.mjs

@@ -3,6 +3,7 @@ export function normalizeProfile(raw) {
   if (!v) return '';
   if (v === 'selfhost' || v === 'self-host' || v === 'self_host' || v === 'host') return 'selfhost';
   if (v === 'dev' || v === 'developer' || v === 'develop' || v === 'development') return 'dev';
+  if (v === 'local-repo' || v === 'localrepo' || v === 'local' || v === 'repo') return 'local-repo';
   return '';
 }
 

package/scripts/utils/cli/progress.mjs

@@ -27,6 +27,14 @@ function colorSpinner(frame) {
 }
 
 export function createStepPrinter({ enabled = true } = {}) {
+  if (!enabled) {
+    return {
+      start: () => {},
+      stop: () => {},
+      info: () => {},
+    };
+  }
+
   const tty = enabled && isTty();
   const frames = spinnerFrames();
   let timer = null;
@@ -138,4 +146,3 @@ export async function runCommandLogged({
   err.logPath = logPath;
   throw err;
 }
-

package/scripts/utils/cli/progress.test.mjs

@@ -0,0 +1,43 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { runCommandLogged } from './progress.mjs';
+
+test('runCommandLogged does not print progress when showSteps=false', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'happier-stack-progress-'));
+  const logPath = join(dir, 'log.txt');
+
+  const origWrite = process.stdout.write;
+  let stdout = '';
+  process.stdout.write = ((chunk, encoding, cb) => {
+    stdout += typeof chunk === 'string' ? chunk : chunk.toString(typeof encoding === 'string' ? encoding : 'utf8');
+    if (typeof cb === 'function') cb();
+    return true;
+  });
+
+  try {
+    const res = await runCommandLogged({
+      label: 'noop',
+      cmd: process.execPath,
+      args: ['-e', "process.stdout.write('hello')"],
+      cwd: process.cwd(),
+      env: process.env,
+      logPath,
+      showSteps: false,
+      quiet: true,
+    });
+
+    assert.equal(res.ok, true);
+    assert.equal(stdout, '');
+
+    const logged = await readFile(logPath, 'utf8');
+    assert.ok(logged.includes('hello'));
+  } finally {
+    process.stdout.write = origWrite;
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+

package/scripts/utils/dev/expo_dev.buildEnv.test.mjs

@@ -33,3 +33,20 @@ test('buildExpoDevEnv does not inject auth auto-restore env vars', () => {
   assert.equal(env.EXPO_PUBLIC_HAPPIER_STACK_DEV_AUTH_ENCRYPTION_MACHINE_KEY, undefined);
 });
 
+test('buildExpoDevEnv forces stack context in stack mode even when base env sets a different context', () => {
+  const baseEnv = {
+    ...process.env,
+    EXPO_PUBLIC_HAPPY_SERVER_CONTEXT: 'custom',
+  };
+
+  const env = buildExpoDevEnv({
+    baseEnv,
+    apiServerUrl: 'http://localhost:3013',
+    wantDevClient: false,
+    wantWeb: true,
+    stackMode: true,
+    stackName: 'qa-agent-2',
+  });
+
+  assert.equal(env.EXPO_PUBLIC_HAPPY_SERVER_CONTEXT, 'stack');
+});

package/scripts/utils/dev/expo_dev.mjs

@@ -10,7 +10,8 @@ import {
   writePidState,
 } from '../expo/expo.mjs';
 import { pickExpoDevMetroPort } from '../expo/metro_ports.mjs';
-import { recordStackRuntimeUpdate } from '../stack/runtime_state.mjs';
+import { ensureEnvFileUpdated } from '../env/env_file.mjs';
+import { isPidAlive, recordStackRuntimeUpdate } from '../stack/runtime_state.mjs';
 import { killProcessGroupOwnedByStack } from '../proc/ownership.mjs';
 import { expoSpawn } from '../expo/command.mjs';
 import { resolveMobileExpoConfig } from '../mobile/config.mjs';
@@ -204,6 +205,10 @@ function expoModeLabel({ wantWeb, wantDevClient }) {
   return 'disabled';
 }
 
+function normalizeApiServerUrl(raw) {
+  return String(raw ?? '').trim().replace(/\/+$/, '');
+}
+
 export function buildExpoDevEnv({
   baseEnv,
   apiServerUrl,
@@ -229,7 +234,7 @@ export function buildExpoDevEnv({
     : apiServerUrl;
 
   env.EXPO_PUBLIC_HAPPY_SERVER_URL = effectiveApiServerUrl;
-  if (stackMode && !env.EXPO_PUBLIC_HAPPY_SERVER_CONTEXT) {
+  if (stackMode) {
     env.EXPO_PUBLIC_HAPPY_SERVER_CONTEXT = 'stack';
   }
   env.EXPO_PUBLIC_DEBUG = env.EXPO_PUBLIC_DEBUG ?? '1';
@@ -314,6 +319,7 @@ export async function ensureDevExpoServer({
 
   const running = await isStateProcessRunning(paths.statePath);
   const alreadyRunning = Boolean(running.running);
+  const desiredApiServerUrl = normalizeApiServerUrl(apiServerUrl);
 
   // Resolve Tailscale forwarding preference
   const wantTailscale = resolveExpoTailscaleEnabled({ env: baseEnv, expoTailscale });
@@ -344,8 +350,25 @@ export async function ensureDevExpoServer({
     }).catch(() => {});
   };
 
-  if (alreadyRunning && !restart) {
-    const pid = Number(running.state?.pid);
+  const runningStateApiServerUrl = normalizeApiServerUrl(running.state?.apiServerUrl);
+  const shouldRestartForApiServerMismatch =
+    alreadyRunning &&
+    !restart &&
+    stackMode &&
+    wantWeb &&
+    desiredApiServerUrl &&
+    runningStateApiServerUrl !== desiredApiServerUrl;
+  // In stack mode, never adopt "running by port probe only" state. It may belong to a
+  // different stack/session and has no reliable owned pid for lifecycle control.
+  const shouldRestartForPortFallbackInStackMode =
+    alreadyRunning &&
+    !restart &&
+    stackMode &&
+    running.reason === 'port';
+
+  if (alreadyRunning && !restart && !shouldRestartForApiServerMismatch && !shouldRestartForPortFallbackInStackMode) {
+    const statePid = Number(running.state?.pid);
+    const pid = Number.isFinite(statePid) && statePid > 1 && isPidAlive(statePid) ? statePid : null;
     const port = Number(running.state?.port);
 
     // Capability check: refuse to spawn a second Expo, so if the existing process doesn't match the
@@ -369,12 +392,19 @@ export async function ensureDevExpoServer({
       ok: true,
       skipped: true,
       reason: 'already_running',
-      pid: Number.isFinite(pid) ? pid : null,
+      pid: Number.isFinite(pid) && pid > 1 ? pid : null,
       port: Number.isFinite(port) ? port : null,
       mode: expoModeLabel({ wantWeb, wantDevClient }),
     };
   }
 
+  if (shouldRestartForApiServerMismatch && !quiet) {
+    // eslint-disable-next-line no-console
+    console.log(
+      `[local] expo: restarting to align API server URL (running=${runningStateApiServerUrl || 'unset'}, wanted=${desiredApiServerUrl}).`
+    );
+  }
+
   const reservedMetroPorts = new Set();
 
   if (restart && running.state?.pid) {
@@ -399,7 +429,30 @@ export async function ensureDevExpoServer({
     stackName,
     reservedPorts: reservedMetroPorts,
   });
+  const forcedPortRaw = (baseEnv?.HAPPIER_STACK_EXPO_DEV_PORT ?? '').toString().trim();
+  const forcedPortNum = Number(forcedPortRaw);
+  if (
+    stackMode &&
+    envPath &&
+    forcedPortRaw &&
+    Number.isFinite(forcedPortNum) &&
+    forcedPortNum > 0 &&
+    forcedPortNum !== metroPort
+  ) {
+    if (!quiet) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `[local] expo: requested metro port ${forcedPortNum} is not available; using ${metroPort}.\n` +
+          `[local] expo: updating ${envPath} so future runs keep stable ports.`
+      );
+    }
+    await ensureEnvFileUpdated({
+      envPath,
+      updates: [{ key: 'HAPPIER_STACK_EXPO_DEV_PORT', value: String(metroPort) }],
+    }).catch(() => {});
+  }
   env.RCT_METRO_PORT = String(metroPort);
+  env.HAPPIER_STACK_EXPO_DEV_PORT = String(metroPort);
   const host = resolveExpoDevHost({ env });
   const args = buildExpoStartArgs({
     port: metroPort,
@@ -457,6 +510,7 @@ export async function ensureDevExpoServer({
       webEnabled: wantWeb,
       devClientEnabled: wantDevClient,
       host,
+      apiServerUrl: desiredApiServerUrl || null,
       scheme: wantDevClient ? scheme : null,
       tailscaleEnabled: wantTailscale,
       tailscaleForwarderPid: tailscaleResult?.pid ?? null,