@happier-dev/stack 0.1.0 → 0.2.0

package/scripts/utils/auth/stack_guided_login.mjs

@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs';
-import { readdir, stat } from 'node:fs/promises';
+import { lstat, readdir } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 
@@ -10,7 +10,10 @@ import { getExpoStatePaths, isStateProcessRunning, looksLikeExpoMetro } from '..
 import { resolveLocalhostHost } from '../paths/localhost_host.mjs';
 import { getStackRuntimeStatePath, isPidAlive, readStackRuntimeStateFile } from '../stack/runtime_state.mjs';
 import { readEnvObjectFromFile } from '../env/read.mjs';
-import { resolveServerUrls } from '../server/urls.mjs';
+import { getWebappUrlEnvOverride, resolveServerUrls } from '../server/urls.mjs';
+import { resolveStackRuntimeLaunchContext } from '../../runtime/launch/resolveStackRuntimeLaunchContext.mjs';
+import { resolveRuntimeManifestEntrypoint } from '../../runtime/shared/runtime_manifest.mjs';
+import { resolveStackCredentialPaths } from './credentials_paths.mjs';
 
 function extractEnvVar(cmd, key) {
   const re = new RegExp(`${key}="([^"]+)"`);
@@ -138,11 +141,38 @@ async function fetchText(url, { timeoutMs = 2000 } = {}) {
   }
 }
 
