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

package/scripts/setup_local_repo_profile.test.mjs

@@ -0,0 +1,178 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { basename, dirname, join } from 'node:path';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+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,
+      });
+    });
+  });
+}
+
+function toDataUrl(source) {
+  return `data:text/javascript,${encodeURIComponent(source)}`;
+}
+
+async function writeHappyMonorepoStub({ repoDir }) {
+  await mkdir(join(repoDir, 'apps', 'ui'), { recursive: true });
+  await mkdir(join(repoDir, 'apps', 'cli'), { recursive: true });
+  await mkdir(join(repoDir, 'apps', 'server'), { recursive: true });
+  await writeFile(join(repoDir, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(repoDir, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(repoDir, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
+}
+
+test('hstack setup --profile=local-repo creates a dedicated stack without bootstrapping/cloning', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-setup-local-repo-'));
+
+  const markerPath = join(tmp, 'calls.log');
+  const loaderPath = join(tmp, 'loader.mjs');
+  const registerPath = join(tmp, 'register.mjs');
+
+  const repoDir = join(tmp, 'repo');
+  await writeHappyMonorepoStub({ repoDir });
+
+  const stubBySpecifier = {
+    './utils/proc/proc.mjs': toDataUrl(`
+import { appendFileSync } from 'node:fs';
+
+const markerPath = ${JSON.stringify(markerPath)};
+function mark(payload) {
+  appendFileSync(markerPath, String(payload) + '\\n', 'utf-8');
+}
+
+export function spawnProc() {
+  return null;
+}
+
+export async function run(_cmd, args, { env } = {}) {
+  mark(JSON.stringify({
+    type: 'run',
+    args,
+    workspace: String(env?.HAPPIER_STACK_WORKSPACE_DIR ?? ''),
+    setupChild: String(env?.HAPPIER_STACK_SETUP_CHILD ?? ''),
+  }));
+  return { status: 0, stdout: '', stderr: '' };
+}
+
+export async function runCapture(_cmd, args, { env } = {}) {
+  mark(JSON.stringify({
+    type: 'runCapture',
+    args,
+    workspace: String(env?.HAPPIER_STACK_WORKSPACE_DIR ?? ''),
+    setupChild: String(env?.HAPPIER_STACK_SETUP_CHILD ?? ''),
+  }));
+  return '';
+}
+`),
+    './utils/env/env_local.mjs': toDataUrl(`
+export async function ensureEnvLocalUpdated() {}
+`),
+    './utils/proc/commands.mjs': toDataUrl(`
+export async function commandExists() { return true; }
+export async function resolveCommandPath(cmd) { return String(cmd ?? ''); }
+export async function runCaptureIfCommandExists() { return ''; }
+`),
+    './utils/stack/stacks.mjs': toDataUrl(`
+export function stackExistsSync() { return false; }
+export async function listAllStackNames() { return ['main']; }
+`),
+    './utils/git/dev_checkout.mjs': toDataUrl(`
+export async function ensureDevCheckout() {
+  throw new Error('ensureDevCheckout should not run for local-repo profile');
+}
+`),
+  };
+
+  const loaderSource = `
+const stubBySpecifier = ${JSON.stringify(stubBySpecifier)};
+
+export async function resolve(specifier, context, defaultResolve) {
+  const stub = stubBySpecifier[specifier];
+  if (stub) return { url: stub, shortCircuit: true };
+  return defaultResolve(specifier, context, defaultResolve);
+}
+`;
+  await writeFile(loaderPath, loaderSource, 'utf-8');
+  await writeFile(registerPath, [
+    `import { register } from 'node:module';`,
+    `register(${JSON.stringify(pathToFileURL(loaderPath).href)}, import.meta.url);`,
+    '',
+  ].join('\n'), 'utf-8');
+
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_TEST_TTY: '1',
+    HAPPIER_STACK_HOME_DIR: join(tmp, 'home'),
+    HAPPIER_STACK_STORAGE_DIR: join(tmp, 'storage'),
+  };
+
+  try {
+    const res = await runNode(
+      [
+        '--import',
+        registerPath,
+        join(rootDir, 'scripts', 'setup.mjs'),
+        '--profile=local-repo',
+        '--server=happier-server-light',
+        '--non-interactive',
+        '--no-auth',
+        '--no-start-now',
+        '--no-autostart',
+        '--no-menubar',
+        '--no-tailscale',
+        `--repo-dir=${repoDir}`,
+      ],
+      { cwd: rootDir, env }
+    );
+
+    assert.equal(res.code, 0, `expected setup to exit 0, got ${res.code}.\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+    const markerText = await readFile(markerPath, 'utf-8');
+    const records = markerText
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+
+    const hasScript = (entry, suffix) => (entry.args ?? []).some((arg) => basename(String(arg)).startsWith(suffix));
+    const initCalls = records.filter((r) => r.type === 'run' && hasScript(r, 'init.mjs'));
+    const installCalls = records.filter((r) => r.type === 'run' && hasScript(r, 'install.mjs'));
+    assert.ok(initCalls.length >= 1, 'expected init command to run');
+    assert.equal(installCalls.length, 0, 'expected bootstrap/install not to run for local-repo profile');
+
+    const stackNewCalls = records.filter(
+      (r) => r.type === 'run' && (r.args ?? []).includes('new') && (r.args ?? []).includes('--non-interactive')
+    );
+    assert.ok(stackNewCalls.length >= 1, 'expected stack creation command to run');
+    const args = stackNewCalls[0]?.args ?? [];
+    assert.ok(args.includes('local'), `expected default stack name "local" in args, got ${JSON.stringify(args)}`);
+    assert.ok(args.some((a) => String(a).startsWith(`--repo=${repoDir}`)), `expected --repo to point at repoDir, got ${JSON.stringify(args)}`);
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});
+

package/scripts/setup_pr.mjs

@@ -19,6 +19,7 @@ import { isSandboxed, sandboxAllowsGlobalSideEffects } from './utils/env/sandbox
 import { sanitizeStackName } from './utils/stack/names.mjs';
 import { getStackRuntimeStatePath, readStackRuntimeStateFile } from './utils/stack/runtime_state.mjs';
 import { readEnvObjectFromFile } from './utils/env/read.mjs';
+import { buildSetupChildEnv } from './utils/setup/child_env.mjs';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
@@ -352,18 +353,19 @@ async function main() {
 
   // Sandbox default: no cross-stack auth reuse unless explicitly allowed.
   const sandboxEffectiveSeedAuth = sandboxNoGlobal ? false : effectiveSeedAuth;
+  const setupChildEnv = buildSetupChildEnv({ baseEnv: process.env });
 
   // If we're going to guide the user through login, start in background first (even in verbose mode)
   // so auth prompts aren't buried in runner logs.
   const needsAuthFlow = interactive && !stackAlreadyAuthed && !sandboxEffectiveSeedAuth && plan.mode === 'login' && plan.loginNow;
   let stackStartEnv = needsAuthFlow
     ? {
-        ...process.env,
+        ...setupChildEnv,
         // Hint to the dev runner that it should start the Expo web UI early (before daemon auth),
         // so guided login can open the correct UI origin (not the server port).
         HAPPIER_STACK_AUTH_FLOW: '1',
       }
-    : process.env;
+    : setupChildEnv;
   if (wantsMobile) {
     stackStartEnv = pickReviewerMobileSchemeEnv(stackStartEnv);
   }
@@ -382,7 +384,7 @@ async function main() {
         cmd: process.execPath,
         args: [join(rootDir, 'scripts', 'init.mjs'), '--no-bootstrap'],
         cwd: rootDir,
-        env: process.env,
+        env: setupChildEnv,
         logPath: initLog,
         quiet: true,
         showSteps: true,
@@ -400,7 +402,7 @@ async function main() {
           ...(isSandboxed() && wantsDev ? ['--no-ui-deps'] : []),
         ],
         cwd: rootDir,
-        env: process.env,
+        env: setupChildEnv,
         logPath: installLog,
         quiet: true,
         showSteps: true,
@@ -421,7 +423,7 @@ async function main() {
       process.exit(1);
     }
   } else {
-    await runNodeScript({ rootDir, rel: 'scripts/init.mjs', args: ['--no-bootstrap'] });
+    await runNodeScript({ rootDir, rel: 'scripts/init.mjs', args: ['--no-bootstrap'], env: setupChildEnv });
     await runNodeScript({
       rootDir,
       rel: 'scripts/install.mjs',
@@ -432,6 +434,7 @@ async function main() {
         ...(wantsDev ? ['--no-ui-build'] : []),
         ...(isSandboxed() && wantsDev ? ['--no-ui-deps'] : []),
       ],
+      env: setupChildEnv,
     });
   }
 
@@ -560,7 +563,7 @@ async function main() {
     ];
     // If the user explicitly asked for verbose, reattach; otherwise keep things quiet.
     if (verbosity > 0) {
-      await runNodeScript({ rootDir, rel: 'scripts/stack.mjs', args: restartArgs });
+      await runNodeScript({ rootDir, rel: 'scripts/stack.mjs', args: restartArgs, env: stackStartEnv });
     }
     // Mobile is started up-front (in the initial stack pr start) so we don't need to restart here.
   }

package/scripts/setup_pr_orchestrated_auth_flow_util_import.test.mjs

@@ -37,7 +37,18 @@ test('setup_pr guided-login path delegates to orchestrated auth flow helpers at
 export async function assertCliPrereqs() {}
 `),
       './utils/proc/proc.mjs': toDataUrl(`
-export async function run() {}
+import { appendFileSync } from 'node:fs';
+
+const markerPath = process.env.HSTACK_SETUP_PR_MARKER;
+function mark(line) {
+  if (!markerPath) return;
+  appendFileSync(markerPath, String(line) + '\\n', 'utf-8');
+}
+export async function run(_cmd, args, { env } = {}) {
+  const script = String(args?.[0] ?? '').split(/[\\/]/).pop();
+  mark('run:' + script + '|setupChild=' + String(env?.HAPPIER_STACK_SETUP_CHILD ?? '') + '|workspace=' + String(env?.HAPPIER_STACK_WORKSPACE_DIR ?? ''));
+  return { status: 0 };
+}
 `),
       './utils/auth/guided_pr_auth.mjs': toDataUrl(`
 export async function decidePrAuthPlan() {
@@ -111,6 +122,17 @@ export async function resolve(specifier, context, defaultResolve) {
     const markerLog = await readFile(markerPath, 'utf-8');
     assert.match(markerLog, /\brunOrchestratedGuidedAuthFlow\b/, `expected setup_pr to call runOrchestratedGuidedAuthFlow\n${markerLog}`);
     assert.match(markerLog, /\bstartDaemonPostAuth\b/, `expected setup_pr to call startDaemonPostAuth\n${markerLog}`);
+    assert.match(markerLog, /run:init\.mjs\|setupChild=1\|workspace=/, `expected setup pr to propagate setup child env to init\n${markerLog}`);
+    assert.match(
+      markerLog,
+      /run:install\.mjs\|setupChild=1\|workspace=/,
+      `expected setup pr to propagate setup child env to install\n${markerLog}`
+    );
+    assert.match(
+      markerLog,
+      /run:stack\.mjs\|setupChild=1\|workspace=/,
+      `expected setup pr to propagate setup child env to initial stack creation\n${markerLog}`
+    );
   } finally {
     await rm(tmp, { recursive: true, force: true });
   }

package/scripts/stack/command_arguments.mjs

@@ -13,6 +13,7 @@ const STACK_NAME_FIRST_SUPPORTED_COMMANDS = new Set([
   'create-dev-auth-seed',
   'daemon',
   'happier',
+  'bug-report',
   'env',
   'auth',
   'dev',

package/scripts/stack/help_text.mjs

@@ -6,10 +6,11 @@ const STACK_HELP_USAGE_LINES = [
   'hstack stack archive <name> [--dry-run] [--date=YYYY-MM-DD] [--json]',
   'hstack stack duplicate <from> <to> [--duplicate-worktrees] [--deps=none|link|install|link-or-install] [--json]',
   'hstack stack info <name> [--json]',
-  'hstack stack pr <name> --repo=<pr-url|number> [--server-flavor=light|full] [--dev|--start] [--json] [-- ...]',
-  'hstack stack create-dev-auth-seed [name] [--server=happier-server|happier-server-light] [--login|--no-login] [--skip-default-seed] [--non-interactive] [--json]',
+  'hstack stack pr <name> --repo=<pr-url|number> [--server-flavor=light|full] [--dev|--start] [--reuse] [--update] [--force] [--background] [--mobile] [--expo-tailscale] [--json] [-- ...]',
+  'hstack stack create-dev-auth-seed [name] [--server=happier-server|happier-server-light] [--login|--no-login] [--force] [--skip-default-seed] [--non-interactive] [--json]',
   'hstack stack daemon <name> start|stop|restart|status [--json]',
   'hstack stack happier <name> [-- ...]',
+  'hstack stack bug-report <name> [-- ...]',
   'hstack stack env <name> set KEY=VALUE [KEY2=VALUE2...] | unset KEY [KEY2...] | get KEY | list | path [--json]',
   'hstack stack auth <name> status|login|copy-from [--json]',
   'hstack stack dev <name> [-- ...]',
@@ -48,6 +49,7 @@ export const STACK_HELP_COMMANDS = [
   'daemon',
   'eas',
   'happier',
+  'bug-report',
   'env',
   'auth',
   'dev',

package/scripts/stack/run_script_with_stack_env.mjs

@@ -169,8 +169,16 @@ export async function runStackScriptWithStackEnv({ rootDir, stackName, scriptPat
           const n = Number(v);
           return Number.isFinite(n) && n > 0 ? n : null;
         };
+        // Port reuse:
+        // - Hard reuse: `--restart` (fail-closed if ports are occupied unless we can prove stack ownership).
+        // - Soft reuse: if the stack previously recorded ports in stack.runtime.json, prefer reusing them
+        //   on the next start to keep stack endpoints stable (helps auth + server-scoped state).
+        const hasRecordedPorts = hasRecordedRuntimePortsForRestart(runtimeState);
+        const wantsSoftReuse = !wantsRestart && hasRecordedPorts && existingPorts;
+        const wantsHardReuse = isTrueRestart;
+
         const candidatePorts =
-          isTrueRestart && existingPorts
+          (wantsHardReuse || wantsSoftReuse) && existingPorts
             ? {
                 server: parsePortOrNull(existingPorts.server),
                 backend: parsePortOrNull(existingPorts.backend),
@@ -181,12 +189,26 @@ export async function runStackScriptWithStackEnv({ rootDir, stackName, scriptPat
               }
             : null;
 
-        const canReuse =
+        let canReuse =
           candidatePorts &&
           candidatePorts.server &&
           (serverComponent !== 'happier-server' || candidatePorts.backend) &&
           (!managedInfra || (candidatePorts.pg && candidatePorts.redis && candidatePorts.minio && candidatePorts.minioConsole));
 
+        // Soft reuse: if previously recorded ports are occupied, fall back to allocating new ports.
+        if (canReuse && wantsSoftReuse && !wantsHardReuse) {
+          const toCheck = Object.values(candidatePorts)
+            .map((n) => Number(n))
+            .filter((n) => Number.isFinite(n) && n > 0);
+          for (const p of toCheck) {
+            // eslint-disable-next-line no-await-in-loop
+            if (!(await isTcpPortFree(p))) {
+              canReuse = false;
+              break;
+            }
+          }
+        }
+
         if (canReuse) {
           ports.server = candidatePorts.server;
           if (serverComponent === 'happier-server') {

package/scripts/stack/stack_daemon_command.mjs

@@ -5,12 +5,12 @@ import { findExistingStackCredentialPath } from '../utils/auth/credentials_paths
 import { parseArgs } from '../utils/cli/args.mjs';
 import { printResult, wantsHelp } from '../utils/cli/cli.mjs';
 import { isTty, promptSelect, withRl } from '../utils/cli/wizard.mjs';
-import { daemonStatusSummary, startLocalDaemonWithAuth, stopLocalDaemon } from '../daemon.mjs';
+import { checkDaemonState, daemonStatusSummary, startLocalDaemonWithAuth, stopLocalDaemon } from '../daemon.mjs';
 import { getComponentDir, resolveStackEnvPath } from '../utils/paths/paths.mjs';
 import { run } from '../utils/proc/proc.mjs';
 import { resolveServerPortFromEnv, resolveServerUrls } from '../utils/server/urls.mjs';
 import { parseCliIdentityOrThrow, resolveCliHomeDirForIdentity } from '../utils/stack/cli_identities.mjs';
-import { readStackRuntimeStateFile, isPidAlive } from '../utils/stack/runtime_state.mjs';
+import { readStackRuntimeStateFile, recordStackRuntimeUpdate, isPidAlive } from '../utils/stack/runtime_state.mjs';
 import { withStackEnv } from './stack_environment.mjs';
 import { banner, cmd as cmdFmt, sectionTitle } from '../utils/ui/layout.mjs';
 import { cyan, green } from '../utils/ui/ansi.mjs';
@@ -96,6 +96,18 @@ export async function runStackDaemonCommand({ rootDir, stackName, argv, json })
       };
       await mkdir(cliHomeDir, { recursive: true }).catch(() => {});
 
+      const maybeRecordDaemonPid = async ({ pid, clear = false } = {}) => {
+        const path = (runtimePath ?? '').toString().trim();
+        if (!path) return;
+        if (clear) {
+          await recordStackRuntimeUpdate(path, { processes: { daemonPid: null } }).catch(() => {});
+          return;
+        }
+        const n = Number(pid);
+        if (!Number.isFinite(n) || n <= 1) return;
+        await recordStackRuntimeUpdate(path, { processes: { daemonPid: n } }).catch(() => {});
+      };
+
       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).
@@ -156,6 +168,14 @@ export async function runStackDaemonCommand({ rootDir, stackName, argv, json })
           stackName,
           cliIdentity: identity,
         });
+
+        // Record the daemon PID in stack.runtime.json so `hstack tui` and other tools can
+        // display correct daemon state even when the daemon is started outside `hstack dev`.
+        const state = checkDaemonState(cliHomeDir, { serverUrl: internalServerUrl, env: envForIdentity });
+        if ((state?.status === 'running' || state?.status === 'starting') && typeof state?.pid === 'number') {
+          await maybeRecordDaemonPid({ pid: state.pid });
+        }
+
         const status = await daemonStatusSummary({
           cliBin,
           cliHomeDir,
@@ -178,6 +198,7 @@ export async function runStackDaemonCommand({ rootDir, stackName, argv, json })
           stackName,
           cliIdentity: identity,
         });
+        await maybeRecordDaemonPid({ clear: true });
         const status = await daemonStatusSummary({
           cliBin,
           cliHomeDir,
@@ -199,6 +220,14 @@ export async function runStackDaemonCommand({ rootDir, stackName, argv, json })
         stackName,
         cliIdentity: identity,
       });
+
+      // Best-effort: when someone runs `status`, persist the observed PID so the TUI can show
+      // "running" even if the daemon was started outside of stack orchestration.
+      const state = checkDaemonState(cliHomeDir, { serverUrl: internalServerUrl, env: envForIdentity });
+      if ((state?.status === 'running' || state?.status === 'starting') && typeof state?.pid === 'number') {
+        await maybeRecordDaemonPid({ pid: state.pid });
+      }
+
       return { ok: true, action, cliIdentity: identity, cliHomeDir, status: status.trim() };
     },
   });

package/scripts/stack/stack_environment.mjs

@@ -1,7 +1,8 @@
 import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import { ensureDir, readTextOrEmpty } from '../utils/fs/ops.mjs';
 import { parseEnvToObject } from '../utils/env/dotenv.mjs';
-import { getRepoDir, resolveStackEnvPath } from '../utils/paths/paths.mjs';
+import { getWorkspaceDir, resolveStackEnvPath } from '../utils/paths/paths.mjs';
 import { stackExistsSync } from '../utils/stack/stacks.mjs';
 import { STACK_WRAPPER_PRESERVE_KEYS, scrubHappierStackEnv } from '../utils/env/scrub_env.mjs';
 import { applyStackActiveServerScopeEnv } from '../utils/auth/stable_scope_id.mjs';
@@ -13,6 +14,17 @@ const STACK_WRAPPER_CLEAR_UNPREFIXED_KEYS = [
   'HAPPIER_PUBLIC_SERVER_URL',
   'HAPPIER_WEBAPP_URL',
   'HAPPIER_HOME_DIR',
+  'APP_ENV',
+  'EXPO_UPDATES_CHANNEL',
+  'EXPO_PUBLIC_HAPPIER_FEATURE_POLICY_ENV',
+  'EXPO_PUBLIC_HAPPIER_BUILD_FEATURES_ALLOW',
+  'EXPO_PUBLIC_HAPPIER_BUILD_FEATURES_DENY',
+  // Runtime feature policy knobs should be stack-local; stale values from a prior stack can
+  // silently bleed into a newly selected stack and override expected defaults.
+  'HAPPIER_FEATURE_POLICY_ENV',
+  'HAPPIER_EMBEDDED_POLICY_ENV',
+  'HAPPIER_BUILD_FEATURES_ALLOW',
+  'HAPPIER_BUILD_FEATURES_DENY',
 ];
 
 function stringifyEnv(env) {
@@ -32,7 +44,8 @@ export function resolveDefaultRepoEnv({ rootDir }) {
   //
   // Default: use the workspace clone (<workspace>/happier), regardless of any current
   // one-off repo/worktree selection in the user's environment.
-  const repoDir = getRepoDir(rootDir, { ...process.env, HAPPIER_STACK_REPO_DIR: '' });
+  const workspaceDir = getWorkspaceDir(rootDir, { ...process.env, HAPPIER_STACK_REPO_DIR: '' });
+  const repoDir = join(workspaceDir, 'main');
   return { HAPPIER_STACK_REPO_DIR: repoDir };
 }
 

package/scripts/stack/stack_environment.sanitization.test.mjs

@@ -45,11 +45,29 @@ test('withStackEnv clears leaked unprefixed server/home env vars from caller sco
     const previousPublicServerUrl = process.env.HAPPIER_PUBLIC_SERVER_URL;
     const previousWebappUrl = process.env.HAPPIER_WEBAPP_URL;
     const previousHomeDir = process.env.HAPPIER_HOME_DIR;
+    const previousAppEnv = process.env.APP_ENV;
+    const previousExpoUpdatesChannel = process.env.EXPO_UPDATES_CHANNEL;
+    const previousExpoPublicFeaturePolicy = process.env.EXPO_PUBLIC_HAPPIER_FEATURE_POLICY_ENV;
+    const previousExpoPublicBuildFeaturesAllow = process.env.EXPO_PUBLIC_HAPPIER_BUILD_FEATURES_ALLOW;
+    const previousExpoPublicBuildFeaturesDeny = process.env.EXPO_PUBLIC_HAPPIER_BUILD_FEATURES_DENY;
+    const previousFeaturePolicyEnv = process.env.HAPPIER_FEATURE_POLICY_ENV;
+    const previousEmbeddedPolicyEnv = process.env.HAPPIER_EMBEDDED_POLICY_ENV;
+    const previousBuildFeaturesAllow = process.env.HAPPIER_BUILD_FEATURES_ALLOW;
+    const previousBuildFeaturesDeny = process.env.HAPPIER_BUILD_FEATURES_DENY;
 
     process.env.HAPPIER_SERVER_URL = 'http://stale.localhost:9999';
     process.env.HAPPIER_PUBLIC_SERVER_URL = 'http://stale.localhost:9999';
     process.env.HAPPIER_WEBAPP_URL = 'http://stale.localhost:9999';
     process.env.HAPPIER_HOME_DIR = '/tmp/stale-home';
+    process.env.APP_ENV = 'preview';
+    process.env.EXPO_UPDATES_CHANNEL = 'preview';
+    process.env.EXPO_PUBLIC_HAPPIER_FEATURE_POLICY_ENV = 'preview';
+    process.env.EXPO_PUBLIC_HAPPIER_BUILD_FEATURES_ALLOW = 'voice';
+    process.env.EXPO_PUBLIC_HAPPIER_BUILD_FEATURES_DENY = 'automations';
+    process.env.HAPPIER_FEATURE_POLICY_ENV = 'preview';
+    process.env.HAPPIER_EMBEDDED_POLICY_ENV = 'preview';
+    process.env.HAPPIER_BUILD_FEATURES_DENY = 'automations';
+    process.env.HAPPIER_BUILD_FEATURES_ALLOW = 'voice';
 
     try {
       await withStackEnv({
@@ -59,6 +77,15 @@ test('withStackEnv clears leaked unprefixed server/home env vars from caller sco
           assert.equal(env.HAPPIER_PUBLIC_SERVER_URL, undefined);
           assert.equal(env.HAPPIER_WEBAPP_URL, undefined);
           assert.equal(env.HAPPIER_HOME_DIR, undefined);
+          assert.equal(env.APP_ENV, undefined);
+          assert.equal(env.EXPO_UPDATES_CHANNEL, undefined);
+          assert.equal(env.EXPO_PUBLIC_HAPPIER_FEATURE_POLICY_ENV, undefined);
+          assert.equal(env.EXPO_PUBLIC_HAPPIER_BUILD_FEATURES_DENY, undefined);
+          assert.equal(env.EXPO_PUBLIC_HAPPIER_BUILD_FEATURES_ALLOW, undefined);
+          assert.equal(env.HAPPIER_FEATURE_POLICY_ENV, undefined);
+          assert.equal(env.HAPPIER_EMBEDDED_POLICY_ENV, undefined);
+          assert.equal(env.HAPPIER_BUILD_FEATURES_DENY, undefined);
+          assert.equal(env.HAPPIER_BUILD_FEATURES_ALLOW, undefined);
         },
       });
     } finally {
@@ -70,6 +97,24 @@ test('withStackEnv clears leaked unprefixed server/home env vars from caller sco
       else process.env.HAPPIER_WEBAPP_URL = previousWebappUrl;
       if (typeof previousHomeDir === 'undefined') delete process.env.HAPPIER_HOME_DIR;
       else process.env.HAPPIER_HOME_DIR = previousHomeDir;
+      if (typeof previousAppEnv === 'undefined') delete process.env.APP_ENV;
+      else process.env.APP_ENV = previousAppEnv;
+      if (typeof previousExpoUpdatesChannel === 'undefined') delete process.env.EXPO_UPDATES_CHANNEL;
+      else process.env.EXPO_UPDATES_CHANNEL = previousExpoUpdatesChannel;
+      if (typeof previousExpoPublicFeaturePolicy === 'undefined') delete process.env.EXPO_PUBLIC_HAPPIER_FEATURE_POLICY_ENV;
+      else process.env.EXPO_PUBLIC_HAPPIER_FEATURE_POLICY_ENV = previousExpoPublicFeaturePolicy;
+      if (typeof previousExpoPublicBuildFeaturesAllow === 'undefined') delete process.env.EXPO_PUBLIC_HAPPIER_BUILD_FEATURES_ALLOW;
+      else process.env.EXPO_PUBLIC_HAPPIER_BUILD_FEATURES_ALLOW = previousExpoPublicBuildFeaturesAllow;
+      if (typeof previousExpoPublicBuildFeaturesDeny === 'undefined') delete process.env.EXPO_PUBLIC_HAPPIER_BUILD_FEATURES_DENY;
+      else process.env.EXPO_PUBLIC_HAPPIER_BUILD_FEATURES_DENY = previousExpoPublicBuildFeaturesDeny;
+      if (typeof previousFeaturePolicyEnv === 'undefined') delete process.env.HAPPIER_FEATURE_POLICY_ENV;
+      else process.env.HAPPIER_FEATURE_POLICY_ENV = previousFeaturePolicyEnv;
+      if (typeof previousEmbeddedPolicyEnv === 'undefined') delete process.env.HAPPIER_EMBEDDED_POLICY_ENV;
+      else process.env.HAPPIER_EMBEDDED_POLICY_ENV = previousEmbeddedPolicyEnv;
+      if (typeof previousBuildFeaturesAllow === 'undefined') delete process.env.HAPPIER_BUILD_FEATURES_ALLOW;
+      else process.env.HAPPIER_BUILD_FEATURES_ALLOW = previousBuildFeaturesAllow;
+      if (typeof previousBuildFeaturesDeny === 'undefined') delete process.env.HAPPIER_BUILD_FEATURES_DENY;
+      else process.env.HAPPIER_BUILD_FEATURES_DENY = previousBuildFeaturesDeny;
     }
   });
 });

package/scripts/stack.mjs

@@ -84,6 +84,7 @@ import { interactiveEdit, interactiveNew } from './utils/stack/interactive_stack
 import { normalizeStackNameOrNull } from './utils/stack/names.mjs';
 import { runOrchestratedGuidedAuthFlow } from './utils/auth/orchestrated_stack_auth_flow.mjs';
 import { assertExpoWebappBundlesOrThrow } from './utils/auth/stack_guided_login.mjs';
+import { applyAuthForceEnv, resolveAuthForceFlag } from './utils/auth/auth_force_flag.mjs';
 import { createStepPrinter } from './utils/cli/progress.mjs';
 import { getVerbosityLevel } from './utils/cli/verbosity.mjs';
 import { applyBindModeToEnv, resolveBindModeFromArgs } from './utils/net/bind_mode.mjs';
@@ -977,6 +978,7 @@ async function cmdCreateDevAuthSeed({ rootDir, argv }) {
     flags.has('--skip-default-seed') || flags.has('--no-default-seed') || flags.has('--no-configure-default-seed');
   const forceLogin =
     flags.has('--login') ? true : flags.has('--no-login') || flags.has('--skip-login') ? false : null;
+  const forceAuth = resolveAuthForceFlag({ flags, kv });
 
   if (json) {
     // Keep JSON mode non-interactive and stable by using the existing stack command output.
@@ -1223,7 +1225,7 @@ async function cmdCreateDevAuthSeed({ rootDir, argv }) {
               await runOrchestratedGuidedAuthFlow({
                 rootDir,
                 stackName: name,
-                env,
+                env: applyAuthForceEnv(env, forceAuth),
                 verbosity,
                 json: false,
               });
@@ -1622,7 +1624,7 @@ async function cmdPrStack({ rootDir, argv }) {
         '[stack] usage:',
         '  hstack stack pr <name> --repo=<pr-url|number> [--dev|--start]',
         '    [--seed-auth] [--copy-auth-from=<stack>] [--link-auth] [--with-infra] [--auth-force]',
-        '    [--remote=upstream] [--deps=none|link|install|link-or-install] [--update] [--force] [--background]',
+        '    [--remote=upstream] [--deps=none|link|install|link-or-install] [--reuse] [--update] [--force] [--background]',
         '    [--mobile]         # also start Expo dev-client Metro for mobile',
         '    [--expo-tailscale] # forward Expo to Tailscale interface for remote access',
         '    [--json] [-- <stack dev/start args...>]',
@@ -1639,6 +1641,7 @@ async function cmdPrStack({ rootDir, argv }) {
         '',
 	        'notes:',
 	        '  - This composes existing commands: `hstack stack new`, `hstack stack wt ...`, and `hstack stack auth ...`',
+	        '  - `--reuse` reuses an existing PR stack (otherwise `stack pr` fails closed if the stack already exists)',
 	        '  - For auth seeding, pass `--seed-auth` and optionally `--copy-auth-from=dev-auth` (or main)',
 	        '  - `--link-auth` symlinks auth files instead of copying (keeps credentials in sync, but reduces isolation)',
 	      ].join('\n'),

package/scripts/stack_create_dev_auth_seed_help_force.test.mjs

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+
+import { getStackRootFromMeta, hstackBinPath, runNodeCapture } from './testkit/auth_testkit.mjs';
+
+test('hstack stack create-dev-auth-seed --help surfaces --force for re-auth', async () => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+
+  const env = {
+    ...process.env,
+    // Prevent env.mjs from auto-loading a real machine stack env file (keeps the test hermetic).
+    HAPPIER_STACK_STACK: 'test-stack',
+    HAPPIER_STACK_ENV_FILE: join(rootDir, 'scripts', 'nonexistent-env'),
+  };
+
+  const res = await runNodeCapture([hstackBinPath(rootDir), 'stack', 'create-dev-auth-seed', '--help'], { cwd: rootDir, env });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+  assert.match(res.stdout, /--force(?:\b|\])/, `expected help to include --force\nstdout:\n${res.stdout}`);
+});
+
+test('hstack stack --help shows --force on create-dev-auth-seed usage line', async () => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_STACK: 'test-stack',
+    HAPPIER_STACK_ENV_FILE: join(rootDir, 'scripts', 'nonexistent-env'),
+  };
+
+  const res = await runNodeCapture([hstackBinPath(rootDir), 'stack', '--help'], { cwd: rootDir, env });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+  assert.match(
+    res.stdout,
+    /hstack stack create-dev-auth-seed[^\n]*--force(?:\b|\])/,
+    `expected stack root help to include --force on create-dev-auth-seed usage line\nstdout:\n${res.stdout}`
+  );
+});