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

package/scripts/stack/stack_info_snapshot.mjs

@@ -7,6 +7,12 @@ import { getStackRuntimeStatePath, isPidAlive, readStackRuntimeStateFile } from
 import { isTcpPortFree } from '../utils/net/ports.mjs';
 import { readTextOrEmpty } from '../utils/fs/ops.mjs';
 import { resolveDefaultRepoEnv } from './stack_environment.mjs';
+import { resolveStackRuntimeMode } from '../runtime/shared/runtime_mode.mjs';
+import { inspectActiveRuntimeSnapshot } from '../runtime/launch/inspectActiveRuntimeSnapshot.mjs';
+import { getObservedStackDaemon, readStackRuntimeStateWithDaemonSync } from '../utils/stack/runtime_daemon_state.mjs';
+import { applyStackActiveServerScopeEnv } from '../utils/auth/stable_scope_id.mjs';
+import { join } from 'node:path';
+import { checkDaemonState } from '../daemon.mjs';
 
 const readExistingEnv = readTextOrEmpty;
 
@@ -16,13 +22,34 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
   const envRaw = await readExistingEnv(envPath);
   const stackEnv = envRaw ? parseEnvToObject(envRaw) : {};
   const runtimeStatePath = getStackRuntimeStatePath(stackName);
-  const runtimeState = await readStackRuntimeStateFile(runtimeStatePath);
 
   const serverComponent = getEnvValueAny(stackEnv, ['HAPPIER_STACK_SERVER_COMPONENT']) || 'happier-server-light';
   const stackRemote = getEnvValueAny(stackEnv, ['HAPPIER_STACK_STACK_REMOTE']) || 'upstream';
 
   const pinnedServerPortRaw = getEnvValueAny(stackEnv, ['HAPPIER_STACK_SERVER_PORT']);
   const pinnedServerPort = pinnedServerPortRaw ? Number(pinnedServerPortRaw) : null;
+  const stackScopedEnv = applyStackActiveServerScopeEnv({
+    env: { ...process.env, ...stackEnv },
+    stackName,
+    cliIdentity: 'default',
+  });
+  const initialRuntimeState = await readStackRuntimeStateFile(runtimeStatePath);
+  const initialRuntimePorts =
+    initialRuntimeState?.ports && typeof initialRuntimeState.ports === 'object' ? initialRuntimeState.ports : {};
+  const syncServerPort =
+    Number.isFinite(pinnedServerPort) && pinnedServerPort > 0
+      ? pinnedServerPort
+      : Number(initialRuntimePorts?.server) > 0
+        ? Number(initialRuntimePorts.server)
+        : null;
+  const runtimeState = await readStackRuntimeStateWithDaemonSync({
+    runtimeStatePath,
+    cliHomeDir: join(baseDir, 'cli'),
+    internalServerUrl: Number.isFinite(syncServerPort) && syncServerPort > 0 ? `http://127.0.0.1:${syncServerPort}` : '',
+    env: stackScopedEnv,
+  }, {
+    checkDaemonStateImpl: checkDaemonState,
+  });
 
   const runtimePorts = runtimeState?.ports && typeof runtimeState.ports === 'object' ? runtimeState.ports : {};
   const serverPort =
@@ -44,6 +71,17 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
   const serverPid = Number(runtimeState?.processes?.serverPid);
   const expoPid = Number(runtimeState?.processes?.expoPid);
   const expoTailscaleForwarderPid = Number(runtimeState?.processes?.expoTailscaleForwarderPid);
