happy-stacks 0.6.12 → 0.6.13

package/scripts/review_pr.mjs

@@ -22,6 +22,13 @@ function usage() {
     '[review-pr] usage:',
     '  happys review-pr --happy=<pr-url|number> [--happy-server-light=<pr-url|number>] [--name=<stack>] [--dev|--start] [--mobile|--no-mobile] [--forks|--upstream] [--seed-auth|--no-seed-auth] [--copy-auth-from=<stack>] [--link-auth|--copy-auth] [--update] [--force] [--keep-sandbox] [--json] [-- <stack dev/start args...>]',
     '',
+    'VM port forwarding (optional):',
+    '- `--vm-ports`: convenience preset for port-forwarded VMs (stack ports ~13xxx, Expo ports ~18xxx)',
+    '- `--stack-port-start=<n>`: sets HAPPY_STACKS_STACK_PORT_START inside the sandbox',
+    '- `--expo-dev-port-strategy=stable|ephemeral`: sets HAPPY_STACKS_EXPO_DEV_PORT_STRATEGY inside the sandbox',
+    '- `--expo-dev-port-base=<n>` / `--expo-dev-port-range=<n>`: stable Expo port hashing params',
+    '- `--expo-dev-port=<n>`: force the Expo dev (Metro) port inside the sandbox',
+    '',
     'What it does:',
     '- creates a temporary sandbox dir',
     '- runs `happys setup-pr ...` inside that sandbox (fully isolated state)',
@@ -70,6 +77,64 @@ function kvValue(argv, names) {
   return null;
 }
 
+function stripArgv(argv, names) {
+  const out = [];
+  for (const a of argv) {
+    let keep = true;
+    for (const n of names) {
+      if (a === n || a.startsWith(`${n}=`)) {
+        keep = false;
+        break;
+      }
+    }
+    if (keep) out.push(a);
+  }
+  return out;
+}
+
+function resolveSandboxPortEnvOverrides(argv) {
+  const overrides = {};
+
+  // Convenience preset for VM review flows (pairs with Lima port-forward ranges in docs).
+  if (argvHasFlag(argv, ['--vm-ports'])) {
+    overrides.HAPPY_STACKS_STACK_PORT_START = '13005';
+    overrides.HAPPY_LOCAL_STACK_PORT_START = '13005';
+
+    // Keep Expo dev ports stable per stack so forwarded ports remain predictable.
+    overrides.HAPPY_STACKS_EXPO_DEV_PORT_STRATEGY = 'stable';
+    overrides.HAPPY_STACKS_EXPO_DEV_PORT_BASE = '18081';
+    overrides.HAPPY_STACKS_EXPO_DEV_PORT_RANGE = '1000';
+  }
+
+  const stackPortStart = (kvValue(argv, ['--stack-port-start']) ?? '').trim();
+  if (stackPortStart) {
+    overrides.HAPPY_STACKS_STACK_PORT_START = stackPortStart;
+    overrides.HAPPY_LOCAL_STACK_PORT_START = stackPortStart;
+  }
+
+  const expoStrategy = (kvValue(argv, ['--expo-dev-port-strategy']) ?? '').trim().toLowerCase();
+  if (expoStrategy === 'stable' || expoStrategy === 'ephemeral') {
+    overrides.HAPPY_STACKS_EXPO_DEV_PORT_STRATEGY = expoStrategy;
+  }
+
+  const expoBase = (kvValue(argv, ['--expo-dev-port-base']) ?? '').trim();
+  if (expoBase) {
+    overrides.HAPPY_STACKS_EXPO_DEV_PORT_BASE = expoBase;
+  }
+
+  const expoRange = (kvValue(argv, ['--expo-dev-port-range']) ?? '').trim();
+  if (expoRange) {
+    overrides.HAPPY_STACKS_EXPO_DEV_PORT_RANGE = expoRange;
+  }
+
+  const expoForced = (kvValue(argv, ['--expo-dev-port']) ?? '').trim();
+  if (expoForced) {
+    overrides.HAPPY_STACKS_EXPO_DEV_PORT = expoForced;
+  }
+
+  return Object.keys(overrides).length ? overrides : null;
+}
+
 async function main() {
   const rootDir = getRootDir(import.meta.url);
   const argv = process.argv.slice(2);
@@ -244,9 +309,20 @@ async function main() {
     const hasNameFlag = argvWithDefaults.some((a) => a === '--name' || a.startsWith('--name='));
     const argvFinal = hasNameFlag ? argvWithDefaults : [...argvWithDefaults, `--name=${effectiveStackName}`];
 
-    child = spawn(process.execPath, [bin, '--sandbox-dir', sandboxDir, 'setup-pr', ...argvFinal], {
+    // Sandbox-only port overrides (useful for VM testing where host port-forwarding expects specific ranges).
+    const portEnv = resolveSandboxPortEnvOverrides(argvFinal);
+    const argvForSetupPr = stripArgv(argvFinal, [
+      '--vm-ports',
+      '--stack-port-start',
+      '--expo-dev-port-strategy',
+      '--expo-dev-port-base',
+      '--expo-dev-port-range',
+      '--expo-dev-port',
+    ]);
+
+    child = spawn(process.execPath, [bin, '--sandbox-dir', sandboxDir, 'setup-pr', ...argvForSetupPr], {
       cwd: rootDir,
-      env: process.env,
+      env: portEnv ? { ...process.env, ...portEnv } : process.env,
       stdio: 'inherit',
     });
  

package/scripts/run.mjs

@@ -271,11 +271,12 @@ async function main() {
       : `file:${join(dataDir, 'happy-server-light.sqlite')}`;
 
     // Reliability: ensure DB schema exists before daemon hits /v1/machines (health checks don't cover DB readiness).
+    // If the server is already running and we are not restarting, do NOT run migrations here (SQLite can lock).
     const acct = await getAccountCountForServerComponent({
       serverComponentName,
       serverDir,
       env: serverEnv,
-      bestEffort: false,
+      bestEffort: Boolean(serverAlreadyRunning && !restart),
     });
     serverLightAccountCount = typeof acct.accountCount === 'number' ? acct.accountCount : null;
   }

package/scripts/stack.mjs

@@ -2,7 +2,7 @@ import './utils/env/env.mjs';
 import { spawn } from 'node:child_process';
 import { chmod, copyFile, mkdir, open, readFile, readdir, rename, writeFile } from 'node:fs/promises';
 import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 // NOTE: random bytes usage centralized in scripts/utils/crypto/tokens.mjs
 import { homedir } from 'node:os';
 import { ensureDir, readTextIfExists, readTextOrEmpty } from './utils/fs/ops.mjs';
@@ -64,6 +64,7 @@ import {
 } from './utils/stack/runtime_state.mjs';
 import { killPid } from './utils/expo/expo.mjs';
 import { getCliHomeDirFromEnvOrDefault, getServerLightDataDirFromEnvOrDefault } from './utils/stack/dirs.mjs';
+import { parseCliIdentityOrThrow, resolveCliHomeDirForIdentity } from './utils/stack/cli_identities.mjs';
 import { randomToken } from './utils/crypto/tokens.mjs';
 import { killPidOwnedByStack, killProcessGroupOwnedByStack } from './utils/proc/ownership.mjs';
 import { sanitizeSlugPart } from './utils/git/refs.mjs';
@@ -1432,10 +1433,12 @@ async function cmdRunScript({ rootDir, stackName, scriptPath, args, extraEnv = {
           return;
         }
 
+        let exit = { code: null, sig: null, ok: false };
         try {
           await new Promise((resolvePromise, rejectPromise) => {
             child.on('error', rejectPromise);
             child.on('exit', (code, sig) => {
+              exit = { code: code ?? null, sig: sig ?? null, ok: code === 0 };
               if (code === 0) return resolvePromise();
               return rejectPromise(new Error(`stack ${scriptPath} exited (code=${code ?? 'null'}, sig=${sig ?? 'null'})`));
             });
@@ -1443,7 +1446,26 @@ async function cmdRunScript({ rootDir, stackName, scriptPath, args, extraEnv = {
         } finally {
           const cur = await readStackRuntimeStateFile(runtimeStatePath);
           if (Number(cur?.ownerPid) === Number(child.pid)) {
-            await deleteStackRuntimeStateFile(runtimeStatePath);
+            // Only delete runtime state when we're confident no child processes are left behind.
+            // If the runner crashes but a child (server/expo/daemon) stays alive, keeping stack.runtime.json
+            // allows `happys stack stop --aggressive` to kill the recorded PIDs safely.
+            const processes = cur?.processes && typeof cur.processes === 'object' ? cur.processes : {};
+            const anyAlive = Object.values(processes)
+              .map((p) => Number(p))
+              .some((pid) => Number.isFinite(pid) && pid > 1 && isPidAlive(pid));
+            const portRaw = cur?.ports && typeof cur.ports === 'object' ? cur.ports.server : null;
+            const port = Number(portRaw);
+            const portOccupied =
+              Number.isFinite(port) && port > 0 ? !(await isTcpPortFree(port, { host: '127.0.0.1' }).catch(() => true)) : false;
+
+            if (!anyAlive && !portOccupied) {
+              await deleteStackRuntimeStateFile(runtimeStatePath);
+            } else if (!wantsJson) {
+              console.warn(
+                `[stack] ${stackName}: preserving ${runtimeStatePath} after runner exit (child processes still alive). ` +
+                  `Run: happys stack stop ${stackName} --yes --aggressive`
+              );
+            }
           }
         }
         return;
@@ -3129,7 +3151,7 @@ async function cmdPrStack({ rootDir, argv }) {
 
   // Monorepo shortcut:
   // If `--happy=<pr>` was provided and the local checkout is the slopus/happy monorepo, pin
-  // happy-cli and (optionally) happy-server to that same worktree without fetching separate PRs.
+  // happy-cli and server flavors to that same worktree without fetching separate PRs.
   if (happyMonorepoActive && prHappy) {
     const happyWt = worktrees.find((w) => w?.component === 'happy');
     const happyPath = String(happyWt?.path ?? '').trim();
@@ -3147,11 +3169,26 @@ async function cmdPrStack({ rootDir, argv }) {
     const derivedComponents = [
       'happy-cli',
       ...(serverComponent === 'happy-server' ? ['happy-server'] : []),
+      // If the user didn't explicitly provide a separate server-light PR, prefer the monorepo server/ dir.
+      ...(serverComponent === 'happy-server-light' && !prServerLight ? ['happy-server-light'] : []),
     ];
 
     for (const c of derivedComponents) {
       const p = derive(c);
       if (!p) continue;
+      if (c === 'happy-server-light') {
+        const hasSqliteSchema =
+          existsSync(join(p, 'prisma', 'sqlite', 'schema.prisma')) || existsSync(join(p, 'prisma', 'schema.sqlite.prisma'));
+        if (!hasSqliteSchema) {
+          throw new Error(
+            '[stack] pr: happy-server-light was requested, but the monorepo server checkout does not include sqlite schema support.\n' +
+              `- expected one of:\n` +
+              `  - ${join(p, 'prisma', 'sqlite', 'schema.prisma')}\n` +
+              `  - ${join(p, 'prisma', 'schema.sqlite.prisma')}\n` +
+              'Fix: either switch to the full server flavor (--server=happy-server), or provide an explicit --happy-server-light=<pr>.'
+          );
+        }
+      }
       if (!isComponentWorktreePath({ rootDir, component: c, dir: p, env: process.env })) {
         throw new Error(`[stack] pr: refusing to pin ${c} because the derived path is not a worktree: ${p}`);
       }
@@ -3376,27 +3413,30 @@ async function cmdStackOpen({ rootDir, stackName, json, includeStackDir, include
 }
 
 async function cmdStackDaemon({ rootDir, stackName, argv, json }) {
-  const { flags } = parseArgs(argv);
+  const { flags, kv } = parseArgs(argv);
   const wantsHelpFlag = wantsHelp(argv, { flags });
 
   const positionals = argv.filter((a) => a && a !== '--' && !a.startsWith('--'));
   const action = (positionals[0] ?? 'status').toString().trim();
+  const identity = parseCliIdentityOrThrow((kv.get('--identity') ?? '').trim());
+  const noOpen = flags.has('--no-open') || flags.has('--no-browser') || flags.has('--no-browser-open');
 
   if (wantsHelpFlag || !action || action === 'help') {
     printResult({
       json,
-      data: { ok: true, stackName, commands: ['start', 'stop', 'restart', 'status'] },
+      data: { ok: true, stackName, commands: ['start', 'stop', 'restart', 'status'], flags: ['--identity=<name>'] },
       text: [
         banner('stack daemon', { subtitle: `Manage the happy-cli daemon for stack ${cyan(stackName || 'main')}.` }),
         '',
         sectionTitle('usage:'),
-        `  ${cyan('happys stack daemon')} <name> status [--json]`,
-        `  ${cyan('happys stack daemon')} <name> start [--json]`,
-        `  ${cyan('happys stack daemon')} <name> stop [--json]`,
-        `  ${cyan('happys stack daemon')} <name> restart [--json]`,
+        `  ${cyan('happys stack daemon')} <name> status [--identity=<name>] [--json]`,
+        `  ${cyan('happys stack daemon')} <name> start [--identity=<name>] [--json]`,
+        `  ${cyan('happys stack daemon')} <name> stop [--identity=<name>] [--json]`,
+        `  ${cyan('happys stack daemon')} <name> restart [--identity=<name>] [--json]`,
         '',
         sectionTitle('example:'),
         `  ${cmdFmt(`happys stack daemon ${stackName || 'main'} restart`)}`,
+        `  ${cmdFmt(`happys stack daemon ${stackName || 'main'} start --identity=account-b`)}`,
       ].join('\n'),
     });
     return;
@@ -3423,37 +3463,106 @@ async function cmdStackDaemon({ rootDir, stackName, argv, json }) {
         (env.HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI ?? env.HAPPY_LOCAL_COMPONENT_DIR_HAPPY_CLI ?? '').toString().trim() ||
         getComponentDir(rootDir, 'happy-cli');
       const cliBin = join(cliDir, 'bin', 'happy.mjs');
-      const cliHomeDir = (env.HAPPY_STACKS_CLI_HOME_DIR ??
+      const baseCliHomeDir = (env.HAPPY_STACKS_CLI_HOME_DIR ??
         env.HAPPY_LOCAL_CLI_HOME_DIR ??
         join(resolveStackEnvPath(stackName).baseDir, 'cli')).toString();
+      const cliHomeDir = resolveCliHomeDirForIdentity({ cliHomeDir: baseCliHomeDir, identity });
       const serverPort = resolveServerPortFromEnv({ env, defaultPort: 3005 });
       const urls = await resolveServerUrls({ env, serverPort, allowEnable: false });
       const internalServerUrl = urls.internalServerUrl;
       const publicServerUrl = urls.publicServerUrl;
-      const daemonEnv = getDaemonEnv({ baseEnv: env, cliHomeDir, internalServerUrl, publicServerUrl });
+      const envForIdentity = {
+        ...env,
+        HAPPY_STACKS_CLI_IDENTITY: identity,
+        HAPPY_LOCAL_CLI_IDENTITY: identity,
+        ...(identity !== 'default'
+          ? {
+              HAPPY_STACKS_MIGRATE_CREDENTIALS: '0',
+              HAPPY_LOCAL_MIGRATE_CREDENTIALS: '0',
+              HAPPY_STACKS_AUTO_AUTH_SEED: '0',
+              HAPPY_LOCAL_AUTO_AUTH_SEED: '0',
+            }
+          : {}),
+      };
+      await mkdir(cliHomeDir, { recursive: true }).catch(() => {});
+      const daemonEnv = getDaemonEnv({ baseEnv: envForIdentity, cliHomeDir, internalServerUrl, publicServerUrl });
 
       if (action === 'start' || action === 'restart') {
+        // UX: if this identity is not authenticated yet and we're in a real TTY, offer to run the
+        // guided login flow inline (instead of failing or asking for a second terminal).
+        //
+        // Important: never prompt in --json mode (automation must not hang).
+        const accessKeyPath = join(cliHomeDir, 'access.key');
+        const hasCreds = (() => {
+          try {
+            if (!existsSync(accessKeyPath)) return false;
+            return readFileSync(accessKeyPath, 'utf-8').trim().length > 0;
+          } catch {
+            return false;
+          }
+        })();
+
+        if (!hasCreds) {
+          if (json) {
+            const loginCmd = `happys stack auth ${stackName} login${identity !== 'default' ? ` --identity=${identity} --no-open` : ''}`;
+            return { ok: false, action, error: 'auth_required', cliIdentity: identity, cliHomeDir, loginCmd };
+          }
+
+          if (isTty()) {
+            const choice = await withRl(async (rl) => {
+              return await promptSelect(rl, {
+                title:
+                  `Daemon identity "${identity}" is not authenticated yet.\n` +
+                  `Authenticate now? (recommended)\n`,
+                options: [
+                  { label: 'yes (run guided login now)', value: 'yes' },
+                  { label: 'no (show command and exit)', value: 'no' },
+                ],
+                defaultIndex: 0,
+              });
+            });
+
+            if (choice === 'yes') {
+              const authArgs = [
+                'login',
+                ...(identity !== 'default' ? [`--identity=${identity}`] : []),
+                ...(identity !== 'default' || noOpen ? ['--no-open'] : []),
+              ];
+              await run(process.execPath, [join(rootDir, 'scripts', 'auth.mjs'), ...authArgs], {
+                cwd: rootDir,
+                env: envForIdentity,
+                stdio: 'inherit',
+              });
+            } else {
+              const loginCmd = `happys stack auth ${stackName} login${identity !== 'default' ? ` --identity=${identity} --no-open` : ''}`;
+              throw new Error(`[stack] daemon auth required. Run:\n${loginCmd}`);
+            }
+          }
+        }
+
         await startLocalDaemonWithAuth({
           cliBin,
           cliHomeDir,
           internalServerUrl,
           publicServerUrl,
+          isShuttingDown: () => false,
           forceRestart: action === 'restart',
-          env,
+          env: envForIdentity,
           stackName,
+          cliIdentity: identity,
         });
         const status = await runCapture(process.execPath, [cliBin, 'daemon', 'status'], { cwd: rootDir, env: daemonEnv });
-        return { ok: true, action, status: status.trim() };
+        return { ok: true, action, cliIdentity: identity, cliHomeDir, status: status.trim() };
       }
 
       if (action === 'stop') {
         await stopLocalDaemon({ cliBin, internalServerUrl, cliHomeDir });
         const status = await runCapture(process.execPath, [cliBin, 'daemon', 'status'], { cwd: rootDir, env: daemonEnv }).catch(() => '');
-        return { ok: true, action, status: status.trim() || null };
+        return { ok: true, action, cliIdentity: identity, cliHomeDir, status: status.trim() || null };
       }
 
       const status = await runCapture(process.execPath, [cliBin, 'daemon', 'status'], { cwd: rootDir, env: daemonEnv });
-      return { ok: true, action, status: status.trim() };
+      return { ok: true, action, cliIdentity: identity, cliHomeDir, status: status.trim() };
     },
   });
 
@@ -3472,12 +3581,91 @@ async function cmdStackDaemon({ rootDir, stackName, argv, json }) {
   console.log(`${green('✓')} daemon command completed`);
 }
 
+const STACK_NAME_FIRST_SUPPORTED_COMMANDS = new Set([
+  'help',
+  'new',
+  'edit',
+  'list',
+  'migrate',
+  'audit',
+  'archive',
+  'duplicate',
+  'info',
+  'pr',
+  'create-dev-auth-seed',
+  'daemon',
+  'happy',
+  'env',
+  'auth',
+  'dev',
+  'start',
+  'build',
+  'review',
+  'typecheck',
+  'lint',
+  'test',
+  'doctor',
+  'mobile',
+  'mobile:install',
+  'mobile-dev-client',
+  'resume',
+  'stop',
+  'code',
+  'cursor',
+  'open',
+  'srv',
+  'wt',
+  'service',
+]);
+
+function isKnownStackCommandToken(token) {
+  const t = (token ?? '').toString().trim();
+  if (!t) return false;
+  if (t.startsWith('service:')) return true;
+  if (t.startsWith('tailscale:')) return true;
+  return STACK_NAME_FIRST_SUPPORTED_COMMANDS.has(t);
+}
+
+function normalizeStackNameFirstArgs(argv) {
+  // Back-compat UX:
+  // Allow `happys stack <name> <command> ...` (stack name first) as a shortcut for:
+  //   `happys stack <command> <name> ...`
+  //
+  // We only apply this rewrite when the first positional is *not* a known stack subcommand,
+  // but *is* an existing stack name.
+  const args = Array.isArray(argv) ? argv : [];
+  const positionalIdx = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!a) continue;
+    if (a === '--') continue;
+    if (a.startsWith('-')) continue;
+    positionalIdx.push(i);
+    if (positionalIdx.length >= 2) break;
+  }
+  if (positionalIdx.length < 2) return args;
+
+  const [i0, i1] = positionalIdx;
+  const first = args[i0];
+  const second = args[i1];
+
+  if (isKnownStackCommandToken(first)) return args;
+  if (!isKnownStackCommandToken(second)) return args;
+  if (!stackExistsSync(first)) return args;
+
+  const next = [...args];
+  next[i0] = second;
+  next[i1] = first;
+  return next;
+}
+
 async function main() {
   const rootDir = getRootDir(import.meta.url);
   // pnpm (legacy) passes an extra leading `--` when forwarding args into scripts. Normalize it away so
   // positional slicing behaves consistently.
   const rawArgv = process.argv.slice(2);
-  const argv = rawArgv[0] === '--' ? rawArgv.slice(1) : rawArgv;
+  const argv0 = rawArgv[0] === '--' ? rawArgv.slice(1) : rawArgv;
+  const argv = normalizeStackNameFirstArgs(argv0);
 
   const { flags } = parseArgs(argv);
   const positionals = argv.filter((a) => !a.startsWith('--'));
@@ -3744,11 +3932,65 @@ async function main() {
     return;
   }
   if (cmd === 'happy') {
-    const args = passthrough[0] === '--' ? passthrough.slice(1) : passthrough;
+    // Allow stack-scoped CLI identity selection:
+    // - `happys stack happy <name> --identity=account-a -- <happy-cli args...>`
+    // - (no passthrough args) `happys stack happy <name> --identity=account-a`
+    //
+    // Implementation detail: we set HAPPY_HOME_DIR (highest precedence) so anything that uses
+    // the CLI home dir (credentials, daemon control, logs, etc.) uses the selected identity.
+    const sepIdx = passthrough.indexOf('--');
+    const wrapperArgs = sepIdx === -1 ? passthrough : passthrough.slice(0, sepIdx);
+    const forwardedArgsRaw = sepIdx === -1 ? passthrough : passthrough.slice(sepIdx + 1);
+
+    // If there is no explicit `--`, treat `--identity=...` tokens as wrapper flags (since there are no
+    // unambiguous happy-cli args to separate).
+    const { kv } = parseArgs(wrapperArgs);
+    const identityRaw = (kv.get('--identity') ?? '').toString().trim();
+    const identity = identityRaw ? parseCliIdentityOrThrow(identityRaw) : null;
+
+    const forwardedArgs =
+      sepIdx === -1
+        ? forwardedArgsRaw.filter((a) => !(identity && typeof a === 'string' && a.trim().startsWith('--identity=')))
+        : forwardedArgsRaw;
+
     await withStackEnv({
       stackName,
       fn: async ({ env }) => {
-        await run(process.execPath, [join(rootDir, 'scripts', 'happy.mjs'), ...args], { cwd: rootDir, env });
+        // NOTE: resolve cli home using the *stack env* we just loaded, not the outer process env.
+        // If identity is set, prefer our explicit HAPPY_HOME_DIR override.
+        const baseCliHomeDir = (env.HAPPY_STACKS_CLI_HOME_DIR ??
+          env.HAPPY_LOCAL_CLI_HOME_DIR ??
+          join(resolveStackEnvPath(stackName).baseDir, 'cli')).toString();
+        const cliHomeDirForIdentity = identity
+          ? resolveCliHomeDirForIdentity({ cliHomeDir: baseCliHomeDir, identity })
+          : baseCliHomeDir;
+        const envForHappy = identity
+          ? {
+              ...env,
+              HAPPY_STACKS_CLI_IDENTITY: identity,
+              HAPPY_LOCAL_CLI_IDENTITY: identity,
+              // Highest-precedence signal for happy-cli: identity-scoped home dir.
+              HAPPY_HOME_DIR: cliHomeDirForIdentity,
+              // Keep stack helpers consistent too (some scripts use *_CLI_HOME_DIR).
+              HAPPY_STACKS_CLI_HOME_DIR: cliHomeDirForIdentity,
+              HAPPY_LOCAL_CLI_HOME_DIR: cliHomeDirForIdentity,
+            }
+          : env;
+
+        // Passthrough: preserve happy-cli output and exit code; avoid wrapper stack traces.
+        const child = spawn(process.execPath, [join(rootDir, 'scripts', 'happy.mjs'), ...forwardedArgs], {
+          cwd: rootDir,
+          env: envForHappy,
+          stdio: 'inherit',
+          shell: false,
+        });
+
+        const exitCode = await new Promise((resolvePromise) => {
+          child.on('error', () => resolvePromise(1));
+          child.on('exit', (code) => resolvePromise(code ?? 1));
+        });
+
+        process.exit(exitCode);
       },
     });
     return;
@@ -3977,6 +4219,10 @@ async function main() {
 }
 
 main().catch((err) => {
-  console.error('[stack] failed:', err);
+  const message = err instanceof Error ? err.message : String(err);
+  console.error('[stack] failed:', message);
+  if (process.env.DEBUG && err instanceof Error && err.stack) {
+    console.error(err.stack);
+  }
   process.exit(1);
 });