+async function fetchResponse(url, { timeoutMs = 2000 } = {}) {
+  const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+  const timeout = setTimeout(() => controller?.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, { signal: controller?.signal });
+    return { ok: true, status: res.status, response: res };
+  } catch (e) {
+    return {
+      ok: false,
+      status: 0,
+      error: String(e?.message ?? e),
+      response: null,
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
 function pickHtmlBundlePath(html) {
   const m = String(html ?? '').match(/<script[^>]+src="([^"]+)"[^>]*><\/script>/i);
   return m?.[1] ? String(m[1]) : '';
 }
 
+const HAPPIER_SERVER_UI_READY_MARKER = 'Welcome to Happier Server!';
+
+function isHappierServerHtmlResponse({ ok, contentType, body }) {
+  if (!ok) return false;
+  const html = String(body ?? '');
+  const looksLikeHtml = String(contentType ?? '').includes('text/html') || /<html|<!doctype/i.test(html);
+  return looksLikeHtml && html.includes(HAPPIER_SERVER_UI_READY_MARKER);
+}
+
 export function parseExpoBundleErrorPayload(payload) {
   try {
     const parsed = JSON.parse(String(payload ?? ''));
@@ -159,21 +189,22 @@ export function parseExpoBundleErrorPayload(payload) {
 async function detectSymlinkedNodeModules({ worktreeDir }) {
   try {
     const p = join(worktreeDir, 'node_modules');
-    const st = await stat(p);
+    const st = await lstat(p);
     return Boolean(st.isSymbolicLink && st.isSymbolicLink());
   } catch {
     return false;
   }
 }
 
-export async function assertExpoWebappBundlesOrThrow({ rootDir, stackName, webappUrl }) {
+export async function assertExpoWebappBundlesOrThrow({ rootDir, stackName, webappUrl, timeoutMs = 60_000 } = {}) {
   const u = new URL(webappUrl);
   const port = u.port ? Number(u.port) : null;
   const probeHost = Number.isFinite(port) ? '127.0.0.1' : u.hostname;
   const base = `${u.protocol}//${probeHost}${u.port ? `:${u.port}` : ''}`;
 
   // Retry briefly: Metro can be up while the first bundle compile is still warming.
-  const deadline = Date.now() + 60_000;
+  const timeout = Number(timeoutMs);
+  const deadline = Date.now() + (Number.isFinite(timeout) && timeout > 0 ? timeout : 60_000);
   let lastError = '';
   while (Date.now() < deadline) {
     // eslint-disable-next-line no-await-in-loop
@@ -181,7 +212,8 @@ export async function assertExpoWebappBundlesOrThrow({ rootDir, stackName, webap
     if (!htmlRes.ok) {
       lastError = `HTTP ${htmlRes.status} loading ${base}/`;
       // eslint-disable-next-line no-await-in-loop
-      await delay(500);
+      if (Date.now() >= deadline) break;
+      await delay(Math.min(500, Math.max(0, deadline - Date.now())));
       continue;
     }
 
@@ -189,18 +221,22 @@ export async function assertExpoWebappBundlesOrThrow({ rootDir, stackName, webap
     if (!bundlePath) {
       lastError = `could not find bundle <script src> in ${base}/`;
       // eslint-disable-next-line no-await-in-loop
-      await delay(500);
+      if (Date.now() >= deadline) break;
+      await delay(Math.min(500, Math.max(0, deadline - Date.now())));
       continue;
     }
 
     // eslint-disable-next-line no-await-in-loop
-    const bundleRes = await fetchText(`${base}${bundlePath.startsWith('/') ? '' : '/'}${bundlePath}`, { timeoutMs: 8000 });
-    if (bundleRes.ok) {
+    const bundleRes = await fetchResponse(`${base}${bundlePath.startsWith('/') ? '' : '/'}${bundlePath}`, { timeoutMs: 8000 });
+    if (bundleRes.ok && bundleRes.status >= 200 && bundleRes.status < 300) {
+      bundleRes.response?.body?.cancel?.().catch?.(() => {});
       return;
     }
 
     // Metro resolver errors are deterministic: surface immediately with actionable hints.
-    const bundleError = parseExpoBundleErrorPayload(bundleRes.text);
+    const bundleText = bundleRes.response ? await bundleRes.response.text().catch(() => '') : String(bundleRes.error ?? '');
+    bundleRes.response?.body?.cancel?.().catch?.(() => {});
+    const bundleError = parseExpoBundleErrorPayload(bundleText);
     if (bundleError?.isResolverError) {
       let hint = '';
       try {
@@ -227,7 +263,8 @@ export async function assertExpoWebappBundlesOrThrow({ rootDir, stackName, webap
 
     lastError = `HTTP ${bundleRes.status} loading bundle ${bundlePath}`;
     // eslint-disable-next-line no-await-in-loop
-    await delay(500);
+    if (Date.now() >= deadline) break;
+    await delay(Math.min(500, Math.max(0, deadline - Date.now())));
   }
 
   if (lastError) {
@@ -240,19 +277,80 @@ export async function assertExpoWebappBundlesOrThrow({ rootDir, stackName, webap
   }
 }
 
-export async function resolveStackWebappUrlForAuth({ rootDir, stackName, env = process.env }) {
-  // Fast path: runtime Expo metadata is a hint, but only accepted when liveness checks pass.
+async function assertServerWebappReadyOrThrow({ webappUrl, timeoutMs = 30_000 } = {}) {
+  const timeout = Number(timeoutMs);
+  const deadline = Date.now() + (Number.isFinite(timeout) && timeout > 0 ? timeout : 30_000);
+  let lastError = '';
+  while (Date.now() < deadline) {
+    // eslint-disable-next-line no-await-in-loop
+    const rootRes = await fetchText(webappUrl, { timeoutMs: 2500 });
+    const contentType = String(rootRes.headers?.get?.('content-type') ?? '').toLowerCase();
+    const body = String(rootRes.text ?? '');
+    if (isHappierServerHtmlResponse({ ok: rootRes.ok, contentType, body })) {
+      return;
+    }
+    lastError = rootRes.ok
+      ? contentType.includes('text/html') || /<html|<!doctype/i.test(body)
+        ? `missing Happier UI readiness marker at ${webappUrl}`
+        : `non-html response from ${webappUrl}`
+      : `HTTP ${rootRes.status} loading ${webappUrl}`;
+    // eslint-disable-next-line no-await-in-loop
+    await delay(Math.min(500, Math.max(0, deadline - Date.now())));
+  }
+
+  throw new Error(
+    '[auth] stack-served web UI did not become ready for guided login.\n' +
+      `[auth] URL: ${webappUrl}\n` +
+      `[auth] Last error: ${lastError || 'unknown error'}\n`
+  );
+}
+
+export async function assertGuidedAuthWebappReadyOrThrow({ rootDir, stackName, webappUrl, kind = 'expo', timeoutMs } = {}) {
+  if (kind === 'server') {
+    await assertServerWebappReadyOrThrow({ webappUrl, timeoutMs });
+    return;
+  }
+  await assertExpoWebappBundlesOrThrow({ rootDir, stackName, webappUrl, timeoutMs });
+}
+
+async function resolveServerWebappUrlForAuth({ stackName, env = process.env }) {
+  const { envWebappUrl } = getWebappUrlEnvOverride({ env, stackName });
+  if (envWebappUrl) {
+    return await preferStackLocalhostUrl(envWebappUrl, { stackName });
+  }
+
+  const serverPort = await resolveServerPortForCoreAuth({ stackName, env });
+  if (!serverPort) return '';
+
+  const localhostUrl = await preferStackLocalhostUrl(`http://localhost:${serverPort}`, { stackName });
+  if (localhostUrl) return localhostUrl;
+
+  const resolved = await resolveServerUrls({
+    env,
+    serverPort,
+    allowEnable: false,
+  });
+  return resolved.publicServerUrl ? await preferStackLocalhostUrl(resolved.publicServerUrl, { stackName }) : '';
+}
+
+export async function resolveStackWebappTargetForAuth({ rootDir, stackName, env = process.env } = {}) {
+  const runtimeLaunchContext = await resolveStackRuntimeLaunchContext({ argv: [], env });
+  if (runtimeLaunchContext.snapshot) {
+    const runtimeServerUrl = await resolveServerWebappUrlForAuth({ stackName, env });
+    if (runtimeServerUrl) {
+      return { webappUrl: runtimeServerUrl, kind: 'server' };
+    }
+  }
+
   const runtimeExpoUrl = await resolveRuntimeExpoWebappUrlForAuth({ stackName });
   if (runtimeExpoUrl) {
-    return await preferStackLocalhostUrl(runtimeExpoUrl, { stackName });
+    return { webappUrl: await preferStackLocalhostUrl(runtimeExpoUrl, { stackName }), kind: 'expo' };
   }
 
   const authFlow =
     (env.HAPPIER_STACK_AUTH_FLOW ?? '').toString().trim() === '1' ||
     (env.HAPPIER_STACK_DAEMON_WAIT_FOR_AUTH ?? '').toString().trim() === '1';
 
-  // Prefer the Expo web UI URL when running in dev mode.
-  // This is crucial for guided login: the browser needs the UI origin, not the server port.
   const timeoutMsRaw =
     (env.HAPPIER_STACK_AUTH_UI_READY_TIMEOUT_MS ?? '180000').toString().trim();
   const timeoutMs = timeoutMsRaw ? Number(timeoutMsRaw) : 180_000;
@@ -262,10 +360,9 @@ export async function resolveStackWebappUrlForAuth({ rootDir, stackName, env = p
     timeoutMs: Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 180_000,
   });
   if (expoUrl) {
-    return await preferStackLocalhostUrl(expoUrl, { stackName });
+    return { webappUrl: await preferStackLocalhostUrl(expoUrl, { stackName }), kind: 'expo' };
   }
 
-  // Fail closed for guided auth flows: falling back to server URLs opens the wrong origin.
   if (authFlow) {
     throw new Error(
       `[auth] failed to resolve Expo web UI URL for guided login.\n` +
@@ -286,12 +383,17 @@ export async function resolveStackWebappUrlForAuth({ rootDir, stackName, env = p
     const parsed = JSON.parse(String(raw ?? '').trim());
     const cmd = typeof parsed?.cmd === 'string' ? parsed.cmd : '';
     const url = extractEnvVar(cmd, 'HAPPIER_WEBAPP_URL');
-    return url ? await preferStackLocalhostUrl(url, { stackName }) : '';
+    return { webappUrl: url ? await preferStackLocalhostUrl(url, { stackName }) : '', kind: 'server' };
   } catch {
-    return '';
+    return { webappUrl: '', kind: 'server' };
   }
 }
 
+export async function resolveStackWebappUrlForAuth({ rootDir, stackName, env = process.env }) {
+  const resolved = await resolveStackWebappTargetForAuth({ rootDir, stackName, env });
+  return String(resolved?.webappUrl ?? '').trim();
+}
+
 function resolvePortFromUrl(urlRaw) {
   const raw = String(urlRaw ?? '').trim();
   if (!raw) return null;
@@ -353,6 +455,11 @@ async function prepareCoreAuthEnv({ stackName, webappUrl, env = process.env } =
     String(merged.HAPPIER_HOME_DIR ?? '').trim() ||
     String(merged.HAPPIER_STACK_CLI_HOME_DIR ?? '').trim() ||
     join(baseDir, 'cli');
+  const credentialPaths = resolveStackCredentialPaths({
+    cliHomeDir,
+    serverUrl: internalServerUrl,
+    env: merged,
+  });
 
   return {
     ...merged,
@@ -360,10 +467,40 @@ async function prepareCoreAuthEnv({ stackName, webappUrl, env = process.env } =
     HAPPIER_SERVER_URL: internalServerUrl,
     HAPPIER_PUBLIC_SERVER_URL: publicServerUrl,
     HAPPIER_WEBAPP_URL: webappUrl,
+    ...(credentialPaths.activeServerId ? { HAPPIER_ACTIVE_SERVER_ID: credentialPaths.activeServerId } : {}),
   };
 }
 
-export function buildStackAuthLoginInvocation({ rootDir, stackName, webappUrl, env = process.env } = {}) {
+export async function resolveStackAuthCliExecutable({ rootDir, env = process.env } = {}) {
+  const runtimeLaunchContext = await resolveStackRuntimeLaunchContext({ argv: [], env });
+  const runtimeCliPath = runtimeLaunchContext.snapshot
+    ? resolveRuntimeManifestEntrypoint({
+        snapshotPath: runtimeLaunchContext.snapshot.snapshotPath,
+        manifest: runtimeLaunchContext.snapshot.manifest,
+        component: 'daemon',
+      })
+    : '';
+  if (runtimeCliPath) {
+    return runtimeCliPath;
+  }
+
+  const cliDir = getComponentDir(rootDir, 'happier-cli', env);
+  const preferredEntrypoints = [
+    join(cliDir, 'package-dist', 'index.mjs'),
+    join(cliDir, 'dist', 'index.mjs'),
+    join(cliDir, 'bin', 'happier.mjs'),
+  ];
+
+  for (const candidate of preferredEntrypoints) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return preferredEntrypoints[0];
+}
+
+export async function buildStackAuthLoginInvocation({ rootDir, stackName, webappUrl, env = process.env } = {}) {
   const root = String(rootDir ?? '').trim();
   if (!root) {
     throw new Error('[auth] buildStackAuthLoginInvocation requires rootDir');
@@ -372,7 +509,7 @@ export function buildStackAuthLoginInvocation({ rootDir, stackName, webappUrl, e
   if (!url) {
     throw new Error('[auth] buildStackAuthLoginInvocation requires a webappUrl');
   }
-  const cliBin = join(getComponentDir(root, 'happier-cli', env), 'bin', 'happier.mjs');
+  const cliExecutable = await resolveStackAuthCliExecutable({ rootDir: root, env });
   const merged = { ...(env ?? process.env), HAPPIER_WEBAPP_URL: url };
   const method = String(merged.HAPPIER_AUTH_METHOD ?? '').trim().toLowerCase();
   if (method && method !== 'web' && method !== 'browser' && method !== 'mobile') {
@@ -380,7 +517,9 @@ export function buildStackAuthLoginInvocation({ rootDir, stackName, webappUrl, e
   }
   const normalizedMethod = method === 'browser' ? 'web' : method;
 
-  const args = [cliBin, 'auth', 'login'];
+  const executableLooksLikeScript = cliExecutable.endsWith('.mjs') || cliExecutable.endsWith('.js') || cliExecutable.endsWith('.cjs');
+  const command = executableLooksLikeScript ? process.execPath : cliExecutable;
+  const args = executableLooksLikeScript ? [cliExecutable, 'auth', 'login'] : ['auth', 'login'];
   if (String(merged.HAPPIER_AUTH_FORCE ?? '').trim() === '1') {
     args.push('--force');
   }
@@ -392,14 +531,19 @@ export function buildStackAuthLoginInvocation({ rootDir, stackName, webappUrl, e
   }
 
   return {
+    command,
     args,
     env: merged,
   };
 }
 
-export async function guidedStackAuthLoginNow({ rootDir, stackName, env = process.env, webappUrl = null }) {
+export async function guidedStackAuthLoginNow({ rootDir, stackName, env = process.env, webappUrl = null, webappKind = '' }) {
   const name = String(stackName ?? '').trim() || 'main';
-  const resolved = (webappUrl ?? '').toString().trim() || (await resolveStackWebappUrlForAuth({ rootDir, stackName: name, env }));
+  const resolvedTarget =
+    (webappUrl ?? '').toString().trim()
+      ? { webappUrl: String(webappUrl).trim(), kind: String(webappKind ?? '').trim() || 'server' }
+      : await resolveStackWebappTargetForAuth({ rootDir, stackName: name, env });
+  const resolved = String(resolvedTarget?.webappUrl ?? '').trim();
   if (!resolved) {
     throw new Error('[auth] cannot start guided login: web UI URL is empty');
   }
@@ -407,12 +551,20 @@ export async function guidedStackAuthLoginNow({ rootDir, stackName, env = proces
   const skipBundleCheck = (env.HAPPIER_STACK_AUTH_SKIP_BUNDLE_CHECK ?? '').toString().trim() === '1';
   // Surface common "blank page" issues (Metro resolver errors) even in quiet mode.
   if (!skipBundleCheck) {
-    await assertExpoWebappBundlesOrThrow({ rootDir, stackName: name, webappUrl: resolved });
+    const timeoutMsRaw = String(env.HAPPIER_STACK_AUTH_EXPO_BUNDLE_READY_TIMEOUT_MS ?? '').trim();
+    const timeoutMs = timeoutMsRaw ? Number(timeoutMsRaw) : null;
+    await assertGuidedAuthWebappReadyOrThrow({
+      rootDir,
+      stackName: name,
+      webappUrl: resolved,
+      kind: resolvedTarget.kind,
+      timeoutMs: Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined,
+    });
   }
 
   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 });
+  const inv = await buildStackAuthLoginInvocation({ rootDir, stackName: name, webappUrl: resolved, env: preparedEnv });
+  await run(inv.command, inv.args, { cwd: rootDir, env: inv.env });
 }
 
 export async function stackAuthCopyFrom({ rootDir, stackName, fromStackName, env = process.env, link = true }) {

package/scripts/utils/cli/cliDistIntegrity.mjs

@@ -0,0 +1,86 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+export function isCliScriptEntrypoint(pathLike) {
+  const value = String(pathLike ?? '').trim().toLowerCase();
+  return value.endsWith('.mjs') || value.endsWith('.js') || value.endsWith('.cjs');
+}
+
+export function isCliDirectExecutableCommand(cliBin) {
+  const bin = String(cliBin ?? '').trim();
+  if (!bin) return false;
+  return !isCliScriptEntrypoint(bin);
+}
+
+export function resolveCliDistEntrypointFromBin(cliBin) {
+  const bin = String(cliBin ?? '').trim();
+  if (!bin) return null;
+  if (!isCliScriptEntrypoint(bin)) return null;
+  try {
+    const binDir = dirname(bin);
+    return join(binDir, '..', 'dist', 'index.mjs');
+  } catch {
+    return null;
+  }
+}
+
+function extractRelativeMjsImportSpecifiers(source) {
+  const specs = new Set();
+  const patterns = [
+    /(?:^|[^\w$])import\s+(?:[^'"]*?\s+from\s*)?['"]([^'"]+)['"]/gm,
+    /(?:^|[^\w$])export\s+[^'"]*?\s+from\s*['"]([^'"]+)['"]/gm,
+    /import\s*\(\s*['"]([^'"]+)['"]\s*\)/gm,
+  ];
+  for (const re of patterns) {
+    for (const match of source.matchAll(re)) {
+      const spec = String(match?.[1] ?? '').trim();
+      if (!spec || !spec.startsWith('.')) continue;
+      if (!spec.endsWith('.mjs')) continue;
+      specs.add(spec);
+    }
+  }
+  return [...specs];
+}
+
+export function findMissingCliDistModules(entrypoint, maxFiles = 400) {
+  const missing = [];
+  const seen = new Set();
+  const queue = [entrypoint];
+  while (queue.length > 0 && seen.size < maxFiles) {
+    const filePath = queue.shift();
+    if (!filePath || seen.has(filePath)) continue;
+    seen.add(filePath);
+
+    let source = '';
+    try {
+      source = readFileSync(filePath, 'utf-8');
+    } catch {
+      missing.push(filePath);
+      continue;
+    }
+
+    const imports = extractRelativeMjsImportSpecifiers(source);
+    for (const spec of imports) {
+      const target = join(dirname(filePath), spec);
+      if (!existsSync(target)) {
+        missing.push(target);
+        continue;
+      }
+      if (!seen.has(target)) {
+        queue.push(target);
+      }
+    }
+  }
+  return missing;
+}
+
+export function readCliDistIntegrity(entrypoint) {
+  if (!entrypoint || !existsSync(entrypoint)) {
+    return { ok: false, reason: 'missing_entrypoint' };
+  }
+  const missing = findMissingCliDistModules(entrypoint);
+  if (missing.length === 0) {
+    return { ok: true, reason: 'exists' };
+  }
+  return { ok: false, reason: `incomplete:${missing[0]}` };
+}

package/scripts/utils/cli/cli_registry.mjs

@@ -26,8 +26,16 @@ export function gethstackRegistry() {
       name: 'setup',
       kind: 'node',
       scriptRelPath: 'scripts/setup.mjs',
-      rootUsage: 'hstack setup [--profile=selfhost|dev] [--json]',
-      description: 'Guided setup (selfhost or dev)',
+      rootUsage: 'hstack setup [--profile=selfhost|dev|local-repo] [--json]',
+      description: 'DEPRECATED: use setup-from-source (or self-host)',
+    },
+    {
+      name: 'setup-from-source',
+      aliases: ['setup-fromsource', 'setupFromSource'],
+      kind: 'node',
+      scriptRelPath: 'scripts/setup.mjs',
+      rootUsage: 'hstack setup-from-source [--profile=selfhost|dev|local-repo] [--stable-branch=<name>] [--json]',
+      description: 'Guided from-source setup (workspace + deps)',
     },
     {
       name: 'contrib',
@@ -250,10 +258,11 @@ export function gethstackRegistry() {
       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]',
+          'hstack remote daemon setup --ssh <user@host> [--preview|--dev|--stable] [--channel <stable|preview|dev>] [--service <user|none>] [--ssh-config-file=<path>] [--server-url=<url>] [--webapp-url=<url>] [--public-server-url=<url>] [--json]',
+          'hstack remote server setup --ssh <user@host> [--preview|--dev|--stable] [--channel <stable|preview|dev>] [--mode <user|system>] [--self-host-server-binary <path>] [--env KEY=VALUE]... [--json]',
+          'hstack remote relay setup --ssh <user@host> [--preview|--dev|--stable] [--channel <stable|preview|dev>] [--mode <user|system>] [--self-host-server-binary <path>] [--env KEY=VALUE]... [--json]',
         ],
-      description: 'Remote setup helpers (SSH daemon/server setup)',
+      description: 'Remote setup helpers (SSH verified bootstrap + daemon/server setup)',
     },
     {
       name: 'providers',

package/scripts/utils/cli/cwd_scope.mjs

@@ -8,11 +8,19 @@ export function getInvokedCwd(env = process.env) {
   const explicit = String(env.HAPPIER_STACK_INVOKED_CWD ?? '').trim();
   if (explicit) return explicit;
 
+  const actualCwd = String(process.cwd()).trim();
+
   const pwd = String(env.PWD ?? '').trim();
   // Prefer PWD when it already looks like a checkout/worktree root.
   // This avoids surprising behavior when OLDPWD points at a different repo/worktree.
   if (pwd) {
     try {
+      // When callers spawn this process with an explicit cwd, `process.cwd()` reflects that cwd,
+      // but `PWD` can still be inherited from the parent environment (and therefore be stale).
+      // If they disagree, prefer the actual cwd.
+      if (actualCwd && resolve(pwd) !== resolve(actualCwd)) {
+        return actualCwd;
+      }
       if (existsSync(pwd) && existsSync(join(pwd, '.git'))) {
         return pwd;
       }
@@ -34,7 +42,7 @@ export function getInvokedCwd(env = process.env) {
     }
   }
 
-  return pwd || String(process.cwd()).trim();
+  return pwd || actualCwd;
 }
 
 function hasGitMarker(dir) {

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

@@ -1,28 +1,16 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtemp, mkdir, realpath, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
+import { mkdir, realpath } from 'node:fs/promises';
 import { join } from 'node:path';
 
+import { createTempFixture } from '../../testkit/core/temp_fixture.mjs';
+import { ensureMinimalMonorepoLayout } from '../../testkit/core/minimal_monorepo_layout.mjs';
 import { getInvokedCwd, inferComponentFromCwd } from './cwd_scope.mjs';
 
-async function withTempRoot(t) {
-  const dir = await mkdtemp(join(tmpdir(), 'happier-stacks-cwd-scope-'));
-  t.after(async () => {
-    await rm(dir, { recursive: true, force: true });
-  });
-  return dir;
-}
-
 async function createMonorepoCheckout({ rootDir, checkoutPath }) {
   const repoRoot = join(rootDir, checkoutPath);
-  await mkdir(join(repoRoot, 'apps', 'ui'), { recursive: true });
+  await ensureMinimalMonorepoLayout(repoRoot, { writeGitDirMarker: true });
   await mkdir(join(repoRoot, 'apps', 'cli', 'src'), { recursive: true });
-  await mkdir(join(repoRoot, 'apps', 'server'), { recursive: true });
-  await writeFile(join(repoRoot, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
-  await writeFile(join(repoRoot, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
-  await writeFile(join(repoRoot, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
-  await writeFile(join(repoRoot, '.git'), 'gitdir: /tmp/fake\n', 'utf-8');
   return repoRoot;
 }
 
@@ -43,7 +31,8 @@ function withMockedProcessCwd(t, value) {
 }
 
 test('inferComponentFromCwd resolves the stable monorepo checkout under <workspace>/main', async (t) => {
-  const rootDir = await withTempRoot(t);
+  const fixture = await createTempFixture(t, { prefix: 'happier-stacks-cwd-scope-' });
+  const rootDir = fixture.root;
   const repoRoot = await createMonorepoCheckout({ rootDir, checkoutPath: 'main' });
   const inferred = inferComponentFromCwd({
     rootDir,
@@ -55,7 +44,8 @@ test('inferComponentFromCwd resolves the stable monorepo checkout under <workspa
 });
 
 test('inferComponentFromCwd resolves happier monorepo subpackages under <workspace>/main', async (t) => {
-  const rootDir = await withTempRoot(t);
+  const fixture = await createTempFixture(t, { prefix: 'happier-stacks-cwd-scope-' });
+  const rootDir = fixture.root;
   const repoRoot = await createMonorepoCheckout({ rootDir, checkoutPath: 'main' });
   const inferred = inferComponentFromCwd({
     rootDir,
@@ -67,7 +57,8 @@ test('inferComponentFromCwd resolves happier monorepo subpackages under <workspa
 });
 
 test('inferComponentFromCwd resolves happier monorepo worktree roots under <workspace>/pr', async (t) => {
-  const rootDir = await withTempRoot(t);
+  const fixture = await createTempFixture(t, { prefix: 'happier-stacks-cwd-scope-' });
+  const rootDir = fixture.root;
   const repoRoot = await createMonorepoCheckout({ rootDir, checkoutPath: join('pr', '123-fix') });
   await mkdir(join(repoRoot, 'apps', 'cli', 'nested'), { recursive: true });
   const inferred = inferComponentFromCwd({
@@ -80,7 +71,8 @@ test('inferComponentFromCwd resolves happier monorepo worktree roots under <work
 });
 
 test('inferComponentFromCwd returns null outside known component roots', async (t) => {
-  const rootDir = await withTempRoot(t);
+  const fixture = await createTempFixture(t, { prefix: 'happier-stacks-cwd-scope-' });
+  const rootDir = fixture.root;
   const invokedCwd = join(rootDir, 'somewhere', 'else');
   await mkdir(invokedCwd, { recursive: true });
   const inferred = inferComponentFromCwd({
@@ -93,7 +85,8 @@ test('inferComponentFromCwd returns null outside known component roots', async (
 });
 
 test('inferComponentFromCwd uses the provided env (does not depend on process.env)', async (t) => {
-  const rootDir = await withTempRoot(t);
+  const fixture = await createTempFixture(t, { prefix: 'happier-stacks-cwd-scope-' });
+  const rootDir = fixture.root;
   const repoRoot = await createMonorepoCheckout({ rootDir, checkoutPath: 'main' });
   const inferred = inferComponentFromCwd({
     rootDir,
@@ -105,7 +98,8 @@ test('inferComponentFromCwd uses the provided env (does not depend on process.en
 });
 
 test('getInvokedCwd falls back to process.cwd() when PWD is not set (Windows)', async (t) => {
-  const dir = await withTempRoot(t);
+  const fixture = await createTempFixture(t, { prefix: 'happier-stacks-cwd-scope-' });
+  const dir = fixture.root;
   const expected = await realpath(dir).catch(() => dir);
   withMockedProcessCwd(t, dir);
 
@@ -114,12 +108,13 @@ test('getInvokedCwd falls back to process.cwd() when PWD is not set (Windows)',
 });
 
 test('getInvokedCwd prefers OLDPWD when it looks like the real repo/worktree root', async (t) => {
-  const rootDir = await withTempRoot(t);
+  const fixture = await createTempFixture(t, { prefix: 'happier-stacks-cwd-scope-' });
+  const rootDir = fixture.root;
   const oldPwd = join(rootDir, 'dev');
   const pwd = join(rootDir, 'main');
   await mkdir(oldPwd, { recursive: true });
   await mkdir(pwd, { recursive: true });
-  await writeFile(join(oldPwd, '.git'), 'gitdir: /tmp/fake\n', 'utf-8');
+  await ensureMinimalMonorepoLayout(oldPwd, { writeGitDirMarker: true });
 
   withMockedProcessCwd(t, pwd);
   const actual = getInvokedCwd({ PWD: pwd, OLDPWD: oldPwd });
@@ -127,13 +122,12 @@ test('getInvokedCwd prefers OLDPWD when it looks like the real repo/worktree roo
 });
 
 test('getInvokedCwd prefers PWD when both PWD and OLDPWD look like repo/worktree roots', async (t) => {
-  const rootDir = await withTempRoot(t);
+  const fixture = await createTempFixture(t, { prefix: 'happier-stacks-cwd-scope-' });
+  const rootDir = fixture.root;
   const oldPwd = join(rootDir, 'dev');
   const pwd = join(rootDir, 'main');
-  await mkdir(oldPwd, { recursive: true });
-  await mkdir(pwd, { recursive: true });
-  await writeFile(join(oldPwd, '.git'), 'gitdir: /tmp/fake\n', 'utf-8');
-  await writeFile(join(pwd, '.git'), 'gitdir: /tmp/fake\n', 'utf-8');
+  await ensureMinimalMonorepoLayout(oldPwd, { writeGitDirMarker: true });
+  await ensureMinimalMonorepoLayout(pwd, { writeGitDirMarker: true });
 
   withMockedProcessCwd(t, pwd);
   const actual = getInvokedCwd({ PWD: pwd, OLDPWD: oldPwd });
@@ -141,12 +135,13 @@ test('getInvokedCwd prefers PWD when both PWD and OLDPWD look like repo/worktree
 });
 
 test('getInvokedCwd falls back to OLDPWD when PWD does not look like a checkout/worktree root', async (t) => {
-  const rootDir = await withTempRoot(t);
+  const fixture = await createTempFixture(t, { prefix: 'happier-stacks-cwd-scope-' });
+  const rootDir = fixture.root;
   const oldPwd = join(rootDir, 'dev');
   const pwd = join(rootDir, 'not-a-worktree');
   await mkdir(oldPwd, { recursive: true });
   await mkdir(pwd, { recursive: true });
-  await writeFile(join(oldPwd, '.git'), 'gitdir: /tmp/fake\n', 'utf-8');
+  await ensureMinimalMonorepoLayout(oldPwd, { writeGitDirMarker: true });
 
   withMockedProcessCwd(t, pwd);
   const actual = getInvokedCwd({ PWD: pwd, OLDPWD: oldPwd });