+  const daemonExpected = String(getEnvValueAny(stackEnv, ['HAPPIER_STACK_DAEMON']) ?? '1').trim() !== '0';
+  const observedDaemon = getObservedStackDaemon({
+    cliHomeDir: join(baseDir, 'cli'),
+    internalServerUrl: Number.isFinite(serverPort) && serverPort > 0 ? `http://127.0.0.1:${serverPort}` : '',
+    runtimeDaemonPid: runtimeState?.processes?.daemonPid ?? null,
+    env: stackScopedEnv,
+  }, {
+    checkDaemonStateImpl: checkDaemonState,
+  });
+  const daemonPid = Number(observedDaemon.pid);
+  const daemonRunning = observedDaemon.running === true;
 
   const ownerAlive = Number.isFinite(ownerPid) && ownerPid > 1 ? isPidAlive(ownerPid) : false;
   const serverPidAlive = Number.isFinite(serverPid) && serverPid > 1 ? isPidAlive(serverPid) : false;
@@ -70,10 +108,10 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
     Number.isFinite(uiPort) && uiPort > 0
       ? uiPortListening
       : expoPidAlive;
-  const candidateRuntimePids = [ownerPid, serverPid, expoPid, expoTailscaleForwarderPid]
+  const candidateRuntimePids = [ownerPid, serverPid, expoPid, expoTailscaleForwarderPid, daemonPid]
     .filter((pid) => Number.isFinite(pid) && pid > 1);
   const runningPid = candidateRuntimePids.find((pid) => isPidAlive(pid)) ?? null;
-  const running = ownerAlive || serverRunning || uiRunning || serverPidAlive || expoPidAlive || expoForwarderAlive;
+  const running = ownerAlive || serverRunning || uiRunning || daemonRunning || serverPidAlive || expoPidAlive || expoForwarderAlive;
 
   const healthIssues = [];
   if (Number.isFinite(serverPort) && serverPort > 0 && !serverRunning) {
@@ -82,6 +120,9 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
   if (Number.isFinite(uiPort) && uiPort > 0 && !uiRunning) {
     healthIssues.push('ui_down');
   }
+  if (daemonExpected && running && !daemonRunning) {
+    healthIssues.push('daemon_down');
+  }
   const healthStatus = !running ? 'stopped' : healthIssues.length > 0 ? 'degraded' : 'healthy';
 
   const host = resolveLocalhostHost({ stackMode: true, stackName });
@@ -91,6 +132,8 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
 
   const repoDir = getEnvValueAny(stackEnv, ['HAPPIER_STACK_REPO_DIR']) || resolveDefaultRepoEnv({ rootDir }).HAPPIER_STACK_REPO_DIR;
   const repoWorktreeSpec = repoDir ? worktreeSpecFromDir({ rootDir, component: 'happier-ui', dir: repoDir }) || null : null;
+  const runtimeMode = resolveStackRuntimeMode({ argv: [], env: stackEnv }).mode;
+  const runtimeInspection = await inspectActiveRuntimeSnapshot({ stackBaseDir: baseDir });
   const dirs = {
     repoDir,
     uiDir: getComponentDir(rootDir, 'happier-ui', { ...process.env, ...stackEnv }),
@@ -119,6 +162,12 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
           pid: Number.isFinite(ownerPid) && ownerPid > 1 ? ownerPid : null,
           running: ownerAlive,
         },
+        daemon: {
+          pid: Number.isFinite(daemonPid) && daemonPid > 1 ? daemonPid : null,
+          running: daemonRunning,
+          status: observedDaemon.status,
+          source: observedDaemon.source,
+        },
         server: {
           pid: Number.isFinite(serverPid) && serverPid > 1 ? serverPid : null,
           running: serverRunning,
@@ -145,6 +194,13 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
       processes: runtimeState?.processes ?? null,
       startedAt: runtimeState?.startedAt ?? null,
       updatedAt: runtimeState?.updatedAt ?? null,
+      mode: runtimeMode,
+      activeSnapshotId: runtimeInspection.activeSnapshotId,
+      snapshotPath: runtimeInspection.snapshotPath,
+      sourceFingerprint: runtimeInspection.sourceFingerprint,
+      valid: runtimeInspection.valid,
+      errors: runtimeInspection.errors,
+      snapshotComponents: runtimeInspection.manifest?.components ?? null,
     },
     urls: {
       host,

package/scripts/stack/stack_mobile_install_command.mjs

@@ -4,48 +4,114 @@ import { parseEnvToObject } from '../utils/env/dotenv.mjs';
 import { ensureEnvFileUpdated } from '../utils/env/env_file.mjs';
 import { readTextOrEmpty } from '../utils/fs/ops.mjs';
 import { resolveStackEnvPath } from '../utils/paths/paths.mjs';
-import { defaultStackReleaseIdentity } from '../utils/mobile/identifiers.mjs';
+import { defaultDevClientIdentity, defaultStackReleaseIdentity } from '../utils/mobile/identifiers.mjs';
 
 import { runStackScriptWithStackEnv } from './run_script_with_stack_env.mjs';
 
-export async function runStackMobileInstallCommand({ rootDir, stackName, passthrough, json }) {
-  const { flags: mobileFlags, kv: mobileKv } = parseArgs(passthrough);
+function resolveRequestedAppEnv(mobileKv) {
+  const raw = (mobileKv.get('--app-env') ?? '').toString().trim().toLowerCase();
+  return raw === 'development' ? 'development' : 'production';
+}
+
+function resolveInstallConfiguration({ appEnv, mobileKv }) {
+  const explicit = (mobileKv.get('--configuration') ?? '').toString().trim();
+  if (explicit) return explicit;
+  return appEnv === 'development' ? 'Debug' : 'Release';
+}
+
+function buildDevelopmentInstallExtraEnv() {
+  return {
+    HAPPIER_EXPO_DEVCLIENT_LAUNCH_MODE: 'most-recent',
+    HAPPIER_EXPO_DEVCLIENT_SILENT_LAUNCH: 'true',
+    HAPPIER_EXPO_USE_NATIVE_DEBUG: 'true',
+    EX_UPDATES_NATIVE_DEBUG: '1',
+  };
+}
+
+export function resolveStackMobileInstallPlan({ stackName, passthrough, existing, user }) {
+  const { kv: mobileKv } = parseArgs(passthrough);
   const device = (mobileKv.get('--device') ?? '').toString();
   const name = (mobileKv.get('--name') ?? mobileKv.get('--app-name') ?? '').toString().trim();
-  const jsonOut = wantsJson(passthrough, { flags: mobileFlags }) || json;
+  const appEnv = resolveRequestedAppEnv(mobileKv);
+  const configuration = resolveInstallConfiguration({ appEnv, mobileKv });
 
-  const envPath = resolveStackEnvPath(stackName).envPath;
-  const existingRaw = await readTextOrEmpty(envPath);
-  const existing = parseEnvToObject(existingRaw);
-  const priorName = (existing.HAPPIER_STACK_MOBILE_RELEASE_IOS_APP_NAME ?? '').toString().trim();
-  const identity = defaultStackReleaseIdentity({
-    stackName,
-    user: process.env.USER ?? process.env.USERNAME ?? 'user',
-    appName: name || priorName || null,
-  });
+  const priorNameKey =
+    appEnv === 'development'
+      ? 'HAPPIER_STACK_MOBILE_DEVELOPMENT_IOS_APP_NAME'
+      : 'HAPPIER_STACK_MOBILE_RELEASE_IOS_APP_NAME';
+  const priorName = (existing?.[priorNameKey] ?? '').toString().trim();
+  const identity =
+    appEnv === 'development'
+      ? {
+          ...defaultDevClientIdentity({ user }),
+          ...(name || priorName ? { iosAppName: name || priorName } : {}),
+        }
+      : defaultStackReleaseIdentity({
+          stackName,
+          user,
+          appName: name || priorName || null,
+        });
 
-  await ensureEnvFileUpdated({
-    envPath,
-    updates: [
-      { key: 'HAPPIER_STACK_MOBILE_RELEASE_IOS_APP_NAME', value: identity.iosAppName },
-      { key: 'HAPPIER_STACK_MOBILE_RELEASE_IOS_BUNDLE_ID', value: identity.iosBundleId },
-      { key: 'HAPPIER_STACK_MOBILE_RELEASE_SCHEME', value: identity.scheme },
-    ],
-  });
+  const envUpdates =
+    appEnv === 'development'
+      ? [
+          { key: 'HAPPIER_STACK_MOBILE_DEVELOPMENT_IOS_APP_NAME', value: identity.iosAppName },
+          { key: 'HAPPIER_STACK_MOBILE_DEVELOPMENT_IOS_BUNDLE_ID', value: identity.iosBundleId },
+          { key: 'HAPPIER_STACK_MOBILE_DEVELOPMENT_SCHEME', value: identity.scheme },
+        ]
+      : [
+          { key: 'HAPPIER_STACK_MOBILE_RELEASE_IOS_APP_NAME', value: identity.iosAppName },
+          { key: 'HAPPIER_STACK_MOBILE_RELEASE_IOS_BUNDLE_ID', value: identity.iosBundleId },
+          { key: 'HAPPIER_STACK_MOBILE_RELEASE_SCHEME', value: identity.scheme },
+        ];
 
   const args = [
-    '--app-env=production',
+    `--app-env=${appEnv}`,
     `--ios-app-name=${identity.iosAppName}`,
     `--ios-bundle-id=${identity.iosBundleId}`,
     `--scheme=${identity.scheme}`,
     '--prebuild',
     '--run-ios',
-    '--configuration=Release',
+    `--configuration=${configuration}`,
     '--no-metro',
     ...(device ? [`--device=${device}`] : []),
   ];
 
-  await runStackScriptWithStackEnv({ rootDir, stackName, scriptPath: 'mobile.mjs', args });
+  return {
+    appEnv,
+    identity,
+    envUpdates,
+    args,
+    extraEnv: appEnv === 'development' ? buildDevelopmentInstallExtraEnv() : {},
+  };
+}
+
+export async function runStackMobileInstallCommand({ rootDir, stackName, passthrough, json }) {
+  const { flags: mobileFlags, kv: mobileKv } = parseArgs(passthrough);
+  const jsonOut = wantsJson(passthrough, { flags: mobileFlags }) || json;
+
+  const envPath = resolveStackEnvPath(stackName).envPath;
+  const existingRaw = await readTextOrEmpty(envPath);
+  const existing = parseEnvToObject(existingRaw);
+  const plan = resolveStackMobileInstallPlan({
+    stackName,
+    passthrough,
+    existing,
+    user: process.env.USER ?? process.env.USERNAME ?? 'user',
+  });
+
+  await ensureEnvFileUpdated({
+    envPath,
+    updates: plan.envUpdates,
+  });
+
+  await runStackScriptWithStackEnv({
+    rootDir,
+    stackName,
+    scriptPath: 'mobile.mjs',
+    args: plan.args,
+    extraEnv: plan.extraEnv,
+  });
 
   if (jsonOut) {
     printResult({
@@ -54,7 +120,8 @@ export async function runStackMobileInstallCommand({ rootDir, stackName, passthr
         ok: true,
         stackName,
         installed: true,
-        identity,
+        appEnv: plan.appEnv,
+        identity: plan.identity,
       },
     });
   }

package/scripts/stack/stack_mobile_install_command.test.mjs

@@ -0,0 +1,53 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { defaultDevClientIdentity, defaultStackReleaseIdentity } from '../utils/mobile/identifiers.mjs';
+import { resolveStackMobileInstallPlan } from './stack_mobile_install_command.mjs';
+
+test('resolveStackMobileInstallPlan defaults to the production stack release install flow', () => {
+  const plan = resolveStackMobileInstallPlan({
+    stackName: 'pr272-107',
+    passthrough: ['--device=iPhone 13'],
+    existing: {},
+    user: 'Leeroy',
+  });
+
+  const expectedIdentity = defaultStackReleaseIdentity({ stackName: 'pr272-107', user: 'Leeroy' });
+  assert.equal(plan.appEnv, 'production');
+  assert.deepEqual(plan.identity, expectedIdentity);
+  assert.deepEqual(plan.extraEnv, {});
+  assert.ok(plan.args.includes('--app-env=production'));
+  assert.ok(plan.args.includes('--configuration=Release'));
+  assert.ok(plan.args.includes('--device=iPhone 13'));
+  assert.deepEqual(plan.envUpdates, [
+    { key: 'HAPPIER_STACK_MOBILE_RELEASE_IOS_APP_NAME', value: expectedIdentity.iosAppName },
+    { key: 'HAPPIER_STACK_MOBILE_RELEASE_IOS_BUNDLE_ID', value: expectedIdentity.iosBundleId },
+    { key: 'HAPPIER_STACK_MOBILE_RELEASE_SCHEME', value: expectedIdentity.scheme },
+  ]);
+});
+
+test('resolveStackMobileInstallPlan supports a development install with Expo native-debug update flags', () => {
+  const plan = resolveStackMobileInstallPlan({
+    stackName: 'repo-main',
+    passthrough: ['--app-env=development'],
+    existing: {},
+    user: 'Leeroy',
+  });
+
+  const expectedIdentity = defaultDevClientIdentity({ user: 'Leeroy' });
+  assert.equal(plan.appEnv, 'development');
+  assert.deepEqual(plan.identity, expectedIdentity);
+  assert.deepEqual(plan.extraEnv, {
+    HAPPIER_EXPO_DEVCLIENT_LAUNCH_MODE: 'most-recent',
+    HAPPIER_EXPO_DEVCLIENT_SILENT_LAUNCH: 'true',
+    HAPPIER_EXPO_USE_NATIVE_DEBUG: 'true',
+    EX_UPDATES_NATIVE_DEBUG: '1',
+  });
+  assert.ok(plan.args.includes('--app-env=development'));
+  assert.ok(plan.args.includes('--configuration=Debug'));
+  assert.deepEqual(plan.envUpdates, [
+    { key: 'HAPPIER_STACK_MOBILE_DEVELOPMENT_IOS_APP_NAME', value: expectedIdentity.iosAppName },
+    { key: 'HAPPIER_STACK_MOBILE_DEVELOPMENT_IOS_BUNDLE_ID', value: expectedIdentity.iosBundleId },
+    { key: 'HAPPIER_STACK_MOBILE_DEVELOPMENT_SCHEME', value: expectedIdentity.scheme },
+  ]);
+});

package/scripts/stack.mjs

@@ -41,7 +41,7 @@ import {
   withStackEnv,
   writeStackEnv,
 } from './stack/stack_environment.mjs';
-import { cmdAuth, cmdListStacks, cmdService, cmdSrv, cmdTailscale, cmdWt } from './stack/delegated_script_commands.mjs';
+import { cmdAuth, cmdListStacks, cmdRuntime, cmdService, cmdSrv, cmdTailscale, cmdWt } from './stack/delegated_script_commands.mjs';
 import { runStackDaemonCommand } from './stack/stack_daemon_command.mjs';
 import { runStackHappierPassthroughCommand } from './stack/stack_happier_passthrough_command.mjs';
 import { runStackMobileInstallCommand } from './stack/stack_mobile_install_command.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';
@@ -333,7 +334,7 @@ async function cmdNew({ rootDir, argv, emit = true }) {
       throw new Error(
         `[stack] repo checkout does not exist: ${resolved || '(empty)'}\n` +
           `Fix:\n` +
-          `- run: hstack setup --profile=dev (clones the monorepo into the workspace)\n` +
+          `- run: hstack setup-from-source --profile=dev (clones the monorepo into the workspace)\n` +
           `- or pass an explicit --repo=<path|worktreeSpec>\n`
       );
     }
@@ -360,12 +361,19 @@ async function cmdNew({ rootDir, argv, emit = true }) {
       json,
       requireSourceStackExists: kv.has('--copy-auth-from'),
       linkMode: linkAuth,
-    }).catch((err) => {
-      if (!json && emit) {
-        console.warn(`[stack] auth copy skipped: ${err instanceof Error ? err.message : String(err)}`);
-        console.warn(`[stack] tip: you can always run: hstack stack auth ${stackName} login`);
-      }
-    });
+    })
+      .then(() => {
+        if (kv.has('--copy-auth-from') && copyAuthFrom) {
+          stackEnv.HAPPIER_STACK_AUTH_SEED_FROM = copyAuthFrom;
+          stackEnv.HAPPIER_STACK_AUTO_AUTH_SEED = '1';
+        }
+      })
+      .catch((err) => {
+        if (!json && emit) {
+          console.warn(`[stack] auth copy skipped: ${err instanceof Error ? err.message : String(err)}`);
+          console.warn(`[stack] tip: you can always run: hstack stack auth ${stackName} login`);
+        }
+      });
   }
 
   const envPath = await writeStackEnv({ stackName, env: stackEnv });
@@ -977,16 +985,21 @@ 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.
-    // (We intentionally don't run the guided login flow in JSON mode.)
-    const createArgs = ['new', name, '--no-copy-auth', '--server', serverComponent, '--json'];
-    const created = await runCapture(process.execPath, [join(rootDir, 'scripts', 'stack.mjs'), ...createArgs], { cwd: rootDir, env: process.env }).catch((e) => {
-      throw new Error(
-        `[stack] create-dev-auth-seed: failed to create auth seed stack "${name}": ${e instanceof Error ? e.message : String(e)}`
-      );
-    });
+    // Keep JSON mode non-interactive and stable by reusing an existing seed stack instead of
+    // recreating it, which would overwrite its pinned repo/worktree selection.
+    let createdPayload = { ok: true, stackName: name, reused: true };
+    if (!stackExistsSync(name)) {
+      const createArgs = ['new', name, '--no-copy-auth', '--server', serverComponent, '--json'];
+      const created = await runCapture(process.execPath, [join(rootDir, 'scripts', 'stack.mjs'), ...createArgs], { cwd: rootDir, env: process.env }).catch((e) => {
+        throw new Error(
+          `[stack] create-dev-auth-seed: failed to create auth seed stack "${name}": ${e instanceof Error ? e.message : String(e)}`
+        );
+      });
+      createdPayload = created.trim() ? JSON.parse(created.trim()) : { ok: true, stackName: name };
+    }
 
     printResult({
       json,
@@ -994,7 +1007,7 @@ async function cmdCreateDevAuthSeed({ rootDir, argv }) {
         ok: true,
         seedStack: name,
         serverComponent,
-        created: created.trim() ? JSON.parse(created.trim()) : { ok: true },
+        created: createdPayload,
         next: {
           login: `hstack stack auth ${name} login`,
           setEnv: `# add to ${getHomeEnvLocalPath()}:\nHAPPIER_STACK_AUTH_SEED_FROM=${name}\nHAPPIER_STACK_AUTO_AUTH_SEED=1`,
@@ -1172,13 +1185,16 @@ async function cmdCreateDevAuthSeed({ rootDir, argv }) {
                 // Prefer localhost for readiness checks (faster/more reliable), even though we
                 // instruct the user to use the stack-scoped *.localhost origin for storage isolation.
                 await waitForHttpOk(uiRootLocalhost || uiRoot, { timeoutMs: 30_000 });
-                try {
-                  await assertExpoWebappBundlesOrThrow({
-                    rootDir,
-                    stackName: name,
-                    webappUrl: uiRootLocalhost || uiRoot,
-                  });
-                } catch (e) {
+	                try {
+	                  const bundleTimeoutRaw = String(process.env.HAPPIER_STACK_AUTH_EXPO_BUNDLE_READY_TIMEOUT_MS ?? '').trim();
+	                  const bundleTimeoutMs = bundleTimeoutRaw ? Number(bundleTimeoutRaw) : null;
+	                  await assertExpoWebappBundlesOrThrow({
+	                    rootDir,
+	                    stackName: name,
+	                    webappUrl: uiRootLocalhost || uiRoot,
+	                    timeoutMs: Number.isFinite(bundleTimeoutMs) && bundleTimeoutMs > 0 ? bundleTimeoutMs : undefined,
+	                  });
+	                } catch (e) {
                   const detail = e instanceof Error ? e.message : String(e);
                   throw new Error(
                     `[stack] temporary UI is reachable, but the Expo web bundle is not ready.\n` +
@@ -1223,7 +1239,7 @@ async function cmdCreateDevAuthSeed({ rootDir, argv }) {
               await runOrchestratedGuidedAuthFlow({
                 rootDir,
                 stackName: name,
-                env,
+                env: applyAuthForceEnv(env, forceAuth),
                 verbosity,
                 json: false,
               });
@@ -1622,7 +1638,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 +1655,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'),
@@ -2141,7 +2158,7 @@ async function main() {
       cmd === 'service'
         ? [
             '[stack] usage:',
-            '  hstack stack service <name> <install|uninstall|status|start|stop|restart|enable|disable|logs|tail>',
+                  '  hstack stack service <name> <install|uninstall|status|start|stop|restart|enable|disable|logs|tail> [-- ...]',
             '',
             'example:',
             '  hstack stack service exp1 status',
@@ -2162,15 +2179,23 @@ async function main() {
                 'example:',
                 '  hstack stack srv exp1 -- status',
               ]
-            : cmd === 'env'
-              ? [
-                  '[stack] usage:',
-                  '  hstack stack env <name> set KEY=VALUE [KEY2=VALUE2...]',
-                  '  hstack stack env <name> unset KEY [KEY2...]',
-                  '  hstack stack env <name> get KEY',
-                  '  hstack stack env <name> list',
-                  '  hstack stack env <name> path',
-                ]
+              : cmd === 'env'
+                ? [
+                    '[stack] usage:',
+                    '  hstack stack env <name> set KEY=VALUE [KEY2=VALUE2...]',
+                    '  hstack stack env <name> unset KEY [KEY2...]',
+                    '  hstack stack env <name> get KEY',
+                    '  hstack stack env <name> list',
+                    '  hstack stack env <name> path',
+                  ]
+                : cmd === 'runtime'
+                  ? [
+                      '[stack] usage:',
+                      '  hstack stack runtime <name> activate [--web|--server|--daemon|--all] [--json]',
+                      '',
+                      'example:',
+                      '  hstack stack runtime exp1 activate --web',
+                    ]
               : cmd === 'eas'
                 ? [
                     '[stack] usage:',
@@ -2348,7 +2373,7 @@ async function main() {
         data: { ok: false, error: 'missing_service_subcommand', stackName },
         text: [
           '[stack] usage:',
-          '  hstack stack service <name> <install|uninstall|status|start|stop|restart|enable|disable|logs|tail>',
+          '  hstack stack service <name> <install|uninstall|status|start|stop|restart|enable|disable|logs|tail> [-- ...]',
           '',
           'example:',
           `  hstack stack service ${stackName} status`,
@@ -2356,13 +2381,32 @@ async function main() {
       });
       process.exit(1);
     }
-    await cmdService({ rootDir, stackName, svcCmd });
+    await cmdService({ rootDir, stackName, svcCmd, args: passthrough.slice(1) });
+    return;
+  }
+  if (cmd === 'runtime') {
+    const runtimeCmd = passthrough[0];
+    if (runtimeCmd !== 'activate') {
+      printResult({
+        json,
+        data: { ok: false, error: 'missing_runtime_subcommand', stackName },
+        text: [
+          '[stack] usage:',
+          '  hstack stack runtime <name> activate [--web|--server|--daemon|--all] [--json]',
+          '',
+          'example:',
+          `  hstack stack runtime ${stackName} activate --web`,
+        ].join('\n'),
+      });
+      process.exit(1);
+    }
+    await cmdRuntime({ rootDir, stackName, args: passthrough.slice(1) });
     return;
   }
 
   if (cmd.startsWith('service:')) {
     const svcCmd = cmd.slice('service:'.length);
-    await cmdService({ rootDir, stackName, svcCmd });
+    await cmdService({ rootDir, stackName, svcCmd, args: passthrough });
     return;
   }
   if (cmd.startsWith('tailscale:')) {

package/scripts/stack_copy_auth_server_scoped.test.mjs

@@ -7,6 +7,7 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { resolveStackCredentialPaths } from './utils/auth/credentials_paths.mjs';
+import { pickNextFreeTcpPort } from './utils/net/ports.mjs';
 
 function runNode(args, { cwd, env }) {
   return new Promise((resolve, reject) => {
@@ -31,7 +32,7 @@ test('hstack stack new copies server-scoped credentials from source stack', asyn
   const sandboxDir = join(tmp, 'sandbox');
   const sourceStack = 'seed-auth';
   const targetStack = 'exp-copy-auth';
-  const serverPort = 4101;
+  const serverPort = await pickNextFreeTcpPort(4101, { host: '127.0.0.1' });
   const serverUrl = `http://127.0.0.1:${serverPort}`;
 
   const monoRoot = join(workspaceDir, 'tmp', 'leeroy-wip');
@@ -89,6 +90,9 @@ test('hstack stack new copies server-scoped credentials from source stack', asyn
   const targetCred = resolveStackCredentialPaths({ cliHomeDir: targetCliHome, serverUrl, env: targetStableEnv });
   const targetCredRaw = await readFile(targetCred.serverScopedPath, 'utf-8');
   assert.equal(targetCredRaw.trim(), 'seed-credential');
+  const targetEnvRaw = await readFile(join(storageDir, targetStack, 'env'), 'utf-8');
+  assert.match(targetEnvRaw, new RegExp(`^HAPPIER_STACK_AUTH_SEED_FROM=${sourceStack}$`, 'm'));
+  assert.match(targetEnvRaw, /^HAPPIER_STACK_AUTO_AUTH_SEED=1$/m);
 
   await rm(tmp, { recursive: true, force: true });
 });
@@ -104,7 +108,7 @@ test('hstack stack new copy-auth prefers source server-scoped credentials over u
   const sandboxDir = join(tmp, 'sandbox');
   const sourceStack = 'seed-auth';
   const targetStack = 'exp-copy-auth';
-  const serverPort = 4101;
+  const serverPort = await pickNextFreeTcpPort(4101, { host: '127.0.0.1' });
   const serverUrl = `http://127.0.0.1:${serverPort}`;
 
   const monoRoot = join(workspaceDir, 'tmp', 'leeroy-wip');
@@ -178,7 +182,7 @@ test('hstack stack new copy-auth copies stable-scope credentials from source sta
   const sandboxDir = join(tmp, 'sandbox');
   const sourceStack = 'seed-auth';
   const targetStack = 'exp-copy-auth';
-  const serverPort = 4101;
+  const serverPort = await pickNextFreeTcpPort(4101, { host: '127.0.0.1' });
   const serverUrl = `http://127.0.0.1:${serverPort}`;
 
   const monoRoot = join(workspaceDir, 'tmp', 'leeroy-wip');

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}`
+  );
+});